/[gxemul]/upstream/0.3.6.2/src/machine.c
This is repository of my old source code which isn't updated any more. Go to git.rot13.org for current projects!
ViewVC logotype

Contents of /upstream/0.3.6.2/src/machine.c

Parent Directory Parent Directory | Revision Log Revision Log

Revision 19 - (show annotations)
Mon Oct 8 16:19:16 2007 UTC (16 years, 8 months ago) by dpavlin
File MIME type: text/plain
File size: 198455 byte(s) 
0.3.6.2
1 /*
2 * Copyright (C) 2003-2005 Anders Gavare. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions are met:
6 *
7 * 1. Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
12 * 3. The name of the author may not be used to endorse or promote products
13 * derived from this software without specific prior written permission.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25 * SUCH DAMAGE.
26 *
27 *
28 * $Id: machine.c,v 1.577 2005/10/27 14:01:12 debug Exp $
29 *
30 * Emulation of specific machines.
31 *
32 * This module is quite large. Hopefully it is still clear enough to be
33 * easily understood. The main parts are:
34 *
35 * Helper functions.
36 *
37 * Machine specific Interrupt routines.
38 *
39 * Machine specific Initialization routines.
40 */
41
42 #include <stdio.h>
43 #include <stdlib.h>
44 #include <stdarg.h>
45 #ifdef SOLARIS
46 #include <strings.h>
47 #else
48 #include <string.h>
49 #endif
50 #include <time.h>
51 #include <unistd.h>
52
53 #include "arcbios.h"
54 #include "bus_pci.h"
55 #include "cpu.h"
56 #include "device.h"
57 #include "devices.h"
58 #include "diskimage.h"
59 #include "emul.h"
60 #include "machine.h"
61 #include "memory.h"
62 #include "misc.h"
63 #include "mp.h"
64 #include "net.h"
65 #include "symbol.h"
66
67 /* For Alpha emulation: */
68 #include "alpha_rpb.h"
69
70 /* For CATS emulation: */
71 #include "cyclone_boot.h"
72
73 /* For SGI and ARC emulation: */
74 #include "sgi_arcbios.h"
75 #include "crimereg.h"
76
77 /* For evbmips emulation: */
78 #include "maltareg.h"
79
80 /* For DECstation emulation: */
81 #include "dec_prom.h"
82 #include "dec_bootinfo.h"
83 #include "dec_5100.h"
84 #include "dec_kn01.h"
85 #include "dec_kn02.h"
86 #include "dec_kn03.h"
87 #include "dec_kmin.h"
88 #include "dec_maxine.h"
89
90 /* HPC: */
91 #include "hpc_bootinfo.h"
92 #include "vripreg.h"
93
94 #define BOOTSTR_BUFLEN 1000
95 #define BOOTARG_BUFLEN 2000
96 #define ETHERNET_STRING_MAXLEN 40
97
98 struct machine_entry_subtype {
99 int machine_subtype;/* Old-style subtype */
100 const char *name; /* Official name */
101 int n_aliases;
102 char **aliases; /* Aliases */
103 };
104
105 struct machine_entry {
106 struct machine_entry *next;
107
108 /* Machine type: */
109 int arch;
110 int machine_type; /* Old-style type */
111 const char *name; /* Official name */
112 int n_aliases;
113 char **aliases; /* Aliases */
114
115 /* Machine subtypes: */
116 int n_subtypes;
117 struct machine_entry_subtype **subtype;
118 };
119
120
121 /* See main.c: */
122 extern int quiet_mode;
123
124
125 /* This is initialized by machine_init(): */
126 static struct machine_entry *first_machine_entry = NULL;
127
128
129 /*
130 * machine_new():
131 *
132 * Returns a reasonably initialized struct machine.
133 */
134 struct machine *machine_new(char *name, struct emul *emul)
135 {
136 struct machine *m;
137 m = malloc(sizeof(struct machine));
138 if (m == NULL) {
139 fprintf(stderr, "machine_new(): out of memory\n");
140 exit(1);
141 }
142
143 memset(m, 0, sizeof(struct machine));
144
145 /* Back pointer: */
146 m->emul = emul;
147
148 m->name = strdup(name);
149
150 /* Sane default values: */
151 m->serial_nr = 1;
152 m->machine_type = MACHINE_NONE;
153 m->machine_subtype = MACHINE_NONE;
154 #ifdef BINTRANS
155 m->bintrans_enable = 1;
156 m->old_bintrans_enable = 1;
157 #endif
158 m->arch_pagesize = 4096; /* Should be overriden in
159 emul.c for other pagesizes. */
160 m->dyntrans_alignment_check = 1;
161 m->prom_emulation = 1;
162 m->speed_tricks = 1;
163 m->byte_order_override = NO_BYTE_ORDER_OVERRIDE;
164 m->boot_kernel_filename = "";
165 m->boot_string_argument = NULL;
166 m->automatic_clock_adjustment = 1;
167 m->x11_scaledown = 1;
168 m->n_gfx_cards = 1;
169 m->dbe_on_nonexistant_memaccess = 1;
170 m->show_symbolic_register_names = 1;
171 m->bintrans_size = DEFAULT_BINTRANS_SIZE_IN_MB * 1048576;
172 symbol_init(&m->symbol_context);
173
174 return m;
175 }
176
177
178 /*
179 * machine_name_to_type():
180 *
181 * Take a type and a subtype as strings, and convert them into numeric
182 * values used internally throughout the code.
183 *
184 * Return value is 1 on success, 0 if there was no match.
185 * Also, any errors/warnings are printed using fatal()/debug().
186 */
187 int machine_name_to_type(char *stype, char *ssubtype,
188 int *type, int *subtype, int *arch)
189 {
190 struct machine_entry *me;
191 int i, j, k, nmatches = 0;
192
193 *type = MACHINE_NONE;
194 *subtype = 0;
195
196 /* Check stype, and optionally ssubtype: */
197 me = first_machine_entry;
198 while (me != NULL) {
199 for (i=0; i<me->n_aliases; i++)
200 if (strcasecmp(me->aliases[i], stype) == 0) {
201 /* Found a type: */
202 *type = me->machine_type;
203 *arch = me->arch;
204
205 if (me->n_subtypes == 0)
206 return 1;
207
208 /* Check for subtype: */
209 for (j=0; j<me->n_subtypes; j++)
210 for (k=0; k<me->subtype[j]->n_aliases;
211 k++)
212 if (strcasecmp(ssubtype,
213 me->subtype[j]->aliases[k]
214 ) == 0) {
215 *subtype = me->subtype[
216 j]->machine_subtype;
217 return 1;
218 }
219
220 fatal("Unknown subtype '%s' for emulation"
221 " '%s'\n", ssubtype, stype);
222 if (!ssubtype[0])
223 fatal("(Maybe you forgot the -e"
224 " command line option?)\n");
225 exit(1);
226 }
227
228 me = me->next;
229 }
230
231 /* Not found? Then just check ssubtype: */
232 me = first_machine_entry;
233 while (me != NULL) {
234 if (me->n_subtypes == 0) {
235 me = me->next;
236 continue;
237 }
238
239 /* Check for subtype: */
240 for (j=0; j<me->n_subtypes; j++)
241 for (k=0; k<me->subtype[j]->n_aliases; k++)
242 if (strcasecmp(ssubtype, me->subtype[j]->
243 aliases[k]) == 0) {
244 *type = me->machine_type;
245 *arch = me->arch;
246 *subtype = me->subtype[j]->
247 machine_subtype;
248 nmatches ++;
249 }
250
251 me = me->next;
252 }
253
254 switch (nmatches) {
255 case 0: fatal("\nSorry, emulation \"%s\"", stype);
256 if (ssubtype != NULL && ssubtype[0] != '\0')
257 fatal(" (subtype \"%s\")", ssubtype);
258 fatal(" is unknown.\n");
259 break;
260 case 1: return 1;
261 default:fatal("\nSorry, multiple matches for \"%s\"", stype);
262 if (ssubtype != NULL && ssubtype[0] != '\0')
263 fatal(" (subtype \"%s\")", ssubtype);
264 fatal(".\n");
265 }
266
267 *type = MACHINE_NONE;
268 *subtype = 0;
269
270 fatal("Use the -H command line option to get a list of "
271 "available types and subtypes.\n\n");
272
273 return 0;
274 }
275
276
277 /*
278 * machine_add_tickfunction():
279 *
280 * Adds a tick function (a function called every now and then, depending on
281 * clock cycle count) to a machine.
282 */
283 void machine_add_tickfunction(struct machine *machine, void (*func)
284 (struct cpu *, void *), void *extra, int clockshift)
285 {
286 int n = machine->n_tick_entries;
287
288 if (n >= MAX_TICK_FUNCTIONS) {
289 fprintf(stderr, "machine_add_tickfunction(): too "
290 "many tick functions\n");
291 exit(1);
292 }
293
294 /* Don't use too low clockshifts, that would be too inefficient
295 with bintrans. */
296 if (clockshift < N_SAFE_BINTRANS_LIMIT_SHIFT)
297 fatal("WARNING! clockshift = %i, less than "
298 "N_SAFE_BINTRANS_LIMIT_SHIFT (%i)\n",
299 clockshift, N_SAFE_BINTRANS_LIMIT_SHIFT);
300
301 machine->ticks_till_next[n] = 0;
302 machine->ticks_reset_value[n] = 1 << clockshift;
303 machine->tick_func[n] = func;
304 machine->tick_extra[n] = extra;
305
306 machine->n_tick_entries ++;
307 }
308
309
310 /****************************************************************************
311 * *
312 * Helper functions *
313 * *
314 ****************************************************************************/
315
316
317 int int_to_bcd(int i)
318 {
319 return (i/10) * 16 + (i % 10);
320 }
321
322
323 /*
324 * dump_mem_string():
325 *
326 * Dump the contents of emulated RAM as readable text. Bytes that aren't
327 * readable are dumped in [xx] notation, where xx is in hexadecimal.
328 * Dumping ends after DUMP_MEM_STRING_MAX bytes, or when a terminating
329 * zero byte is found.
330 */
331 #define DUMP_MEM_STRING_MAX 45
332 void dump_mem_string(struct cpu *cpu, uint64_t addr)
333 {
334 int i;
335 for (i=0; i<DUMP_MEM_STRING_MAX; i++) {
336 unsigned char ch = '\0';
337
338 cpu->memory_rw(cpu, cpu->mem, addr + i, &ch, sizeof(ch),
339 MEM_READ, CACHE_DATA | NO_EXCEPTIONS);
340 if (ch == '\0')
341 return;
342 if (ch >= ' ' && ch < 126)
343 debug("%c", ch);
344 else
345 debug("[%02x]", ch);
346 }
347 }
348
349
350 /*
351 * store_byte():
352 *
353 * Stores a byte in emulated ram. (Helper function.)
354 */
355 void store_byte(struct cpu *cpu, uint64_t addr, uint8_t data)
356 {
357 if ((addr >> 32) == 0)
358 addr = (int64_t)(int32_t)addr;
359 cpu->memory_rw(cpu, cpu->mem,
360 addr, &data, sizeof(data), MEM_WRITE, CACHE_DATA);
361 }
362
363
364 /*
365 * store_string():
366 *
367 * Stores chars into emulated RAM until a zero byte (string terminating
368 * character) is found. The zero byte is also copied.
369 * (strcpy()-like helper function, host-RAM-to-emulated-RAM.)
370 */
371 void store_string(struct cpu *cpu, uint64_t addr, char *s)
372 {
373 do {
374 store_byte(cpu, addr++, *s);
375 } while (*s++);
376 }
377
378
379 /*
380 * add_environment_string():
381 *
382 * Like store_string(), but advances the pointer afterwards. The most
383 * obvious use is to place a number of strings (such as environment variable
384 * strings) after one-another in emulated memory.
385 */
386 void add_environment_string(struct cpu *cpu, char *s, uint64_t *addr)
387 {
388 store_string(cpu, *addr, s);
389 (*addr) += strlen(s) + 1;
390 }
391
392
393 /*
394 * add_environment_string_dual():
395 *
396 * Add "dual" environment strings, one for the variable name and one for the
397 * value, and update pointers afterwards.
398 */
399 void add_environment_string_dual(struct cpu *cpu,
400 uint64_t *ptrp, uint64_t *addrp, char *s1, char *s2)
401 {
402 uint64_t ptr = *ptrp, addr = *addrp;
403
404 store_32bit_word(cpu, ptr, addr);
405 ptr += sizeof(uint32_t);
406 if (addr != 0) {
407 store_string(cpu, addr, s1);
408 addr += strlen(s1) + 1;
409 }
410 store_32bit_word(cpu, ptr, addr);
411 ptr += sizeof(uint32_t);
412 if (addr != 0) {
413 store_string(cpu, addr, s2);
414 addr += strlen(s2) + 1;
415 }
416
417 *ptrp = ptr;
418 *addrp = addr;
419 }
420
421
422 /*
423 * store_64bit_word():
424 *
425 * Stores a 64-bit word in emulated RAM. Byte order is taken into account.
426 * Helper function.
427 */
428 int store_64bit_word(struct cpu *cpu, uint64_t addr, uint64_t data64)
429 {
430 unsigned char data[8];
431 if ((addr >> 32) == 0)
432 addr = (int64_t)(int32_t)addr;
433 data[0] = (data64 >> 56) & 255;
434 data[1] = (data64 >> 48) & 255;
435 data[2] = (data64 >> 40) & 255;
436 data[3] = (data64 >> 32) & 255;
437 data[4] = (data64 >> 24) & 255;
438 data[5] = (data64 >> 16) & 255;
439 data[6] = (data64 >> 8) & 255;
440 data[7] = (data64) & 255;
441 if (cpu->byte_order == EMUL_LITTLE_ENDIAN) {
442 int tmp = data[0]; data[0] = data[7]; data[7] = tmp;
443 tmp = data[1]; data[1] = data[6]; data[6] = tmp;
444 tmp = data[2]; data[2] = data[5]; data[5] = tmp;
445 tmp = data[3]; data[3] = data[4]; data[4] = tmp;
446 }
447 return cpu->memory_rw(cpu, cpu->mem,
448 addr, data, sizeof(data), MEM_WRITE, CACHE_DATA);
449 }
450
451
452 /*
453 * store_32bit_word():
454 *
455 * Stores a 32-bit word in emulated RAM. Byte order is taken into account.
456 * (This function takes a 64-bit word as argument, to suppress some
457 * warnings, but only the lowest 32 bits are used.)
458 */
459 int store_32bit_word(struct cpu *cpu, uint64_t addr, uint64_t data32)
460 {
461 unsigned char data[4];
462 if (cpu->machine->arch == ARCH_MIPS && (addr >> 32) == 0)
463 addr = (int64_t)(int32_t)addr;
464 data[0] = (data32 >> 24) & 255;
465 data[1] = (data32 >> 16) & 255;
466 data[2] = (data32 >> 8) & 255;
467 data[3] = (data32) & 255;
468 if (cpu->byte_order == EMUL_LITTLE_ENDIAN) {
469 int tmp = data[0]; data[0] = data[3]; data[3] = tmp;
470 tmp = data[1]; data[1] = data[2]; data[2] = tmp;
471 }
472 return cpu->memory_rw(cpu, cpu->mem,
473 addr, data, sizeof(data), MEM_WRITE, CACHE_DATA);
474 }
475
476
477 /*
478 * store_16bit_word():
479 *
480 * Stores a 16-bit word in emulated RAM. Byte order is taken into account.
481 * (This function takes a 64-bit word as argument, to suppress some
482 * warnings, but only the lowest 16 bits are used.)
483 */
484 int store_16bit_word(struct cpu *cpu, uint64_t addr, uint64_t data16)
485 {
486 unsigned char data[2];
487 if (cpu->machine->arch == ARCH_MIPS && (addr >> 32) == 0)
488 addr = (int64_t)(int32_t)addr;
489 data[0] = (data16 >> 8) & 255;
490 data[1] = (data16) & 255;
491 if (cpu->byte_order == EMUL_LITTLE_ENDIAN) {
492 int tmp = data[0]; data[0] = data[1]; data[1] = tmp;
493 }
494 return cpu->memory_rw(cpu, cpu->mem,
495 addr, data, sizeof(data), MEM_WRITE, CACHE_DATA);
496 }
497
498
499 /*
500 * store_buf():
501 *
502 * memcpy()-like helper function, from host RAM to emulated RAM.
503 */
504 void store_buf(struct cpu *cpu, uint64_t addr, char *s, size_t len)
505 {
506 int psize = 1024; /* 1024 256 64 16 4 1 */
507
508 if (cpu->machine->arch == ARCH_MIPS && (addr >> 32) == 0)
509 addr = (int64_t)(int32_t)addr;
510
511 while (len != 0) {
512 if ((addr & (psize-1)) == 0) {
513 while (len >= psize) {
514 cpu->memory_rw(cpu, cpu->mem, addr,
515 (unsigned char *)s, psize, MEM_WRITE,
516 CACHE_DATA);
517 addr += psize;
518 s += psize;
519 len -= psize;
520 }
521 }
522 psize >>= 2;
523 }
524
525 while (len-- != 0)
526 store_byte(cpu, addr++, *s++);
527 }
528
529
530 /*
531 * store_pointer_and_advance():
532 *
533 * Stores a 32-bit or 64-bit pointer in emulated RAM, and advances the
534 * target address. (Used by ARC and SGI initialization.)
535 */
536 void store_pointer_and_advance(struct cpu *cpu, uint64_t *addrp,
537 uint64_t data, int flag64)
538 {
539 uint64_t addr = *addrp;
540 if (flag64) {
541 store_64bit_word(cpu, addr, data);
542 addr += 8;
543 } else {
544 store_32bit_word(cpu, addr, data);
545 addr += 4;
546 }
547 *addrp = addr;
548 }
549
550
551 /*
552 * load_32bit_word():
553 *
554 * Helper function. Prints a warning and returns 0, if the read failed.
555 * Emulated byte order is taken into account.
556 */
557 uint32_t load_32bit_word(struct cpu *cpu, uint64_t addr)
558 {
559 unsigned char data[4];
560
561 if (cpu->machine->arch == ARCH_MIPS && (addr >> 32) == 0)
562 addr = (int64_t)(int32_t)addr;
563 cpu->memory_rw(cpu, cpu->mem,
564 addr, data, sizeof(data), MEM_READ, CACHE_DATA);
565
566 if (cpu->byte_order == EMUL_LITTLE_ENDIAN) {
567 int tmp = data[0]; data[0] = data[3]; data[3] = tmp;
568 tmp = data[1]; data[1] = data[2]; data[2] = tmp;
569 }
570
571 return (data[0] << 24) + (data[1] << 16) + (data[2] << 8) + data[3];
572 }
573
574
575 /*
576 * load_16bit_word():
577 *
578 * Helper function. Prints a warning and returns 0, if the read failed.
579 * Emulated byte order is taken into account.
580 */
581 uint16_t load_16bit_word(struct cpu *cpu, uint64_t addr)
582 {
583 unsigned char data[2];
584
585 if (cpu->machine->arch == ARCH_MIPS && (addr >> 32) == 0)
586 addr = (int64_t)(int32_t)addr;
587 cpu->memory_rw(cpu, cpu->mem,
588 addr, data, sizeof(data), MEM_READ, CACHE_DATA);
589
590 if (cpu->byte_order == EMUL_LITTLE_ENDIAN) {
591 int tmp = data[0]; data[0] = data[1]; data[1] = tmp;
592 }
593
594 return (data[0] << 8) + data[1];
595 }
596
597
598 /*
599 * store_64bit_word_in_host():
600 *
601 * Stores a 64-bit word in the _host's_ RAM. Emulated byte order is taken
602 * into account. This is useful when building structs in the host's RAM
603 * which will later be copied into emulated RAM.
604 */
605 void store_64bit_word_in_host(struct cpu *cpu,
606 unsigned char *data, uint64_t data64)
607 {
608 data[0] = (data64 >> 56) & 255;
609 data[1] = (data64 >> 48) & 255;
610 data[2] = (data64 >> 40) & 255;
611 data[3] = (data64 >> 32) & 255;
612 data[4] = (data64 >> 24) & 255;
613 data[5] = (data64 >> 16) & 255;
614 data[6] = (data64 >> 8) & 255;
615 data[7] = (data64) & 255;
616 if (cpu->byte_order == EMUL_LITTLE_ENDIAN) {
617 int tmp = data[0]; data[0] = data[7]; data[7] = tmp;
618 tmp = data[1]; data[1] = data[6]; data[6] = tmp;
619 tmp = data[2]; data[2] = data[5]; data[5] = tmp;
620 tmp = data[3]; data[3] = data[4]; data[4] = tmp;
621 }
622 }
623
624
625 /*
626 * store_32bit_word_in_host():
627 *
628 * See comment for store_64bit_word_in_host().
629 *
630 * (Note: The data32 parameter is a uint64_t. This is done to suppress
631 * some warnings.)
632 */
633 void store_32bit_word_in_host(struct cpu *cpu,
634 unsigned char *data, uint64_t data32)
635 {
636 data[0] = (data32 >> 24) & 255;
637 data[1] = (data32 >> 16) & 255;
638 data[2] = (data32 >> 8) & 255;
639 data[3] = (data32) & 255;
640 if (cpu->byte_order == EMUL_LITTLE_ENDIAN) {
641 int tmp = data[0]; data[0] = data[3]; data[3] = tmp;
642 tmp = data[1]; data[1] = data[2]; data[2] = tmp;
643 }
644 }
645
646
647 /*
648 * store_16bit_word_in_host():
649 *
650 * See comment for store_64bit_word_in_host().
651 */
652 void store_16bit_word_in_host(struct cpu *cpu,
653 unsigned char *data, uint16_t data16)
654 {
655 data[0] = (data16 >> 8) & 255;
656 data[1] = (data16) & 255;
657 if (cpu->byte_order == EMUL_LITTLE_ENDIAN) {
658 int tmp = data[0]; data[0] = data[1]; data[1] = tmp;
659 }
660 }
661
662
663 /****************************************************************************
664 * *
665 * Machine dependant Interrupt routines *
666 * *
667 ****************************************************************************/
668
669
670 /*
671 * DECstation KN02 interrupts:
672 */
673 void kn02_interrupt(struct machine *m, struct cpu *cpu, int irq_nr, int assrt)
674 {
675 int current;
676
677 irq_nr -= 8;
678 irq_nr &= 0xff;
679
680 if (assrt) {
681 /* OR in the irq_nr into the CSR: */
682 m->md_int.kn02_csr->csr[0] |= irq_nr;
683 } else {
684 /* AND out the irq_nr from the CSR: */
685 m->md_int.kn02_csr->csr[0] &= ~irq_nr;
686 }
687
688 current = m->md_int.kn02_csr->csr[0] & m->md_int.kn02_csr->csr[2];
689 if (current == 0)
690 cpu_interrupt_ack(cpu, 2);
691 else
692 cpu_interrupt(cpu, 2);
693 }
694
695
696 /*
697 * DECstation KMIN interrupts:
698 *
699 * TC slot 3 = system slot.
700 */
701 void kmin_interrupt(struct machine *m, struct cpu *cpu, int irq_nr, int assrt)
702 {
703 irq_nr -= 8;
704 /* debug("kmin_interrupt(): irq_nr=%i assrt=%i\n", irq_nr, assrt); */
705
706 if (assrt)
707 m->md_int.dec_ioasic_data->reg[(IOASIC_INTR - IOASIC_SLOT_1_START) / 0x10] |= irq_nr;
708 else
709 m->md_int.dec_ioasic_data->reg[(IOASIC_INTR - IOASIC_SLOT_1_START) / 0x10] &= ~irq_nr;
710
711 if (m->md_int.dec_ioasic_data->reg[(IOASIC_INTR - IOASIC_SLOT_1_START) / 0x10]
712 & m->md_int.dec_ioasic_data->reg[(IOASIC_IMSK - IOASIC_SLOT_1_START) / 0x10])
713 cpu_interrupt(cpu, KMIN_INT_TC3);
714 else
715 cpu_interrupt_ack(cpu, KMIN_INT_TC3);
716 }
717
718
719 /*
720 * DECstation KN03 interrupts:
721 */
722 void kn03_interrupt(struct machine *m, struct cpu *cpu, int irq_nr, int assrt)
723 {
724 irq_nr -= 8;
725 /* debug("kn03_interrupt(): irq_nr=0x%x assrt=%i\n", irq_nr, assrt); */
726
727 if (assrt)
728 m->md_int.dec_ioasic_data->reg[(IOASIC_INTR - IOASIC_SLOT_1_START) / 0x10] |= irq_nr;
729 else
730 m->md_int.dec_ioasic_data->reg[(IOASIC_INTR - IOASIC_SLOT_1_START) / 0x10] &= ~irq_nr;
731
732 if (m->md_int.dec_ioasic_data->reg[(IOASIC_INTR - IOASIC_SLOT_1_START) / 0x10]
733 & m->md_int.dec_ioasic_data->reg[(IOASIC_IMSK - IOASIC_SLOT_1_START) / 0x10])
734 cpu_interrupt(cpu, KN03_INT_ASIC);
735 else
736 cpu_interrupt_ack(cpu, KN03_INT_ASIC);
737 }
738
739
740 /*
741 * DECstation MAXINE interrupts:
742 */
743 void maxine_interrupt(struct machine *m, struct cpu *cpu,
744 int irq_nr, int assrt)
745 {
746 irq_nr -= 8;
747 debug("maxine_interrupt(): irq_nr=0x%x assrt=%i\n", irq_nr, assrt);
748
749 if (assrt)
750 m->md_int.dec_ioasic_data->reg[(IOASIC_INTR - IOASIC_SLOT_1_START)
751 / 0x10] |= irq_nr;
752 else
753 m->md_int.dec_ioasic_data->reg[(IOASIC_INTR - IOASIC_SLOT_1_START)
754 / 0x10] &= ~irq_nr;
755
756 if (m->md_int.dec_ioasic_data->reg[(IOASIC_INTR - IOASIC_SLOT_1_START) / 0x10]
757 & m->md_int.dec_ioasic_data->reg[(IOASIC_IMSK - IOASIC_SLOT_1_START)
758 / 0x10])
759 cpu_interrupt(cpu, XINE_INT_TC3);
760 else
761 cpu_interrupt_ack(cpu, XINE_INT_TC3);
762 }
763
764
765 /*
766 * DECstation KN230 interrupts:
767 */
768 void kn230_interrupt(struct machine *m, struct cpu *cpu, int irq_nr, int assrt)
769 {
770 int r2 = 0;
771
772 m->md_int.kn230_csr->csr |= irq_nr;
773
774 switch (irq_nr) {
775 case KN230_CSR_INTR_SII:
776 case KN230_CSR_INTR_LANCE:
777 r2 = 3;
778 break;
779 case KN230_CSR_INTR_DZ0:
780 case KN230_CSR_INTR_OPT0:
781 case KN230_CSR_INTR_OPT1:
782 r2 = 2;
783 break;
784 default:
785 fatal("kn230_interrupt(): irq_nr = %i ?\n", irq_nr);
786 }
787
788 if (assrt) {
789 /* OR in the irq_nr mask into the CSR: */
790 m->md_int.kn230_csr->csr |= irq_nr;
791
792 /* Assert MIPS interrupt 2 or 3: */
793 cpu_interrupt(cpu, r2);
794 } else {
795 /* AND out the irq_nr mask from the CSR: */
796 m->md_int.kn230_csr->csr &= ~irq_nr;
797
798 /* If the CSR interrupt bits are all zero,
799 clear the bit in the cause register as well. */
800 if (r2 == 2) {
801 /* irq 2: */
802 if ((m->md_int.kn230_csr->csr & (KN230_CSR_INTR_DZ0
803 | KN230_CSR_INTR_OPT0 | KN230_CSR_INTR_OPT1)) == 0)
804 cpu_interrupt_ack(cpu, r2);
805 } else {
806 /* irq 3: */
807 if ((m->md_int.kn230_csr->csr & (KN230_CSR_INTR_SII |
808 KN230_CSR_INTR_LANCE)) == 0)
809 cpu_interrupt_ack(cpu, r2);
810 }
811 }
812 }
813
814
815 /*
816 * Jazz interrupts (for Acer PICA-61 etc):
817 *
818 * 0..7 MIPS interrupts
819 * 8 + x, where x = 0..15 Jazz interrupts
820 * 8 + x, where x = 16..31 ISA interrupt (irq nr + 16)
821 */
822 void jazz_interrupt(struct machine *m, struct cpu *cpu, int irq_nr, int assrt)
823 {
824 uint32_t irq;
825 int isa = 0;
826
827 irq_nr -= 8;
828
829 /* debug("jazz_interrupt() irq_nr = %i, assrt = %i\n",
830 irq_nr, assrt); */
831
832 if (irq_nr >= 16) {
833 isa = 1;
834 irq_nr -= 16;
835 }
836
837 irq = 1 << irq_nr;
838
839 if (isa) {
840 if (assrt)
841 m->md_int.jazz_data->isa_int_asserted |= irq;
842 else
843 m->md_int.jazz_data->isa_int_asserted &= ~irq;
844 } else {
845 if (assrt)
846 m->md_int.jazz_data->int_asserted |= irq;
847 else
848 m->md_int.jazz_data->int_asserted &= ~irq;
849 }
850
851 /* debug(" %08x %08x\n", m->md_int.jazz_data->int_asserted,
852 m->md_int.jazz_data->int_enable_mask); */
853 /* debug(" %08x %08x\n", m->md_int.jazz_data->isa_int_asserted,
854 m->md_int.jazz_data->isa_int_enable_mask); */
855
856 if (m->md_int.jazz_data->int_asserted
857 /* & m->md_int.jazz_data->int_enable_mask */ & ~0x8000 )
858 cpu_interrupt(cpu, 3);
859 else
860 cpu_interrupt_ack(cpu, 3);
861
862 if (m->md_int.jazz_data->isa_int_asserted &
863 m->md_int.jazz_data->isa_int_enable_mask)
864 cpu_interrupt(cpu, 4);
865 else
866 cpu_interrupt_ack(cpu, 4);
867
868 /* TODO: this "15" (0x8000) is the timer... fix this? */
869 if (m->md_int.jazz_data->int_asserted & 0x8000)
870 cpu_interrupt(cpu, 6);
871 else
872 cpu_interrupt_ack(cpu, 6);
873 }
874
875
876 /*
877 * VR41xx interrupt routine:
878 *
879 * irq_nr = 8 + x
880 * x = 0..15 for level1
881 * x = 16..31 for level2
882 * x = 32+y for GIU interrupt y
883 */
884 void vr41xx_interrupt(struct machine *m, struct cpu *cpu,
885 int irq_nr, int assrt)
886 {
887 int giu_irq = 0;
888
889 irq_nr -= 8;
890 if (irq_nr >= 32) {
891 giu_irq = irq_nr - 32;
892
893 if (assrt)
894 m->md_int.vr41xx_data->giuint |= (1 << giu_irq);
895 else
896 m->md_int.vr41xx_data->giuint &= ~(1 << giu_irq);
897 }
898
899 /* TODO: This is wrong. What about GIU bit 8? */
900
901 if (irq_nr != 8) {
902 /* If any GIU bit is asserted, then assert the main
903 GIU interrupt: */
904 if (m->md_int.vr41xx_data->giuint &
905 m->md_int.vr41xx_data->giumask)
906 vr41xx_interrupt(m, cpu, 8 + 8, 1);
907 else
908 vr41xx_interrupt(m, cpu, 8 + 8, 0);
909 }
910
911 /* debug("vr41xx_interrupt(): irq_nr=%i assrt=%i\n",
912 irq_nr, assrt); */
913
914 if (irq_nr < 16) {
915 if (assrt)
916 m->md_int.vr41xx_data->sysint1 |= (1 << irq_nr);
917 else
918 m->md_int.vr41xx_data->sysint1 &= ~(1 << irq_nr);
919 } else if (irq_nr < 32) {
920 irq_nr -= 16;
921 if (assrt)
922 m->md_int.vr41xx_data->sysint2 |= (1 << irq_nr);
923 else
924 m->md_int.vr41xx_data->sysint2 &= ~(1 << irq_nr);
925 }
926
927 /* TODO: Which hardware interrupt pin? */
928
929 /* debug(" sysint1=%04x mask=%04x, sysint2=%04x mask=%04x\n",
930 m->md_int.vr41xx_data->sysint1, m->md_int.vr41xx_data->msysint1,
931 m->md_int.vr41xx_data->sysint2, m->md_int.vr41xx_data->msysint2); */
932
933 if ((m->md_int.vr41xx_data->sysint1 & m->md_int.vr41xx_data->msysint1) |
934 (m->md_int.vr41xx_data->sysint2 & m->md_int.vr41xx_data->msysint2))
935 cpu_interrupt(cpu, 2);
936 else
937 cpu_interrupt_ack(cpu, 2);
938 }
939
940
941 /*
942 * Playstation 2 interrupt routine:
943 *
944 * irq_nr = 8 + x normal irq x
945 * 8 + 16 + y dma irq y
946 * 8 + 32 + 0 sbus irq 0 (pcmcia)
947 * 8 + 32 + 1 sbus irq 1 (usb)
948 */
949 void ps2_interrupt(struct machine *m, struct cpu *cpu, int irq_nr, int assrt)
950 {
951 irq_nr -= 8;
952 debug("ps2_interrupt(): irq_nr=0x%x assrt=%i\n", irq_nr, assrt);
953
954 if (irq_nr >= 32) {
955 int msk = 0;
956 switch (irq_nr - 32) {
957 case 0: /* PCMCIA: */
958 msk = 0x100;
959 break;
960 case 1: /* USB: */
961 msk = 0x400;
962 break;
963 default:
964 fatal("ps2_interrupt(): bad irq_nr %i\n", irq_nr);
965 }
966
967 if (assrt)
968 m->md_int.ps2_data->sbus_smflg |= msk;
969 else
970 m->md_int.ps2_data->sbus_smflg &= ~msk;
971
972 if (m->md_int.ps2_data->sbus_smflg != 0)
973 cpu_interrupt(cpu, 8 + 1);
974 else
975 cpu_interrupt_ack(cpu, 8 + 1);
976 return;
977 }
978
979 if (assrt) {
980 /* OR into the INTR: */
981 if (irq_nr < 16)
982 m->md_int.ps2_data->intr |= (1 << irq_nr);
983 else
984 m->md_int.ps2_data->dmac_reg[0x601] |=
985 (1 << (irq_nr-16));
986 } else {
987 /* AND out of the INTR: */
988 if (irq_nr < 16)
989 m->md_int.ps2_data->intr &= ~(1 << irq_nr);
990 else
991 m->md_int.ps2_data->dmac_reg[0x601] &=
992 ~(1 << (irq_nr-16));
993 }
994
995 /* TODO: Hm? How about the mask? */
996 if (m->md_int.ps2_data->intr /* & m->md_int.ps2_data->imask */ )
997 cpu_interrupt(cpu, 2);
998 else
999 cpu_interrupt_ack(cpu, 2);
1000
1001 /* TODO: mask? */
1002 if (m->md_int.ps2_data->dmac_reg[0x601] & 0xffff)
1003 cpu_interrupt(cpu, 3);
1004 else
1005 cpu_interrupt_ack(cpu, 3);
1006 }
1007
1008
1009 /*
1010 * SGI "IP22" interrupt routine:
1011 */
1012 void sgi_ip22_interrupt(struct machine *m, struct cpu *cpu,
1013 int irq_nr, int assrt)
1014 {
1015 /*
1016 * SGI-IP22 specific interrupt stuff:
1017 *
1018 * irq_nr should be 8 + x, where x = 0..31 for local0,
1019 * and 32..63 for local1 interrupts.
1020 * Add 64*y for "mappable" interrupts, where 1<<y is
1021 * the mappable interrupt bitmask. TODO: this misses 64*0 !
1022 */
1023
1024 uint32_t newmask;
1025 uint32_t stat, mask;
1026
1027 irq_nr -= 8;
1028 newmask = 1 << (irq_nr & 31);
1029
1030 if (irq_nr >= 64) {
1031 int ms = irq_nr / 64;
1032 uint32_t new = 1 << ms;
1033 if (assrt)
1034 m->md_int.sgi_ip22_data->reg[4] |= new;
1035 else
1036 m->md_int.sgi_ip22_data->reg[4] &= ~new;
1037 /* TODO: is this enough? */
1038 irq_nr &= 63;
1039 }
1040
1041 if (irq_nr < 32) {
1042 if (assrt)
1043 m->md_int.sgi_ip22_data->reg[0] |= newmask;
1044 else
1045 m->md_int.sgi_ip22_data->reg[0] &= ~newmask;
1046 } else {
1047 if (assrt)
1048 m->md_int.sgi_ip22_data->reg[2] |= newmask;
1049 else
1050 m->md_int.sgi_ip22_data->reg[2] &= ~newmask;
1051 }
1052
1053 /* Read stat and mask for local0: */
1054 stat = m->md_int.sgi_ip22_data->reg[0];
1055 mask = m->md_int.sgi_ip22_data->reg[1];
1056 if ((stat & mask) == 0)
1057 cpu_interrupt_ack(cpu, 2);
1058 else
1059 cpu_interrupt(cpu, 2);
1060
1061 /* Read stat and mask for local1: */
1062 stat = m->md_int.sgi_ip22_data->reg[2];
1063 mask = m->md_int.sgi_ip22_data->reg[3];
1064 if ((stat & mask) == 0)
1065 cpu_interrupt_ack(cpu, 3);
1066 else
1067 cpu_interrupt(cpu, 3);
1068 }
1069
1070
1071 /*
1072 * SGI "IP30" interrupt routine:
1073 *
1074 * irq_nr = 8 + 1 + nr, where nr is:
1075 * 0..49 HEART irqs hardware irq 2,3,4
1076 * 50 HEART timer hardware irq 5
1077 * 51..63 HEART errors hardware irq 6
1078 *
1079 * according to Linux/IP30.
1080 */
1081 void sgi_ip30_interrupt(struct machine *m, struct cpu *cpu,
1082 int irq_nr, int assrt)
1083 {
1084 uint64_t newmask;
1085 uint64_t stat, mask;
1086
1087 irq_nr -= 8;
1088 if (irq_nr == 0)
1089 goto just_assert_and_such;
1090 irq_nr --;
1091
1092 newmask = (int64_t)1 << irq_nr;
1093
1094 if (assrt)
1095 m->md_int.sgi_ip30_data->isr |= newmask;
1096 else
1097 m->md_int.sgi_ip30_data->isr &= ~newmask;
1098
1099 just_assert_and_such:
1100
1101 cpu_interrupt_ack(cpu, 2);
1102 cpu_interrupt_ack(cpu, 3);
1103 cpu_interrupt_ack(cpu, 4);
1104 cpu_interrupt_ack(cpu, 5);
1105 cpu_interrupt_ack(cpu, 6);
1106
1107 stat = m->md_int.sgi_ip30_data->isr;
1108 mask = m->md_int.sgi_ip30_data->imask0;
1109
1110 if ((stat & mask) & 0x000000000000ffffULL)
1111 cpu_interrupt(cpu, 2);
1112 if ((stat & mask) & 0x00000000ffff0000ULL)
1113 cpu_interrupt(cpu, 3);
1114 if ((stat & mask) & 0x0003ffff00000000ULL)
1115 cpu_interrupt(cpu, 4);
1116 if ((stat & mask) & 0x0004000000000000ULL)
1117 cpu_interrupt(cpu, 5);
1118 if ((stat & mask) & 0xfff8000000000000ULL)
1119 cpu_interrupt(cpu, 6);
1120 }
1121
1122
1123 /*
1124 * SGI "IP32" interrupt routine:
1125 */
1126 void sgi_ip32_interrupt(struct machine *m, struct cpu *cpu,
1127 int irq_nr, int assrt)
1128 {
1129 /*
1130 * The 64-bit word at crime offset 0x10 is CRIME_INTSTAT,
1131 * which contains the current interrupt bits. CRIME_INTMASK
1132 * contains a mask of which bits are actually in use.
1133 *
1134 * crime hardcoded at 0x14000000, for SGI-IP32.
1135 * If any of these bits are asserted, then physical MIPS
1136 * interrupt 2 should be asserted.
1137 *
1138 * TODO: how should all this be done nicely?
1139 */
1140
1141 uint64_t crime_addr = CRIME_INTSTAT;
1142 uint64_t mace_addr = 0x10;
1143 uint64_t crime_interrupts, crime_interrupts_mask;
1144 uint64_t mace_interrupts, mace_interrupt_mask;
1145 unsigned int i;
1146 unsigned char x[8];
1147
1148 /* Read current MACE interrupt assertions: */
1149 memcpy(x, m->md_int.ip32.mace_data->reg + mace_addr,
1150 sizeof(uint64_t));
1151 mace_interrupts = 0;
1152 for (i=0; i<sizeof(uint64_t); i++) {
1153 mace_interrupts <<= 8;
1154 mace_interrupts |= x[i];
1155 }
1156
1157 /* Read current MACE interrupt mask: */
1158 memcpy(x, m->md_int.ip32.mace_data->reg + mace_addr + 8,
1159 sizeof(uint64_t));
1160 mace_interrupt_mask = 0;
1161 for (i=0; i<sizeof(uint64_t); i++) {
1162 mace_interrupt_mask <<= 8;
1163 mace_interrupt_mask |= x[i];
1164 }
1165
1166 /*
1167 * This mapping of both MACE and CRIME interrupts into the same
1168 * 'int' is really ugly.
1169 *
1170 * If MACE_PERIPH_MISC or MACE_PERIPH_SERIAL is set, then mask
1171 * that bit out and treat the rest of the word as the mace interrupt
1172 * bitmask.
1173 *
1174 * TODO: fix.
1175 */
1176 if (irq_nr & MACE_PERIPH_SERIAL) {
1177 if (assrt)
1178 mace_interrupts |= (irq_nr & ~MACE_PERIPH_SERIAL);
1179 else
1180 mace_interrupts &= ~(irq_nr & ~MACE_PERIPH_SERIAL);
1181
1182 irq_nr = MACE_PERIPH_SERIAL;
1183 if ((mace_interrupts & mace_interrupt_mask) == 0)
1184 assrt = 0;
1185 else
1186 assrt = 1;
1187 }
1188
1189 /* Hopefully _MISC and _SERIAL will not be both on at the same time. */
1190 if (irq_nr & MACE_PERIPH_MISC) {
1191 if (assrt)
1192 mace_interrupts |= (irq_nr & ~MACE_PERIPH_MISC);
1193 else
1194 mace_interrupts &= ~(irq_nr & ~MACE_PERIPH_MISC);
1195
1196 irq_nr = MACE_PERIPH_MISC;
1197 if ((mace_interrupts & mace_interrupt_mask) == 0)
1198 assrt = 0;
1199 else
1200 assrt = 1;
1201 }
1202
1203 /* Write back MACE interrupt assertions: */
1204 for (i=0; i<sizeof(uint64_t); i++)
1205 x[7-i] = mace_interrupts >> (i*8);
1206 memcpy(m->md_int.ip32.mace_data->reg + mace_addr, x, sizeof(uint64_t));
1207
1208 /* Read CRIME_INTSTAT: */
1209 memcpy(x, m->md_int.ip32.crime_data->reg + crime_addr,
1210 sizeof(uint64_t));
1211 crime_interrupts = 0;
1212 for (i=0; i<sizeof(uint64_t); i++) {
1213 crime_interrupts <<= 8;
1214 crime_interrupts |= x[i];
1215 }
1216
1217 if (assrt)
1218 crime_interrupts |= irq_nr;
1219 else
1220 crime_interrupts &= ~irq_nr;
1221
1222 /* Write back CRIME_INTSTAT: */
1223 for (i=0; i<sizeof(uint64_t); i++)
1224 x[7-i] = crime_interrupts >> (i*8);
1225 memcpy(m->md_int.ip32.crime_data->reg + crime_addr, x,
1226 sizeof(uint64_t));
1227
1228 /* Read CRIME_INTMASK: */
1229 memcpy(x, m->md_int.ip32.crime_data->reg + CRIME_INTMASK,
1230 sizeof(uint64_t));
1231 crime_interrupts_mask = 0;
1232 for (i=0; i<sizeof(uint64_t); i++) {
1233 crime_interrupts_mask <<= 8;
1234 crime_interrupts_mask |= x[i];
1235 }
1236
1237 if ((crime_interrupts & crime_interrupts_mask) == 0)
1238 cpu_interrupt_ack(cpu, 2);
1239 else
1240 cpu_interrupt(cpu, 2);
1241
1242 /* printf("sgi_crime_machine_irq(%i,%i): new interrupts = 0x%08x\n",
1243 assrt, irq_nr, crime_interrupts); */
1244 }
1245
1246
1247 /*
1248 * Au1x00 interrupt routine:
1249 *
1250 * TODO: This is just bogus so far. For more info, read this:
1251 * http://www.meshcube.org/cgi-bin/viewcvs.cgi/kernel/linux/arch/mips/au1000/common/
1252 *
1253 * CPU int 2 = IC 0, request 0
1254 * CPU int 3 = IC 0, request 1
1255 * CPU int 4 = IC 1, request 0
1256 * CPU int 5 = IC 1, request 1
1257 *
1258 * Interrupts 0..31 are on interrupt controller 0, interrupts 32..63 are
1259 * on controller 1.
1260 *
1261 * Special case: if irq_nr == 64+8, then this just updates the CPU
1262 * interrupt assertions.
1263 */
1264 void au1x00_interrupt(struct machine *m, struct cpu *cpu,
1265 int irq_nr, int assrt)
1266 {
1267 uint32_t ms;
1268
1269 irq_nr -= 8;
1270 debug("au1x00_interrupt(): irq_nr=%i assrt=%i\n", irq_nr, assrt);
1271
1272 if (irq_nr < 64) {
1273 ms = 1 << (irq_nr & 31);
1274
1275 if (assrt)
1276 m->md_int.au1x00_ic_data->request0_int |= ms;
1277 else
1278 m->md_int.au1x00_ic_data->request0_int &= ~ms;
1279
1280 /* TODO: Controller 1 */
1281 }
1282
1283 if ((m->md_int.au1x00_ic_data->request0_int &
1284 m->md_int.au1x00_ic_data->mask) != 0)
1285 cpu_interrupt(cpu, 2);
1286 else
1287 cpu_interrupt_ack(cpu, 2);
1288
1289 /* TODO: What _is_ request1? */
1290
1291 /* TODO: Controller 1 */
1292 }
1293
1294
1295 /*
1296 * Malta (evbmips) interrupts:
1297 *
1298 * ISA interrupts.
1299 * (irq_nr = 16+8 can be used to just reassert/deassert interrupts.)
1300 */
1301 void malta_interrupt(struct machine *m, struct cpu *cpu, int irq_nr,
1302 int assrt)
1303 {
1304 int mask;
1305
1306 irq_nr -= 8;
1307 mask = 1 << (irq_nr & 7);
1308
1309 if (irq_nr < 8) {
1310 if (assrt)
1311 m->isa_pic_data.pic1->irr |= mask;
1312 else
1313 m->isa_pic_data.pic1->irr &= ~mask;
1314 } else if (irq_nr < 16) {
1315 if (assrt)
1316 m->isa_pic_data.pic2->irr |= mask;
1317 else
1318 m->isa_pic_data.pic2->irr &= ~mask;
1319 }
1320
1321 /* Any interrupt assertions on PIC2 go to irq 2 on PIC1 */
1322 /* (TODO: don't hardcode this here) */
1323 if (m->isa_pic_data.pic2->irr &
1324 ~m->isa_pic_data.pic2->ier)
1325 m->isa_pic_data.pic1->irr |= 0x04;
1326 else
1327 m->isa_pic_data.pic1->irr &= ~0x04;
1328
1329 /* Now, PIC1: */
1330 if (m->isa_pic_data.pic1->irr &
1331 ~m->isa_pic_data.pic1->ier)
1332 cpu_interrupt(cpu, 2);
1333 else
1334 cpu_interrupt_ack(cpu, 2);
1335
1336 /* printf("MALTA: pic1.irr=0x%02x ier=0x%02x pic2.irr=0x%02x "
1337 "ier=0x%02x\n", m->isa_pic_data.pic1->irr,
1338 m->isa_pic_data.pic1->ier,
1339 m->isa_pic_data.pic2->irr,
1340 m->isa_pic_data.pic2->ier); */
1341 }
1342
1343
1344 /*
1345 * Cobalt interrupts:
1346 *
1347 * (irq_nr = 8 + 16 can be used to just reassert/deassert interrupts.)
1348 */
1349 void cobalt_interrupt(struct machine *m, struct cpu *cpu, int irq_nr, int assrt)
1350 {
1351 int mask;
1352
1353 irq_nr -= 8;
1354 mask = 1 << (irq_nr & 7);
1355
1356 if (irq_nr < 8) {
1357 if (assrt)
1358 m->isa_pic_data.pic1->irr |= mask;
1359 else
1360 m->isa_pic_data.pic1->irr &= ~mask;
1361 } else if (irq_nr < 16) {
1362 if (assrt)
1363 m->isa_pic_data.pic2->irr |= mask;
1364 else
1365 m->isa_pic_data.pic2->irr &= ~mask;
1366 }
1367
1368 /* Any interrupt assertions on PIC2 go to irq 2 on PIC1 */
1369 /* (TODO: don't hardcode this here) */
1370 if (m->isa_pic_data.pic2->irr &
1371 ~m->isa_pic_data.pic2->ier)
1372 m->isa_pic_data.pic1->irr |= 0x04;
1373 else
1374 m->isa_pic_data.pic1->irr &= ~0x04;
1375
1376 /* Now, PIC1: */
1377 if (m->isa_pic_data.pic1->irr &
1378 ~m->isa_pic_data.pic1->ier)
1379 cpu_interrupt(cpu, 6);
1380 else
1381 cpu_interrupt_ack(cpu, 6);
1382
1383 /* printf("COBALT: pic1.irr=0x%02x ier=0x%02x pic2.irr=0x%02x "
1384 "ier=0x%02x\n", m->isa_pic_data.pic1->irr,
1385 m->isa_pic_data.pic1->ier,
1386 m->isa_pic_data.pic2->irr,
1387 m->isa_pic_data.pic2->ier); */
1388 }
1389
1390
1391 /*
1392 * x86 (PC) interrupts:
1393 *
1394 * (irq_nr = 16 can be used to just reassert/deassert interrupts.)
1395 */
1396 void x86_pc_interrupt(struct machine *m, struct cpu *cpu, int irq_nr, int assrt)
1397 {
1398 int mask = 1 << (irq_nr & 7);
1399
1400 if (irq_nr < 8) {
1401 if (assrt)
1402 m->isa_pic_data.pic1->irr |= mask;
1403 else
1404 m->isa_pic_data.pic1->irr &= ~mask;
1405 } else if (irq_nr < 16) {
1406 if (m->isa_pic_data.pic2 == NULL) {
1407 fatal("x86_pc_interrupt(): pic2 used (irq_nr = %i), "
1408 "but we are emulating an XT?\n", irq_nr);
1409 return;
1410 }
1411 if (assrt)
1412 m->isa_pic_data.pic2->irr |= mask;
1413 else
1414 m->isa_pic_data.pic2->irr &= ~mask;
1415 }
1416
1417 if (m->isa_pic_data.pic2 != NULL) {
1418 /* Any interrupt assertions on PIC2 go to irq 2 on PIC1 */
1419 /* (TODO: don't hardcode this here) */
1420 if (m->isa_pic_data.pic2->irr & ~m->isa_pic_data.pic2->ier)
1421 m->isa_pic_data.pic1->irr |= 0x04;
1422 else
1423 m->isa_pic_data.pic1->irr &= ~0x04;
1424 }
1425
1426 /* Now, PIC1: */
1427 if (m->isa_pic_data.pic1->irr & ~m->isa_pic_data.pic1->ier)
1428 cpu->cd.x86.interrupt_asserted = 1;
1429 else
1430 cpu->cd.x86.interrupt_asserted = 0;
1431 }
1432
1433
1434 /*
1435 * Footbridge interrupts:
1436 *
1437 * 0..31 = footbridge interrupt
1438 * 32..47 = ISA (connected to IRQ_IN_L2 on CATS, L3 on NetWinder)
1439 * 64 = reassert
1440 */
1441 void footbridge_interrupt(struct machine *m, struct cpu *cpu, int irq_nr,
1442 int assrt)
1443 {
1444 uint32_t mask = 1 << (irq_nr & 31);
1445 int old_isa_assert, new_isa_assert;
1446 int isa_int = m->machine_type == MACHINE_CATS? 10 : 11;
1447
1448 old_isa_assert = m->isa_pic_data.pic1->irr & ~m->isa_pic_data.pic1->ier;
1449
1450 if (irq_nr >= 32 && irq_nr < 32 + 8) {
1451 int mm = 1 << (irq_nr & 7);
1452 if (assrt)
1453 m->isa_pic_data.pic1->irr |= mm;
1454 else
1455 m->isa_pic_data.pic1->irr &= ~mm;
1456 } else if (irq_nr >= 32+8 && irq_nr < 32+16) {
1457 int mm = 1 << (irq_nr & 7);
1458 if (assrt)
1459 m->isa_pic_data.pic2->irr |= mm;
1460 else
1461 m->isa_pic_data.pic2->irr &= ~mm;
1462 }
1463
1464 /* Any interrupt assertions on PIC2 go to irq 2 on PIC1 */
1465 /* (TODO: don't hardcode this here) */
1466 if (m->isa_pic_data.pic2->irr & ~m->isa_pic_data.pic2->ier)
1467 m->isa_pic_data.pic1->irr |= 0x04;
1468 else
1469 m->isa_pic_data.pic1->irr &= ~0x04;
1470
1471 /* Now, PIC1: */
1472 new_isa_assert = m->isa_pic_data.pic1->irr & ~m->isa_pic_data.pic1->ier;
1473 if (old_isa_assert != new_isa_assert) {
1474 if (new_isa_assert)
1475 cpu_interrupt(cpu, isa_int);
1476 else
1477 cpu_interrupt_ack(cpu, isa_int);
1478 return;
1479 }
1480
1481 if (irq_nr < 32) {
1482 if (assrt)
1483 m->md_int.footbridge_data->irq_status |= mask;
1484 else
1485 m->md_int.footbridge_data->irq_status &= ~mask;
1486 }
1487
1488 if (m->md_int.footbridge_data->irq_status &
1489 m->md_int.footbridge_data->irq_enable)
1490 cpu_interrupt(cpu, 65);
1491 else
1492 cpu_interrupt_ack(cpu, 65);
1493 }
1494
1495
1496 /****************************************************************************
1497 * *
1498 * Machine dependant Initialization routines *
1499 * *
1500 ****************************************************************************/
1501
1502
1503 /*
1504 * machine_setup():
1505 *
1506 * This (rather large) function initializes memory, registers, and/or devices
1507 * required by specific machine emulations.
1508 */
1509 void machine_setup(struct machine *machine)
1510 {
1511 uint64_t addr, addr2;
1512 int i, j;
1513 struct memory *mem;
1514 char tmpstr[1000];
1515 struct cons_data *cons_data;
1516
1517 /* DECstation: */
1518 char *framebuffer_console_name, *serial_console_name;
1519 int color_fb_flag;
1520 int boot_scsi_boardnumber = 3, boot_net_boardnumber = 3;
1521 char *turbochannel_default_gfx_card = "PMAG-BA";
1522 /* PMAG-AA, -BA, -CA/DA/EA/FA, -JA, -RO, PMAGB-BA */
1523
1524 /* HPCmips: */
1525 struct xx {
1526 struct btinfo_magic a;
1527 struct btinfo_bootpath b;
1528 struct btinfo_symtab c;
1529 } xx;
1530 struct hpc_bootinfo hpc_bootinfo;
1531 int hpc_platid_flags = 0, hpc_platid_cpu_submodel = 0,
1532 hpc_platid_cpu_model = 0, hpc_platid_cpu_series = 0,
1533 hpc_platid_cpu_arch = 0,
1534 hpc_platid_submodel = 0, hpc_platid_model = 0,
1535 hpc_platid_series = 0, hpc_platid_vendor = 0;
1536 uint64_t hpc_fb_addr = 0;
1537 int hpc_fb_bits = 0, hpc_fb_encoding = 0;
1538 int hpc_fb_xsize = 0;
1539 int hpc_fb_ysize = 0;
1540 int hpc_fb_xsize_mem = 0;
1541 int hpc_fb_ysize_mem = 0;
1542
1543 /* ARCBIOS stuff: */
1544 uint64_t sgi_ram_offset = 0;
1545 int arc_wordlen = sizeof(uint32_t);
1546 char *eaddr_string = "eaddr=10:20:30:40:50:60"; /* nonsense */
1547 unsigned char macaddr[6];
1548
1549 /* Generic bootstring stuff: */
1550 int bootdev_type = 0;
1551 int bootdev_id;
1552 char *bootstr = NULL;
1553 char *bootarg = NULL;
1554 char *init_bootpath;
1555
1556 /* PCI stuff: */
1557 struct pci_data *pci_data = NULL;
1558
1559 /* Framebuffer stuff: */
1560 struct vfb_data *fb = NULL;
1561
1562 /* Abreviation: :-) */
1563 struct cpu *cpu = machine->cpus[machine->bootstrap_cpu];
1564
1565
1566 bootdev_id = diskimage_bootdev(machine, &bootdev_type);
1567
1568 mem = cpu->mem;
1569 machine->machine_name = NULL;
1570
1571 /* TODO: Move this somewhere else? */
1572 if (machine->boot_string_argument == NULL) {
1573 switch (machine->machine_type) {
1574 case MACHINE_ARC:
1575 machine->boot_string_argument = "-aN";
1576 break;
1577 case MACHINE_CATS:
1578 machine->boot_string_argument = "-A";
1579 break;
1580 case MACHINE_DEC:
1581 machine->boot_string_argument = "-a";
1582 break;
1583 default:
1584 /* Important, because boot_string_argument should
1585 not be set to NULL: */
1586 machine->boot_string_argument = "";
1587 }
1588 }
1589
1590 switch (machine->machine_type) {
1591
1592 case MACHINE_NONE:
1593 printf("\nNo emulation type specified.\n");
1594 exit(1);
1595
1596 #ifdef ENABLE_MIPS
1597 case MACHINE_BAREMIPS:
1598 /*
1599 * A "bare" MIPS test machine.
1600 *
1601 * NOTE: NO devices at all.
1602 */
1603 cpu->byte_order = EMUL_BIG_ENDIAN;
1604 machine->machine_name = "\"Bare\" MIPS machine";
1605 break;
1606
1607 case MACHINE_TESTMIPS:
1608 /*
1609 * A MIPS test machine (which happens to work with the
1610 * code in my master's thesis). :-)
1611 *
1612 * IRQ map:
1613 * 7 CPU counter
1614 * 6 SMP IPIs
1615 * 5 not used yet
1616 * 4 not used yet
1617 * 3 ethernet
1618 * 2 serial console
1619 */
1620 cpu->byte_order = EMUL_BIG_ENDIAN;
1621 machine->machine_name = "MIPS test machine";
1622
1623 snprintf(tmpstr, sizeof(tmpstr), "cons addr=0x%llx irq=2",
1624 (long long)DEV_CONS_ADDRESS);
1625 cons_data = device_add(machine, tmpstr);
1626 machine->main_console_handle = cons_data->console_handle;
1627
1628 snprintf(tmpstr, sizeof(tmpstr), "mp addr=0x%llx",
1629 (long long)DEV_MP_ADDRESS);
1630 device_add(machine, tmpstr);
1631
1632 fb = dev_fb_init(machine, mem, DEV_FB_ADDRESS, VFB_GENERIC,
1633 640,480, 640,480, 24, "testmips generic");
1634
1635 snprintf(tmpstr, sizeof(tmpstr), "disk addr=0x%llx",
1636 (long long)DEV_DISK_ADDRESS);
1637 device_add(machine, tmpstr);
1638
1639 snprintf(tmpstr, sizeof(tmpstr), "ether addr=0x%llx irq=3",
1640 (long long)DEV_ETHER_ADDRESS);
1641 device_add(machine, tmpstr);
1642
1643 break;
1644
1645 case MACHINE_DEC:
1646 cpu->byte_order = EMUL_LITTLE_ENDIAN;
1647
1648 /* An R2020 or R3220 memory thingy: */
1649 cpu->cd.mips.coproc[3] = mips_coproc_new(cpu, 3);
1650
1651 /* There aren't really any good standard values... */
1652 framebuffer_console_name = "osconsole=0,3";
1653 serial_console_name = "osconsole=1";
1654
1655 switch (machine->machine_subtype) {
1656 case MACHINE_DEC_PMAX_3100: /* type 1, KN01 */
1657 /* Supposed to have 12MHz or 16.67MHz R2000 CPU, R2010 FPC, R2020 Memory coprocessor */
1658 machine->machine_name = "DEC PMAX 3100 (KN01)";
1659
1660 /* 12 MHz for 2100, 16.67 MHz for 3100 */
1661 if (machine->emulated_hz == 0)
1662 machine->emulated_hz = 16670000;
1663
1664 if (machine->physical_ram_in_mb > 24)
1665 fprintf(stderr, "WARNING! Real DECstation 3100 machines cannot have more than 24MB RAM. Continuing anyway.\n");
1666
1667 if ((machine->physical_ram_in_mb % 4) != 0)
1668 fprintf(stderr, "WARNING! Real DECstation 3100 machines have an integer multiple of 4 MBs of RAM. Continuing anyway.\n");
1669
1670 color_fb_flag = 1; /* 1 for color, 0 for mono. TODO: command line option? */
1671
1672 /*
1673 * According to NetBSD/pmax:
1674 *
1675 * pm0 at ibus0 addr 0xfc00000: 1024x864x1 (or x8 for color)
1676 * dc0 at ibus0 addr 0x1c000000
1677 * le0 at ibus0 addr 0x18000000: address 00:00:00:00:00:00
1678 * sii0 at ibus0 addr 0x1a000000
1679 * mcclock0 at ibus0 addr 0x1d000000: mc146818 or compatible
1680 * 0x1e000000 = system status and control register
1681 */
1682 fb = dev_fb_init(machine, mem, KN01_PHYS_FBUF_START,
1683 color_fb_flag? VFB_DEC_VFB02 : VFB_DEC_VFB01,
1684 0,0,0,0,0, color_fb_flag? "VFB02":"VFB01");
1685 dev_colorplanemask_init(mem, KN01_PHYS_COLMASK_START, &fb->color_plane_mask);
1686 dev_vdac_init(mem, KN01_SYS_VDAC, fb->rgb_palette, color_fb_flag);
1687 dev_le_init(machine, mem, KN01_SYS_LANCE, KN01_SYS_LANCE_B_START, KN01_SYS_LANCE_B_END, KN01_INT_LANCE, 4*1048576);
1688 dev_sii_init(machine, mem, KN01_SYS_SII, KN01_SYS_SII_B_START, KN01_SYS_SII_B_END, KN01_INT_SII);
1689 dev_dc7085_init(machine, mem, KN01_SYS_DZ, KN01_INT_DZ, machine->use_x11);
1690 dev_mc146818_init(machine, mem, KN01_SYS_CLOCK, KN01_INT_CLOCK, MC146818_DEC, 1);
1691 dev_kn01_csr_init(mem, KN01_SYS_CSR, color_fb_flag);
1692
1693 framebuffer_console_name = "osconsole=0,3"; /* fb,keyb */
1694 serial_console_name = "osconsole=3"; /* 3 */
1695 break;
1696
1697 case MACHINE_DEC_3MAX_5000: /* type 2, KN02 */
1698 /* Supposed to have 25MHz R3000 CPU, R3010 FPC, */
1699 /* and a R3220 Memory coprocessor */
1700 machine->machine_name = "DECstation 5000/200 (3MAX, KN02)";
1701
1702 if (machine->emulated_hz == 0)
1703 machine->emulated_hz = 25000000;
1704
1705 if (machine->physical_ram_in_mb < 8)
1706 fprintf(stderr, "WARNING! Real KN02 machines do not have less than 8MB RAM. Continuing anyway.\n");
1707 if (machine->physical_ram_in_mb > 480)
1708 fprintf(stderr, "WARNING! Real KN02 machines cannot have more than 480MB RAM. Continuing anyway.\n");
1709
1710 /* An R3220 memory thingy: */
1711 cpu->cd.mips.coproc[3] = mips_coproc_new(cpu, 3);
1712
1713 /*
1714 * According to NetBSD/pmax:
1715 * asc0 at tc0 slot 5 offset 0x0
1716 * le0 at tc0 slot 6 offset 0x0
1717 * ibus0 at tc0 slot 7 offset 0x0
1718 * dc0 at ibus0 addr 0x1fe00000
1719 * mcclock0 at ibus0 addr 0x1fe80000: mc146818
1720 *
1721 * kn02 shared irq numbers (IP) are offset by +8
1722 * in the emulator
1723 */
1724
1725 /* KN02 interrupts: */
1726 machine->md_interrupt = kn02_interrupt;
1727
1728 /*
1729 * TURBOchannel slots 0, 1, and 2 are free for
1730 * option cards. Let's put in zero or more graphics
1731 * boards:
1732 *
1733 * TODO: It's also possible to have larger graphics
1734 * cards that occupy several slots. How to solve
1735 * this nicely?
1736 */
1737 dev_turbochannel_init(machine, mem, 0,
1738 KN02_PHYS_TC_0_START, KN02_PHYS_TC_0_END,
1739 machine->n_gfx_cards >= 1?
1740 turbochannel_default_gfx_card : "",
1741 KN02_IP_SLOT0 +8);
1742
1743 dev_turbochannel_init(machine, mem, 1,
1744 KN02_PHYS_TC_1_START, KN02_PHYS_TC_1_END,
1745 machine->n_gfx_cards >= 2?
1746 turbochannel_default_gfx_card : "",
1747 KN02_IP_SLOT1 +8);
1748
1749 dev_turbochannel_init(machine, mem, 2,
1750 KN02_PHYS_TC_2_START, KN02_PHYS_TC_2_END,
1751 machine->n_gfx_cards >= 3?
1752 turbochannel_default_gfx_card : "",
1753 KN02_IP_SLOT2 +8);
1754
1755 /* TURBOchannel slots 3 and 4 are reserved. */
1756
1757 /* TURBOchannel slot 5 is PMAZ-AA ("asc" SCSI). */
1758 dev_turbochannel_init(machine, mem, 5,
1759 KN02_PHYS_TC_5_START, KN02_PHYS_TC_5_END,
1760 "PMAZ-AA", KN02_IP_SCSI +8);
1761
1762 /* TURBOchannel slot 6 is PMAD-AA ("le" ethernet). */
1763 dev_turbochannel_init(machine, mem, 6,
1764 KN02_PHYS_TC_6_START, KN02_PHYS_TC_6_END,
1765 "PMAD-AA", KN02_IP_LANCE +8);
1766
1767 /* TURBOchannel slot 7 is system stuff. */
1768 machine->main_console_handle =
1769 dev_dc7085_init(machine, mem,
1770 KN02_SYS_DZ, KN02_IP_DZ +8, machine->use_x11);
1771 dev_mc146818_init(machine, mem,
1772 KN02_SYS_CLOCK, KN02_INT_CLOCK, MC146818_DEC, 1);
1773
1774 machine->md_int.kn02_csr =
1775 dev_kn02_init(cpu, mem, KN02_SYS_CSR);
1776
1777 framebuffer_console_name = "osconsole=0,7";
1778 /* fb,keyb */
1779 serial_console_name = "osconsole=2";
1780 boot_scsi_boardnumber = 5;
1781 boot_net_boardnumber = 6; /* TODO: 3? */
1782 break;
1783
1784 case MACHINE_DEC_3MIN_5000: /* type 3, KN02BA */
1785 machine->machine_name = "DECstation 5000/112 or 145 (3MIN, KN02BA)";
1786 if (machine->emulated_hz == 0)
1787 machine->emulated_hz = 33000000;
1788 if (machine->physical_ram_in_mb > 128)
1789 fprintf(stderr, "WARNING! Real 3MIN machines cannot have more than 128MB RAM. Continuing anyway.\n");
1790
1791 /* KMIN interrupts: */
1792 machine->md_interrupt = kmin_interrupt;
1793
1794 /*
1795 * tc0 at mainbus0: 12.5 MHz clock (0x10000000, slotsize = 64MB)
1796 * tc slot 1: 0x14000000
1797 * tc slot 2: 0x18000000
1798 * ioasic0 at tc0 slot 3 offset 0x0 (0x1c000000) slot 0
1799 * asic regs (0x1c040000) slot 1
1800 * station's ether address (0x1c080000) slot 2
1801 * le0 at ioasic0 offset 0xc0000: address 00:00:00:00:00:00 (0x1c0c0000) slot 3
1802 * scc0 at ioasic0 offset 0x100000 (0x1c100000) slot 4
1803 * scc1 at ioasic0 offset 0x180000: console (0x1c180000) slot 6
1804 * mcclock0 at ioasic0 offset 0x200000: mc146818 or compatible (0x1c200000) slot 8
1805 * asc0 at ioasic0 offset 0x300000: NCR53C94, 25MHz, SCSI ID 7 (0x1c300000) slot 12
1806 * dma for asc0 (0x1c380000) slot 14
1807 */
1808 machine->md_int.dec_ioasic_data = dev_dec_ioasic_init(cpu, mem, 0x1c000000, 0);
1809 dev_le_init(machine, mem, 0x1c0c0000, 0, 0, KMIN_INTR_LANCE +8, 4*65536);
1810 dev_scc_init(machine, mem, 0x1c100000, KMIN_INTR_SCC_0 +8, machine->use_x11, 0, 1);
1811 dev_scc_init(machine, mem, 0x1c180000, KMIN_INTR_SCC_1 +8, machine->use_x11, 1, 1);
1812 dev_mc146818_init(machine, mem, 0x1c200000, KMIN_INTR_CLOCK +8, MC146818_DEC, 1);
1813 dev_asc_init(machine, mem, 0x1c300000, KMIN_INTR_SCSI +8,
1814 NULL, DEV_ASC_DEC, NULL, NULL);
1815
1816 /*
1817 * TURBOchannel slots 0, 1, and 2 are free for
1818 * option cards. These are by default filled with
1819 * zero or more graphics boards.
1820 *
1821 * TODO: irqs
1822 */
1823 dev_turbochannel_init(machine, mem, 0,
1824 0x10000000, 0x103fffff,
1825 machine->n_gfx_cards >= 1?
1826 turbochannel_default_gfx_card : "",
1827 KMIN_INT_TC0);
1828
1829 dev_turbochannel_init(machine, mem, 1,
1830 0x14000000, 0x143fffff,
1831 machine->n_gfx_cards >= 2?
1832 turbochannel_default_gfx_card : "",
1833 KMIN_INT_TC1);
1834
1835 dev_turbochannel_init(machine, mem, 2,
1836 0x18000000, 0x183fffff,
1837 machine->n_gfx_cards >= 3?
1838 turbochannel_default_gfx_card : "",
1839 KMIN_INT_TC2);
1840
1841 /* (kmin shared irq numbers (IP) are offset by +8 in the emulator) */
1842 /* kmin_csr = dev_kmin_init(cpu, mem, KMIN_REG_INTR); */
1843
1844 framebuffer_console_name = "osconsole=0,3"; /* fb, keyb (?) */
1845 serial_console_name = "osconsole=3"; /* ? */
1846 break;
1847
1848 case MACHINE_DEC_3MAXPLUS_5000: /* type 4, KN03 */
1849 machine->machine_name = "DECsystem 5900 or 5000 (3MAX+) (KN03)";
1850
1851 /* 5000/240 (KN03-GA, R3000): 40 MHz */
1852 /* 5000/260 (KN05-NB, R4000): 60 MHz */
1853 /* TODO: are both these type 4? */
1854 if (machine->emulated_hz == 0)
1855 machine->emulated_hz = 40000000;
1856 if (machine->physical_ram_in_mb > 480)
1857 fprintf(stderr, "WARNING! Real KN03 machines cannot have more than 480MB RAM. Continuing anyway.\n");
1858
1859 /* KN03 interrupts: */
1860 machine->md_interrupt = kn03_interrupt;
1861
1862 /*
1863 * tc0 at mainbus0: 25 MHz clock (slot 0) (0x1e000000)
1864 * tc0 slot 1 (0x1e800000)
1865 * tc0 slot 2 (0x1f000000)
1866 * ioasic0 at tc0 slot 3 offset 0x0 (0x1f800000)
1867 * something that has to do with interrupts? (?) (0x1f840000 ?)
1868 * le0 at ioasic0 offset 0xc0000 (0x1f8c0000)
1869 * scc0 at ioasic0 offset 0x100000 (0x1f900000)
1870 * scc1 at ioasic0 offset 0x180000: console (0x1f980000)
1871 * mcclock0 at ioasic0 offset 0x200000: mc146818 or compatible (0x1fa00000)
1872 * asc0 at ioasic0 offset 0x300000: NCR53C94, 25MHz, SCSI ID 7 (0x1fb00000)
1873 */
1874 machine->md_int.dec_ioasic_data = dev_dec_ioasic_init(cpu, mem, 0x1f800000, 0);
1875
1876 dev_le_init(machine, mem, KN03_SYS_LANCE, 0, 0, KN03_INTR_LANCE +8, 4*65536);
1877
1878 machine->md_int.dec_ioasic_data->dma_func[3] = dev_scc_dma_func;
1879 machine->md_int.dec_ioasic_data->dma_func_extra[2] = dev_scc_init(machine, mem, KN03_SYS_SCC_0, KN03_INTR_SCC_0 +8, machine->use_x11, 0, 1);
1880 machine->md_int.dec_ioasic_data->dma_func[2] = dev_scc_dma_func;
1881 machine->md_int.dec_ioasic_data->dma_func_extra[3] = dev_scc_init(machine, mem, KN03_SYS_SCC_1, KN03_INTR_SCC_1 +8, machine->use_x11, 1, 1);
1882
1883 dev_mc146818_init(machine, mem, KN03_SYS_CLOCK, KN03_INT_RTC, MC146818_DEC, 1);
1884 dev_asc_init(machine, mem, KN03_SYS_SCSI,
1885 KN03_INTR_SCSI +8, NULL, DEV_ASC_DEC, NULL, NULL);
1886
1887 /*
1888 * TURBOchannel slots 0, 1, and 2 are free for
1889 * option cards. These are by default filled with
1890 * zero or more graphics boards.
1891 *
1892 * TODO: irqs
1893 */
1894 dev_turbochannel_init(machine, mem, 0,
1895 KN03_PHYS_TC_0_START, KN03_PHYS_TC_0_END,
1896 machine->n_gfx_cards >= 1?
1897 turbochannel_default_gfx_card : "",
1898 KN03_INTR_TC_0 +8);
1899
1900 dev_turbochannel_init(machine, mem, 1,
1901 KN03_PHYS_TC_1_START, KN03_PHYS_TC_1_END,
1902 machine->n_gfx_cards >= 2?
1903 turbochannel_default_gfx_card : "",
1904 KN03_INTR_TC_1 +8);
1905
1906 dev_turbochannel_init(machine, mem, 2,
1907 KN03_PHYS_TC_2_START, KN03_PHYS_TC_2_END,
1908 machine->n_gfx_cards >= 3?
1909 turbochannel_default_gfx_card : "",
1910 KN03_INTR_TC_2 +8);
1911
1912 /* TODO: interrupts */
1913 /* shared (turbochannel) interrupts are +8 */
1914
1915 framebuffer_console_name = "osconsole=0,3"; /* fb, keyb (?) */
1916 serial_console_name = "osconsole=3"; /* ? */
1917 break;
1918
1919 case MACHINE_DEC_5800: /* type 5, KN5800 */
1920 machine->machine_name = "DECsystem 5800";
1921
1922 /* TODO: this is incorrect, banks multiply by 8 etc */
1923 if (machine->physical_ram_in_mb < 48)
1924 fprintf(stderr, "WARNING! 5800 will probably not run with less than 48MB RAM. Continuing anyway.\n");
1925
1926 /*
1927 * According to http://www2.no.netbsd.org/Ports/pmax/models.html,
1928 * the 5800-series is based on VAX 6000/300.
1929 */
1930
1931 /*
1932 * Ultrix might support SMP on this machine type.
1933 *
1934 * Something at 0x10000000.
1935 * ssc serial console at 0x10140000, interrupt 2 (shared with XMI?).
1936 * xmi 0 at address 0x11800000 (node x at offset x*0x80000)
1937 * Clock uses interrupt 3 (shared with XMI?).
1938 */
1939
1940 machine->md_int.dec5800_csr = dev_dec5800_init(machine, mem, 0x10000000);
1941 dev_decbi_init(mem, 0x10000000);
1942 dev_ssc_init(machine, mem, 0x10140000, 2, machine->use_x11, &machine->md_int.dec5800_csr->csr);
1943 dev_decxmi_init(mem, 0x11800000);
1944 dev_deccca_init(mem, DEC_DECCCA_BASEADDR);
1945
1946 break;
1947
1948 case MACHINE_DEC_5400: /* type 6, KN210 */
1949 machine->machine_name = "DECsystem 5400 (KN210)";
1950 /*
1951 * Misc. info from the KN210 manual:
1952 *
1953 * Interrupt lines:
1954 * irq5 fpu
1955 * irq4 halt
1956 * irq3 pwrfl -> mer1 -> mer0 -> wear
1957 * irq2 100 Hz -> birq7
1958 * irq1 dssi -> ni -> birq6
1959 * irq0 birq5 -> console -> timers -> birq4
1960 *
1961 * Interrupt status register at 0x10048000.
1962 * Main memory error status register at 0x1008140.
1963 * Interval Timer Register (ITR) at 0x10084010.
1964 * Q22 stuff at 0x10088000 - 0x1008ffff.
1965 * TODR at 0x1014006c.
1966 * TCR0 (timer control register 0) 0x10140100.
1967 * TIR0 (timer interval register 0) 0x10140104.
1968 * TCR1 (timer control register 1) 0x10140110.
1969 * TIR1 (timer interval register 1) 0x10140114.
1970 * VRR0 (Vector Read Register 0) at 0x16000050.
1971 * VRR1 (Vector Read Register 1) at 0x16000054.
1972 * VRR2 (Vector Read Register 2) at 0x16000058.
1973 * VRR3 (Vector Read Register 3) at 0x1600005c.
1974 */
1975 /* ln (ethernet) at 0x10084x00 ? and 0x10120000 ? */
1976 /* error registers (?) at 0x17000000 and 0x10080000 */
1977 device_add(machine, "kn210 addr=0x10080000");
1978 dev_ssc_init(machine, mem, 0x10140000, 0, machine->use_x11, NULL); /* TODO: not irq 0 */
1979 break;
1980
1981 case MACHINE_DEC_MAXINE_5000: /* type 7, KN02CA */
1982 machine->machine_name = "Personal DECstation 5000/xxx (MAXINE) (KN02CA)";
1983 if (machine->emulated_hz == 0)
1984 machine->emulated_hz = 33000000;
1985
1986 if (machine->physical_ram_in_mb < 8)
1987 fprintf(stderr, "WARNING! Real KN02CA machines do not have less than 8MB RAM. Continuing anyway.\n");
1988 if (machine->physical_ram_in_mb > 40)
1989 fprintf(stderr, "WARNING! Real KN02CA machines cannot have more than 40MB RAM. Continuing anyway.\n");
1990
1991 /* Maxine interrupts: */
1992 machine->md_interrupt = maxine_interrupt;
1993
1994 /*
1995 * Something at address 0xca00000. (?)
1996 * Something at address 0xe000000. (?)
1997 * tc0 slot 0 (0x10000000)
1998 * tc0 slot 1 (0x14000000)
1999 * (tc0 slot 2 used by the framebuffer)
2000 * ioasic0 at tc0 slot 3 offset 0x0 (0x1c000000)
2001 * le0 at ioasic0 offset 0xc0000: address 00:00:00:00:00:00 (0x1c0c0000)
2002 * scc0 at ioasic0 offset 0x100000: console <-- serial (0x1c100000)
2003 * mcclock0 at ioasic0 offset 0x200000: mc146818 (0x1c200000)
2004 * isdn at ioasic0 offset 0x240000 not configured (0x1c240000)
2005 * bba0 at ioasic0 offset 0x240000 (audio0 at bba0) <--- which one of isdn and bba0?
2006 * dtop0 at ioasic0 offset 0x280000 (0x1c280000)
2007 * fdc at ioasic0 offset 0x2c0000 not configured <-- floppy (0x1c2c0000)
2008 * asc0 at ioasic0 offset 0x300000: NCR53C94, 25MHz, SCSI ID 7 (0x1c300000)
2009 * xcfb0 at tc0 slot 2 offset 0x0: 1024x768x8 built-in framebuffer (0xa000000)
2010 */
2011 machine->md_int.dec_ioasic_data = dev_dec_ioasic_init(cpu, mem, 0x1c000000, 0);
2012
2013 /* TURBOchannel slots (0 and 1): */
2014 dev_turbochannel_init(machine, mem, 0,
2015 0x10000000, 0x103fffff,
2016 machine->n_gfx_cards >= 2?
2017 turbochannel_default_gfx_card : "",
2018 XINE_INTR_TC_0 +8);
2019 dev_turbochannel_init(machine, mem, 1,
2020 0x14000000, 0x143fffff,
2021 machine->n_gfx_cards >= 3?
2022 turbochannel_default_gfx_card : "",
2023 XINE_INTR_TC_1 +8);
2024
2025 /*
2026 * TURBOchannel slot 2 is hardwired to be used by
2027 * the framebuffer: (NOTE: 0x8000000, not 0x18000000)
2028 */
2029 dev_turbochannel_init(machine, mem, 2,
2030 0x8000000, 0xbffffff, "PMAG-DV", 0);
2031
2032 /*
2033 * TURBOchannel slot 3: fixed, ioasic
2034 * (the system stuff), 0x1c000000
2035 */
2036 dev_le_init(machine, mem, 0x1c0c0000, 0, 0, XINE_INTR_LANCE +8, 4*65536);
2037 dev_scc_init(machine, mem, 0x1c100000,
2038 XINE_INTR_SCC_0 +8, machine->use_x11, 0, 1);
2039 dev_mc146818_init(machine, mem, 0x1c200000,
2040 XINE_INT_TOY, MC146818_DEC, 1);
2041 dev_asc_init(machine, mem, 0x1c300000,
2042 XINE_INTR_SCSI +8, NULL, DEV_ASC_DEC, NULL, NULL);
2043
2044 framebuffer_console_name = "osconsole=3,2"; /* keyb,fb ?? */
2045 serial_console_name = "osconsole=3";
2046 break;
2047
2048 case MACHINE_DEC_5500: /* type 11, KN220 */
2049 machine->machine_name = "DECsystem 5500 (KN220)";
2050
2051 /*
2052 * According to NetBSD's pmax ports page:
2053 * KN220-AA is a "30 MHz R3000 CPU with R3010 FPU"
2054 * with "512 kBytes of Prestoserve battery backed RAM."
2055 */
2056 if (machine->emulated_hz == 0)
2057 machine->emulated_hz = 30000000;
2058
2059 /*
2060 * See KN220 docs for more info.
2061 *
2062 * something at 0x10000000
2063 * something at 0x10001000
2064 * something at 0x10040000
2065 * scc at 0x10140000
2066 * qbus at (or around) 0x10080000
2067 * dssi (disk controller) buffers at 0x10100000, registers at 0x10160000.
2068 * sgec (ethernet) registers at 0x10008000, station addresss at 0x10120000.
2069 * asc (scsi) at 0x17100000.
2070 */
2071
2072 dev_ssc_init(machine, mem, 0x10140000, 0, machine->use_x11, NULL); /* TODO: not irq 0 */
2073
2074 /* something at 0x17000000, ultrix says "cpu 0 panic: DS5500 I/O Board is missing" if this is not here */
2075 dev_dec5500_ioboard_init(cpu, mem, 0x17000000);
2076
2077 dev_sgec_init(mem, 0x10008000, 0); /* irq? */
2078
2079 /* The asc controller might be TURBOchannel-ish? */
2080 #if 0
2081 dev_turbochannel_init(machine, mem, 0, 0x17100000, 0x171fffff, "PMAZ-AA", 0); /* irq? */
2082 #else
2083 dev_asc_init(machine, mem, 0x17100000, 0, NULL, DEV_ASC_DEC, NULL, NULL); /* irq? */
2084 #endif
2085
2086 framebuffer_console_name = "osconsole=0,0"; /* TODO (?) */
2087 serial_console_name = "osconsole=0";
2088 break;
2089
2090 case MACHINE_DEC_MIPSMATE_5100: /* type 12 */
2091 machine->machine_name = "DEC MIPSMATE 5100 (KN230)";
2092 if (machine->emulated_hz == 0)
2093 machine->emulated_hz = 20000000;
2094 if (machine->physical_ram_in_mb > 128)
2095 fprintf(stderr, "WARNING! Real MIPSMATE 5100 machines cannot have more than 128MB RAM. Continuing anyway.\n");
2096
2097 if (machine->use_x11)
2098 fprintf(stderr, "WARNING! Real MIPSMATE 5100 machines cannot have a graphical framebuffer. Continuing anyway.\n");
2099
2100 /* KN230 interrupts: */
2101 machine->md_interrupt = kn230_interrupt;
2102
2103 /*
2104 * According to NetBSD/pmax:
2105 * dc0 at ibus0 addr 0x1c000000
2106 * le0 at ibus0 addr 0x18000000: address 00:00:00:00:00:00
2107 * sii0 at ibus0 addr 0x1a000000
2108 */
2109 dev_mc146818_init(machine, mem, KN230_SYS_CLOCK, 4, MC146818_DEC, 1);
2110 dev_dc7085_init(machine, mem, KN230_SYS_DZ0, KN230_CSR_INTR_DZ0, machine->use_x11); /* NOTE: CSR_INTR */
2111 /* dev_dc7085_init(machine, mem, KN230_SYS_DZ1, KN230_CSR_INTR_OPT0, machine->use_x11); */ /* NOTE: CSR_INTR */
2112 /* dev_dc7085_init(machine, mem, KN230_SYS_DZ2, KN230_CSR_INTR_OPT1, machine->use_x11); */ /* NOTE: CSR_INTR */
2113 dev_le_init(machine, mem, KN230_SYS_LANCE, KN230_SYS_LANCE_B_START, KN230_SYS_LANCE_B_END, KN230_CSR_INTR_LANCE, 4*1048576);
2114 dev_sii_init(machine, mem, KN230_SYS_SII, KN230_SYS_SII_B_START, KN230_SYS_SII_B_END, KN230_CSR_INTR_SII);
2115
2116 snprintf(tmpstr, sizeof(tmpstr),
2117 "kn230 addr=0x%llx", (long long)KN230_SYS_ICSR);
2118 machine->md_int.kn230_csr = device_add(machine, tmpstr);
2119
2120 serial_console_name = "osconsole=0";
2121 break;
2122
2123 default:
2124 ;
2125 }
2126
2127 /*
2128 * Most OSes on DECstation use physical addresses below
2129 * 0x20000000, but both OSF/1 and Sprite use 0xbe...... as if
2130 * it was 0x1e......, so we need this hack:
2131 */
2132 dev_ram_init(machine, 0xa0000000, 0x20000000,
2133 DEV_RAM_MIRROR | DEV_RAM_MIGHT_POINT_TO_DEVICES, 0x0);
2134
2135 if (machine->prom_emulation) {
2136 /* DECstation PROM stuff: (TODO: endianness) */
2137 for (i=0; i<100; i++)
2138 store_32bit_word(cpu, DEC_PROM_CALLBACK_STRUCT + i*4,
2139 DEC_PROM_EMULATION + i*8);
2140
2141 /* Fill PROM with dummy return instructions: (TODO: make this nicer) */
2142 for (i=0; i<100; i++) {
2143 store_32bit_word(cpu, DEC_PROM_EMULATION + i*8,
2144 0x03e00008); /* return */
2145 store_32bit_word(cpu, DEC_PROM_EMULATION + i*8 + 4,
2146 0x00000000); /* nop */
2147 }
2148
2149 /*
2150 * According to dec_prom.h from NetBSD:
2151 *
2152 * "Programs loaded by the new PROMs pass the following arguments:
2153 * a0 argc
2154 * a1 argv
2155 * a2 DEC_PROM_MAGIC
2156 * a3 The callback vector defined below"
2157 *
2158 * So we try to emulate a PROM, even though no such thing has been
2159 * loaded.
2160 */
2161
2162 cpu->cd.mips.gpr[MIPS_GPR_A0] = 3;
2163 cpu->cd.mips.gpr[MIPS_GPR_A1] = DEC_PROM_INITIAL_ARGV;
2164 cpu->cd.mips.gpr[MIPS_GPR_A2] = DEC_PROM_MAGIC;
2165 cpu->cd.mips.gpr[MIPS_GPR_A3] = DEC_PROM_CALLBACK_STRUCT;
2166
2167 store_32bit_word(cpu, INITIAL_STACK_POINTER + 0x10,
2168 BOOTINFO_MAGIC);
2169 store_32bit_word(cpu, INITIAL_STACK_POINTER + 0x14,
2170 BOOTINFO_ADDR);
2171
2172 store_32bit_word(cpu, DEC_PROM_INITIAL_ARGV,
2173 (DEC_PROM_INITIAL_ARGV + 0x10));
2174 store_32bit_word(cpu, DEC_PROM_INITIAL_ARGV+4,
2175 (DEC_PROM_INITIAL_ARGV + 0x70));
2176 store_32bit_word(cpu, DEC_PROM_INITIAL_ARGV+8,
2177 (DEC_PROM_INITIAL_ARGV + 0xe0));
2178 store_32bit_word(cpu, DEC_PROM_INITIAL_ARGV+12, 0);
2179
2180 /*
2181 * NetBSD and Ultrix expect the boot args to be like this:
2182 *
2183 * "boot" "bootdev" [args?]
2184 *
2185 * where bootdev is supposed to be "rz(0,0,0)netbsd" for
2186 * 3100/2100 (although that crashes Ultrix :-/), and
2187 * "5/rz0a/netbsd" for all others. The number '5' is the
2188 * slot number of the boot device.
2189 *
2190 * 'rz' for disks, 'tz' for tapes.
2191 *
2192 * TODO: Make this nicer.
2193 */
2194 {
2195 char bootpath[200];
2196 #if 0
2197 if (machine->machine_subtype == MACHINE_DEC_PMAX_3100)
2198 strlcpy(bootpath, "rz(0,0,0)", sizeof(bootpath));
2199 else
2200 #endif
2201 strlcpy(bootpath, "5/rz1/", sizeof(bootpath));
2202
2203 if (bootdev_id < 0 || machine->force_netboot) {
2204 /* tftp boot: */
2205 strlcpy(bootpath, "5/tftp/", sizeof(bootpath));
2206 bootpath[0] = '0' + boot_net_boardnumber;
2207 } else {
2208 /* disk boot: */
2209 bootpath[0] = '0' + boot_scsi_boardnumber;
2210 if (diskimage_is_a_tape(machine, bootdev_id,
2211 bootdev_type))
2212 bootpath[2] = 't';
2213 bootpath[4] = '0' + bootdev_id;
2214 }
2215
2216 init_bootpath = bootpath;
2217 }
2218
2219 bootarg = malloc(BOOTARG_BUFLEN);
2220 if (bootarg == NULL) {
2221 fprintf(stderr, "out of memory\n");
2222 exit(1);
2223 }
2224 strlcpy(bootarg, init_bootpath, BOOTARG_BUFLEN);
2225 if (strlcat(bootarg, machine->boot_kernel_filename,
2226 BOOTARG_BUFLEN) > BOOTARG_BUFLEN) {
2227 fprintf(stderr, "bootarg truncated?\n");
2228 exit(1);
2229 }
2230
2231 bootstr = "boot";
2232
2233 store_string(cpu, DEC_PROM_INITIAL_ARGV+0x10, bootstr);
2234 store_string(cpu, DEC_PROM_INITIAL_ARGV+0x70, bootarg);
2235 store_string(cpu, DEC_PROM_INITIAL_ARGV+0xe0,
2236 machine->boot_string_argument);
2237
2238 /* Decrease the nr of args, if there are no args :-) */
2239 if (machine->boot_string_argument == NULL ||
2240 machine->boot_string_argument[0] == '\0')
2241 cpu->cd.mips.gpr[MIPS_GPR_A0] --;
2242
2243 if (machine->boot_string_argument[0] != '\0') {
2244 strlcat(bootarg, " ", BOOTARG_BUFLEN);
2245 if (strlcat(bootarg, machine->boot_string_argument,
2246 BOOTARG_BUFLEN) >= BOOTARG_BUFLEN) {
2247 fprintf(stderr, "bootstr truncated?\n");
2248 exit(1);
2249 }
2250 }
2251
2252 xx.a.common.next = (char *)&xx.b - (char *)&xx;
2253 xx.a.common.type = BTINFO_MAGIC;
2254 xx.a.magic = BOOTINFO_MAGIC;
2255
2256 xx.b.common.next = (char *)&xx.c - (char *)&xx.b;
2257 xx.b.common.type = BTINFO_BOOTPATH;
2258 strlcpy(xx.b.bootpath, bootstr, sizeof(xx.b.bootpath));
2259
2260 xx.c.common.next = 0;
2261 xx.c.common.type = BTINFO_SYMTAB;
2262 xx.c.nsym = 0;
2263 xx.c.ssym = 0;
2264 xx.c.esym = machine->file_loaded_end_addr;
2265
2266 store_buf(cpu, BOOTINFO_ADDR, (char *)&xx, sizeof(xx));
2267
2268 /*
2269 * The system's memmap: (memmap is a global variable, in
2270 * dec_prom.h)
2271 */
2272 store_32bit_word_in_host(cpu,
2273 (unsigned char *)&memmap.pagesize, 4096);
2274 {
2275 unsigned int i;
2276 for (i=0; i<sizeof(memmap.bitmap); i++)
2277 memmap.bitmap[i] = ((int)i * 4096*8 <
2278 1048576*machine->physical_ram_in_mb)?
2279 0xff : 0x00;
2280 }
2281 store_buf(cpu, DEC_MEMMAP_ADDR, (char *)&memmap, sizeof(memmap));
2282
2283 /* Environment variables: */
2284 addr = DEC_PROM_STRINGS;
2285
2286 if (machine->use_x11 && machine->n_gfx_cards > 0)
2287 /* (0,3) Keyboard and Framebuffer */
2288 add_environment_string(cpu, framebuffer_console_name, &addr);
2289 else
2290 /* Serial console */
2291 add_environment_string(cpu, serial_console_name, &addr);
2292
2293 /*
2294 * The KN5800 (SMP system) uses a CCA (console communications
2295 * area): (See VAX 6000 documentation for details.)
2296 */
2297 {
2298 char tmps[300];
2299 snprintf(tmps, sizeof(tmps), "cca=%x",
2300 (int)(DEC_DECCCA_BASEADDR + 0xa0000000ULL));
2301 add_environment_string(cpu, tmps, &addr);
2302 }
2303
2304 /* These are needed for Sprite to boot: */
2305 {
2306 char tmps[500];
2307
2308 snprintf(tmps, sizeof(tmps), "boot=%s", bootarg);
2309 tmps[sizeof(tmps)-1] = '\0';
2310 add_environment_string(cpu, tmps, &addr);
2311
2312 snprintf(tmps, sizeof(tmps), "bitmap=0x%x", (uint32_t)((
2313 DEC_MEMMAP_ADDR + sizeof(memmap.pagesize))
2314 & 0xffffffffULL));
2315 tmps[sizeof(tmps)-1] = '\0';
2316 add_environment_string(cpu, tmps, &addr);
2317
2318 snprintf(tmps, sizeof(tmps), "bitmaplen=0x%x",
2319 machine->physical_ram_in_mb * 1048576 / 4096 / 8);
2320 tmps[sizeof(tmps)-1] = '\0';
2321 add_environment_string(cpu, tmps, &addr);
2322 }
2323
2324 add_environment_string(cpu, "scsiid0=7", &addr);
2325 add_environment_string(cpu, "bootmode=a", &addr);
2326 add_environment_string(cpu, "testaction=q", &addr);
2327 add_environment_string(cpu, "haltaction=h", &addr);
2328 add_environment_string(cpu, "more=24", &addr);
2329
2330 /* Used in at least Ultrix on the 5100: */
2331 add_environment_string(cpu, "scsiid=7", &addr);
2332 add_environment_string(cpu, "baud0=9600", &addr);
2333 add_environment_string(cpu, "baud1=9600", &addr);
2334 add_environment_string(cpu, "baud2=9600", &addr);
2335 add_environment_string(cpu, "baud3=9600", &addr);
2336 add_environment_string(cpu, "iooption=0x1", &addr);
2337
2338 /* The end: */
2339 add_environment_string(cpu, "", &addr);
2340 }
2341
2342 break;
2343
2344 case MACHINE_COBALT:
2345 cpu->byte_order = EMUL_LITTLE_ENDIAN;
2346 machine->machine_name = "Cobalt";
2347
2348 /*
2349 * Interrupts seem to be the following:
2350 * (according to http://www.funet.fi/pub/Linux/PEOPLE/Linus/v2.4/patch-html/patch-2.4.19/linux-2.4.19_arch_mips_cobalt_irq.c.html)
2351 *
2352 * 2 Galileo chip (timer)
2353 * 3 Tulip 0 + NCR SCSI
2354 * 4 Tulip 1
2355 * 5 16550 UART (serial console)
2356 * 6 VIA southbridge PIC
2357 * 7 PCI (Note: Not used. The PCI controller
2358 * interrupts at ISA interrupt 9.)
2359 */
2360
2361 /* ISA interrupt controllers: */
2362 snprintf(tmpstr, sizeof(tmpstr), "8259 irq=24 addr=0x10000020");
2363 machine->isa_pic_data.pic1 = device_add(machine, tmpstr);
2364 snprintf(tmpstr, sizeof(tmpstr), "8259 irq=24 addr=0x100000a0");
2365 machine->isa_pic_data.pic2 = device_add(machine, tmpstr);
2366 machine->md_interrupt = cobalt_interrupt;
2367
2368 dev_mc146818_init(machine, mem, 0x10000070, 0, MC146818_PC_CMOS, 4);
2369
2370 machine->main_console_handle = (size_t)
2371 device_add(machine, "ns16550 irq=5 addr=0x1c800000 name2=tty0 in_use=1");
2372
2373 #if 0
2374 device_add(machine, "ns16550 irq=0 addr=0x1f000010 name2=tty1 in_use=0");
2375 #endif
2376
2377 /*
2378 * According to NetBSD/cobalt:
2379 *
2380 * pchb0 at pci0 dev 0 function 0: Galileo GT-64111 System Controller, rev 1 (NOTE: added by dev_gt_init())
2381 * tlp0 at pci0 dev 7 function 0: DECchip 21143 Ethernet, pass 4.1
2382 * Symbios Logic 53c860 (SCSI mass storage, revision 0x02) at pci0 dev 8
2383 * pcib0 at pci0 dev 9 function 0, VIA Technologies VT82C586 (Apollo VP) PCI-ISA Bridge, rev 37
2384 * pciide0 at pci0 dev 9 function 1: VIA Technologies VT82C586 (Apollo VP) ATA33 cr
2385 * tlp1 at pci0 dev 12 function 0: DECchip 21143 Ethernet, pass 4.1
2386 *
2387 * The PCI controller interrupts at ISA interrupt 9.
2388 */
2389 pci_data = dev_gt_init(machine, mem, 0x14000000, 2, 8 + 9, 11);
2390 /* bus_pci_add(machine, pci_data, mem, 0, 7, 0, pci_dec21143_init, pci_dec21143_rr); */
2391 bus_pci_add(machine, pci_data, mem, 0, 8, 0, NULL, NULL); /* PCI_VENDOR_SYMBIOS, PCI_PRODUCT_SYMBIOS_860 */
2392 bus_pci_add(machine, pci_data, mem, 0, 9, 0, pci_vt82c586_isa_init, pci_vt82c586_isa_rr);
2393 bus_pci_add(machine, pci_data, mem, 0, 9, 1, pci_vt82c586_ide_init, pci_vt82c586_ide_rr);
2394 /* bus_pci_add(machine, pci_data, mem, 0, 12, 0, pci_dec21143_init, pci_dec21143_rr); */
2395
2396 if (machine->prom_emulation) {
2397 /*
2398 * NetBSD/cobalt expects memsize in a0, but it seems that what
2399 * it really wants is the end of memory + 0x80000000.
2400 *
2401 * The bootstring is stored 512 bytes before the end of
2402 * physical ram.
2403 */
2404 cpu->cd.mips.gpr[MIPS_GPR_A0] =
2405 machine->physical_ram_in_mb * 1048576 + 0xffffffff80000000ULL;
2406 bootstr = "root=/dev/hda1 ro";
2407 /* bootstr = "nfsroot=/usr/cobalt/"; */
2408 /* TODO: bootarg, and/or automagic boot device detection */
2409 store_string(cpu, cpu->cd.mips.gpr[MIPS_GPR_A0] - 512, bootstr);
2410 }
2411 break;
2412
2413 case MACHINE_HPCMIPS:
2414 cpu->byte_order = EMUL_LITTLE_ENDIAN;
2415 memset(&hpc_bootinfo, 0, sizeof(hpc_bootinfo));
2416 /*
2417 NOTE: See http://forums.projectmayo.com/viewtopic.php?topic=2743&forum=23
2418 for info on framebuffer addresses.
2419 */
2420
2421 switch (machine->machine_subtype) {
2422 case MACHINE_HPCMIPS_CASIO_BE300:
2423 /* 166MHz VR4131 */
2424 machine->machine_name = "Casio Cassiopeia BE-300";
2425 hpc_fb_addr = 0x0a200000;
2426 hpc_fb_xsize = 240;
2427 hpc_fb_ysize = 320;
2428 hpc_fb_xsize_mem = 256;
2429 hpc_fb_ysize_mem = 320;
2430 hpc_fb_bits = 15;
2431 hpc_fb_encoding = BIFB_D16_0000;
2432
2433 /* TODO: irq? */
2434 snprintf(tmpstr, sizeof(tmpstr), "ns16550 irq=0 addr=0x0a008680 addr_mult=4 in_use=%i", machine->use_x11? 0 : 1);
2435 machine->main_console_handle = (size_t)device_add(machine, tmpstr);
2436
2437 machine->md_int.vr41xx_data = dev_vr41xx_init(machine, mem, 4131);
2438 machine->md_interrupt = vr41xx_interrupt;
2439
2440 hpc_platid_cpu_arch = 1; /* MIPS */
2441 hpc_platid_cpu_series = 1; /* VR */
2442 hpc_platid_cpu_model = 1; /* VR41XX */
2443 hpc_platid_cpu_submodel = 6; /* VR4131 */
2444 hpc_platid_vendor = 3; /* Casio */
2445 hpc_platid_series = 1; /* CASSIOPEIAE */
2446 hpc_platid_model = 2; /* EXXX */
2447 hpc_platid_submodel = 3; /* E500 */
2448 /* TODO: Don't use model number for E500, it's a BE300! */
2449 break;
2450 case MACHINE_HPCMIPS_CASIO_E105:
2451 /* 131MHz VR4121 */
2452 machine->machine_name = "Casio Cassiopeia E-105";
2453 hpc_fb_addr = 0x0a200000; /* TODO? */
2454 hpc_fb_xsize = 240;
2455 hpc_fb_ysize = 320;
2456 hpc_fb_xsize_mem = 256;
2457 hpc_fb_ysize_mem = 320;
2458 hpc_fb_bits = 16;
2459 hpc_fb_encoding = BIFB_D16_0000;
2460
2461 /* TODO: irq? */
2462 snprintf(tmpstr, sizeof(tmpstr), "ns16550 irq=0 addr=0x0a008680 addr_mult=4 in_use=%i", machine->use_x11? 0 : 1);
2463 machine->main_console_handle = (size_t)device_add(machine, tmpstr);
2464
2465 machine->md_int.vr41xx_data = dev_vr41xx_init(machine, mem, 4121);
2466 machine->md_interrupt = vr41xx_interrupt;
2467
2468 hpc_platid_cpu_arch = 1; /* MIPS */
2469 hpc_platid_cpu_series = 1; /* VR */
2470 hpc_platid_cpu_model = 1; /* VR41XX */
2471 hpc_platid_cpu_submodel = 3; /* VR4121 */
2472 hpc_platid_vendor = 3; /* Casio */
2473 hpc_platid_series = 1; /* CASSIOPEIAE */
2474 hpc_platid_model = 2; /* EXXX */
2475 hpc_platid_submodel = 2; /* E105 */
2476 break;
2477 case MACHINE_HPCMIPS_NEC_MOBILEPRO_770:
2478 /* 131 MHz VR4121 */
2479 machine->machine_name = "NEC MobilePro 770";
2480 hpc_fb_addr = 0xa000000;
2481 hpc_fb_xsize = 640;
2482 hpc_fb_ysize = 240;
2483 hpc_fb_xsize_mem = 800;
2484 hpc_fb_ysize_mem = 240;
2485 hpc_fb_bits = 16;
2486 hpc_fb_encoding = BIFB_D16_0000;
2487
2488 machine->md_int.vr41xx_data = dev_vr41xx_init(machine, mem, 4121);
2489 machine->md_interrupt = vr41xx_interrupt;
2490
2491 hpc_platid_cpu_arch = 1; /* MIPS */
2492 hpc_platid_cpu_series = 1; /* VR */
2493 hpc_platid_cpu_model = 1; /* VR41XX */
2494 hpc_platid_cpu_submodel = 3; /* VR4121 */
2495 hpc_platid_vendor = 1; /* NEC */
2496 hpc_platid_series = 2; /* NEC MCR */
2497 hpc_platid_model = 2; /* MCR 5XX */
2498 hpc_platid_submodel = 4; /* MCR 520A */
2499 break;
2500 case MACHINE_HPCMIPS_NEC_MOBILEPRO_780:
2501 /* 166 (or 168) MHz VR4121 */
2502 machine->machine_name = "NEC MobilePro 780";
2503 hpc_fb_addr = 0xa180100;
2504 hpc_fb_xsize = 640;
2505 hpc_fb_ysize = 240;
2506 hpc_fb_xsize_mem = 640;
2507 hpc_fb_ysize_mem = 240;
2508 hpc_fb_bits = 16;
2509 hpc_fb_encoding = BIFB_D16_0000;
2510
2511 machine->md_int.vr41xx_data = dev_vr41xx_init(machine, mem, 4121);
2512 machine->md_interrupt = vr41xx_interrupt;
2513
2514 hpc_platid_cpu_arch = 1; /* MIPS */
2515 hpc_platid_cpu_series = 1; /* VR */
2516 hpc_platid_cpu_model = 1; /* VR41XX */
2517 hpc_platid_cpu_submodel = 3; /* VR4121 */
2518 hpc_platid_vendor = 1; /* NEC */
2519 hpc_platid_series = 2; /* NEC MCR */
2520 hpc_platid_model = 2; /* MCR 5XX */
2521 hpc_platid_submodel = 8; /* MCR 530A */
2522 break;
2523 case MACHINE_HPCMIPS_NEC_MOBILEPRO_800:
2524 /* 131 MHz VR4121 */
2525 machine->machine_name = "NEC MobilePro 800";
2526 hpc_fb_addr = 0xa000000;
2527 hpc_fb_xsize = 800;
2528 hpc_fb_ysize = 600;
2529 hpc_fb_xsize_mem = 800;
2530 hpc_fb_ysize_mem = 600;
2531 hpc_fb_bits = 16;
2532 hpc_fb_encoding = BIFB_D16_0000;
2533
2534 machine->md_int.vr41xx_data = dev_vr41xx_init(machine, mem, 4121);
2535 machine->md_interrupt = vr41xx_interrupt;
2536
2537 hpc_platid_cpu_arch = 1; /* MIPS */
2538 hpc_platid_cpu_series = 1; /* VR */
2539 hpc_platid_cpu_model = 1; /* VR41XX */
2540 hpc_platid_cpu_submodel = 3; /* VR4121 */
2541 hpc_platid_vendor = 1; /* NEC */
2542 hpc_platid_series = 2; /* NEC MCR */
2543 hpc_platid_model = 3; /* MCR 7XX */
2544 hpc_platid_submodel = 2; /* MCR 700A */
2545 break;
2546 case MACHINE_HPCMIPS_NEC_MOBILEPRO_880:
2547 /* 168 MHz VR4121 */
2548 machine->machine_name = "NEC MobilePro 880";
2549 hpc_fb_addr = 0xa0ea600;
2550 hpc_fb_xsize = 800;
2551 hpc_fb_ysize = 600;
2552 hpc_fb_xsize_mem = 800;
2553 hpc_fb_ysize_mem = 600;
2554 hpc_fb_bits = 16;
2555 hpc_fb_encoding = BIFB_D16_0000;
2556
2557 machine->md_int.vr41xx_data = dev_vr41xx_init(machine, mem, 4121);
2558 machine->md_interrupt = vr41xx_interrupt;
2559
2560 hpc_platid_cpu_arch = 1; /* MIPS */
2561 hpc_platid_cpu_series = 1; /* VR */
2562 hpc_platid_cpu_model = 1; /* VR41XX */
2563 hpc_platid_cpu_submodel = 3; /* VR4121 */
2564 hpc_platid_vendor = 1; /* NEC */
2565 hpc_platid_series = 2; /* NEC MCR */
2566 hpc_platid_model = 3; /* MCR 7XX */
2567 hpc_platid_submodel = 4; /* MCR 730A */
2568 break;
2569 case MACHINE_HPCMIPS_AGENDA_VR3:
2570 /* 66 MHz VR4181 */
2571 machine->machine_name = "Agenda VR3";
2572 /* TODO: */
2573 hpc_fb_addr = 0x1000;
2574 hpc_fb_xsize = 160;
2575 hpc_fb_ysize = 240;
2576 hpc_fb_xsize_mem = 160;
2577 hpc_fb_ysize_mem = 240;
2578 hpc_fb_bits = 4;
2579 hpc_fb_encoding = BIFB_D4_M2L_F;
2580
2581 machine->md_int.vr41xx_data = dev_vr41xx_init(machine, mem, 4181);
2582 machine->md_interrupt = vr41xx_interrupt;
2583
2584 /* TODO: Hm... irq 17 according to linux, but
2585 VRIP_INTR_SIU (=9) here? */
2586 {
2587 int x;
2588 snprintf(tmpstr, sizeof(tmpstr), "ns16550 irq=%i addr=0x0c000010", 8 + VRIP_INTR_SIU);
2589 x = (size_t)device_add(machine, tmpstr);
2590
2591 if (!machine->use_x11)
2592 machine->main_console_handle = x;
2593 }
2594
2595 hpc_platid_cpu_arch = 1; /* MIPS */
2596 hpc_platid_cpu_series = 1; /* VR */
2597 hpc_platid_cpu_model = 1; /* VR41XX */
2598 hpc_platid_cpu_submodel = 4; /* VR4181 */
2599 hpc_platid_vendor = 15; /* Agenda */
2600 hpc_platid_series = 1; /* VR */
2601 hpc_platid_model = 1; /* VR3 */
2602 hpc_platid_submodel = 0; /* - */
2603
2604 dev_ram_init(machine, 0x0f000000, 0x01000000,
2605 DEV_RAM_MIRROR | DEV_RAM_MIGHT_POINT_TO_DEVICES, 0x0);
2606 break;
2607 case MACHINE_HPCMIPS_IBM_WORKPAD_Z50:
2608 /* 131 MHz VR4121 */
2609 machine->machine_name = "IBM Workpad Z50";
2610 /* TODO: */
2611 hpc_fb_addr = 0xa000000;
2612 hpc_fb_xsize = 640;
2613 hpc_fb_ysize = 480;
2614 hpc_fb_xsize_mem = 640;
2615 hpc_fb_ysize_mem = 480;
2616 hpc_fb_bits = 16;
2617 hpc_fb_encoding = BIFB_D16_0000;
2618
2619 machine->md_int.vr41xx_data = dev_vr41xx_init(machine, mem, 4121);
2620 machine->md_interrupt = vr41xx_interrupt;
2621
2622 hpc_platid_cpu_arch = 1; /* MIPS */
2623 hpc_platid_cpu_series = 1; /* VR */
2624 hpc_platid_cpu_model = 1; /* VR41XX */
2625 hpc_platid_cpu_submodel = 3; /* VR4121 */
2626 hpc_platid_vendor = 9; /* IBM */
2627 hpc_platid_series = 1; /* WorkPad */
2628 hpc_platid_model = 1; /* Z50 */
2629 hpc_platid_submodel = 0; /* 0 */
2630 break;
2631 default:
2632 printf("Unimplemented hpcmips machine number.\n");
2633 exit(1);
2634 }
2635
2636 store_32bit_word_in_host(cpu, (unsigned char *)&hpc_bootinfo.platid_cpu,
2637 (hpc_platid_cpu_arch << 26) + (hpc_platid_cpu_series << 20)
2638 + (hpc_platid_cpu_model << 14) + (hpc_platid_cpu_submodel << 8)
2639 + hpc_platid_flags);
2640 store_32bit_word_in_host(cpu, (unsigned char *)&hpc_bootinfo.platid_machine,
2641 (hpc_platid_vendor << 22) + (hpc_platid_series << 16)
2642 + (hpc_platid_model << 8) + hpc_platid_submodel);
2643
2644 if (machine->use_x11)
2645 machine->main_console_handle =
2646 machine->md_int.vr41xx_data->kiu_console_handle;
2647
2648 if (machine->prom_emulation) {
2649 /* NetBSD/hpcmips and possibly others expects the following: */
2650
2651 cpu->cd.mips.gpr[MIPS_GPR_A0] = 1; /* argc */
2652 cpu->cd.mips.gpr[MIPS_GPR_A1] = machine->physical_ram_in_mb * 1048576
2653 + 0xffffffff80000000ULL - 512; /* argv */
2654 cpu->cd.mips.gpr[MIPS_GPR_A2] = machine->physical_ram_in_mb * 1048576
2655 + 0xffffffff80000000ULL - 256; /* ptr to hpc_bootinfo */
2656
2657 bootstr = machine->boot_kernel_filename;
2658 store_32bit_word(cpu, 0xffffffff80000000ULL + machine->physical_ram_in_mb * 1048576 - 512,
2659 0xffffffff80000000ULL + machine->physical_ram_in_mb * 1048576 - 512 + 16);
2660 store_32bit_word(cpu, 0xffffffff80000000ULL + machine->physical_ram_in_mb * 1048576 - 512 + 4, 0);
2661 store_string(cpu, 0xffffffff80000000ULL + machine->physical_ram_in_mb * 1048576 - 512 + 16, bootstr);
2662
2663 /* Special case for the Agenda VR3: */
2664 if (machine->machine_subtype == MACHINE_HPCMIPS_AGENDA_VR3) {
2665 const int tmplen = 1000;
2666 char *tmp = malloc(tmplen);
2667
2668 cpu->cd.mips.gpr[MIPS_GPR_A0] = 2; /* argc */
2669
2670 store_32bit_word(cpu, 0x80000000 + machine->physical_ram_in_mb * 1048576 - 512 + 4, 0x80000000 + machine->physical_ram_in_mb * 1048576 - 512 + 64);
2671 store_32bit_word(cpu, 0x80000000 + machine->physical_ram_in_mb * 1048576 - 512 + 8, 0);
2672
2673 snprintf(tmp, tmplen, "root=/dev/rom video=vr4181fb:xres:160,yres:240,bpp:4,"
2674 "gray,hpck:3084,inv ether=0,0x03fe0300,eth0");
2675 tmp[tmplen-1] = '\0';
2676
2677 if (!machine->use_x11)
2678 snprintf(tmp+strlen(tmp), tmplen-strlen(tmp), " console=ttyS0,115200");
2679 tmp[tmplen-1] = '\0';
2680
2681 if (machine->boot_string_argument[0])
2682 snprintf(tmp+strlen(tmp), tmplen-strlen(tmp), " %s", machine->boot_string_argument);
2683 tmp[tmplen-1] = '\0';
2684
2685 store_string(cpu, 0x80000000 + machine->physical_ram_in_mb * 1048576 - 512 + 64, tmp);
2686
2687 bootarg = tmp;
2688 } else if (machine->boot_string_argument[0]) {
2689 cpu->cd.mips.gpr[MIPS_GPR_A0] ++; /* argc */
2690
2691 store_32bit_word(cpu, 0x80000000 + machine->physical_ram_in_mb * 1048576 - 512 + 4, 0x80000000 + machine->physical_ram_in_mb * 1048576 - 512 + 64);
2692 store_32bit_word(cpu, 0x80000000 + machine->physical_ram_in_mb * 1048576 - 512 + 8, 0);
2693
2694 store_string(cpu, 0x80000000 + machine->physical_ram_in_mb * 1048576 - 512 + 64,
2695 machine->boot_string_argument);
2696
2697 bootarg = machine->boot_string_argument;
2698 }
2699
2700 store_16bit_word_in_host(cpu, (unsigned char *)&hpc_bootinfo.length, sizeof(hpc_bootinfo));
2701 store_32bit_word_in_host(cpu, (unsigned char *)&hpc_bootinfo.magic, HPC_BOOTINFO_MAGIC);
2702 store_32bit_word_in_host(cpu, (unsigned char *)&hpc_bootinfo.fb_addr, 0x80000000 + hpc_fb_addr);
2703 store_16bit_word_in_host(cpu, (unsigned char *)&hpc_bootinfo.fb_line_bytes, hpc_fb_xsize_mem * (((hpc_fb_bits-1)|7)+1) / 8);
2704 store_16bit_word_in_host(cpu, (unsigned char *)&hpc_bootinfo.fb_width, hpc_fb_xsize);
2705 store_16bit_word_in_host(cpu, (unsigned char *)&hpc_bootinfo.fb_height, hpc_fb_ysize);
2706 store_16bit_word_in_host(cpu, (unsigned char *)&hpc_bootinfo.fb_type, hpc_fb_encoding);
2707 store_16bit_word_in_host(cpu, (unsigned char *)&hpc_bootinfo.bi_cnuse, BI_CNUSE_BUILTIN); /* _BUILTIN or _SERIAL */
2708
2709 /* printf("hpc_bootinfo.platid_cpu = 0x%08x\n", hpc_bootinfo.platid_cpu);
2710 printf("hpc_bootinfo.platid_machine = 0x%08x\n", hpc_bootinfo.platid_machine); */
2711 store_32bit_word_in_host(cpu, (unsigned char *)&hpc_bootinfo.timezone, 0);
2712 store_buf(cpu, 0x80000000 + machine->physical_ram_in_mb * 1048576 - 256, (char *)&hpc_bootinfo, sizeof(hpc_bootinfo));
2713 }
2714
2715 if (hpc_fb_addr != 0) {
2716 dev_fb_init(machine, mem, hpc_fb_addr, VFB_HPC,
2717 hpc_fb_xsize, hpc_fb_ysize,
2718 hpc_fb_xsize_mem, hpc_fb_ysize_mem,
2719 hpc_fb_bits, machine->machine_name);
2720
2721 /* NetBSD/hpcmips uses framebuffer at physical
2722 address 0x8.......: */
2723 dev_ram_init(machine, 0x80000000, 0x20000000,
2724 DEV_RAM_MIRROR | DEV_RAM_MIGHT_POINT_TO_DEVICES, 0x0);
2725 }
2726
2727 break;
2728
2729 case MACHINE_PS2:
2730 cpu->byte_order = EMUL_LITTLE_ENDIAN;
2731 machine->machine_name = "Playstation 2";
2732
2733 if (machine->physical_ram_in_mb != 32)
2734 fprintf(stderr, "WARNING! Playstation 2 machines are supposed to have exactly 32 MB RAM. Continuing anyway.\n");
2735 if (!machine->use_x11)
2736 fprintf(stderr, "WARNING! Playstation 2 without -X is pretty meaningless. Continuing anyway.\n");
2737
2738 /*
2739 * According to NetBSD:
2740 * Hardware irq 0 is timer/interrupt controller
2741 * Hardware irq 1 is dma controller
2742 *
2743 * Some things are not yet emulated (at all), and hence are detected incorrectly:
2744 * sbus0 at mainbus0: controller type 2
2745 * ohci0 at sbus0 (at 0x1f801600, according to linux)
2746 * ohci0: OHCI version 1.0
2747 */
2748
2749 machine->md_int.ps2_data = dev_ps2_stuff_init(machine, mem, 0x10000000);
2750 device_add(machine, "ps2_gs addr=0x12000000");
2751 device_add(machine, "ps2_ether addr=0x14001000");
2752 dev_ram_init(machine, 0x1c000000, 4 * 1048576, DEV_RAM_RAM, 0); /* TODO: how much? */
2753 /* irq = 8 + 32 + 1 (SBUS/USB) */
2754 device_add(machine, "ohci addr=0x1f801600 irq=41");
2755
2756 machine->md_interrupt = ps2_interrupt;
2757
2758 /* Set the Harddisk controller present flag, if either
2759 disk 0 or 1 is present: */
2760 if (diskimage_exist(machine, 0, DISKIMAGE_IDE) ||
2761 diskimage_exist(machine, 1, DISKIMAGE_IDE)) {
2762 if (machine->prom_emulation)
2763 store_32bit_word(cpu, 0xa0000000 + machine->physical_ram_in_mb*1048576 - 0x1000 + 0x0, 0x100);
2764 dev_ps2_spd_init(machine, mem, 0x14000000);
2765 }
2766
2767 if (machine->prom_emulation) {
2768 int tmplen = 1000;
2769 char *tmp = malloc(tmplen);
2770 time_t timet;
2771 struct tm *tm_ptr;
2772
2773 add_symbol_name(&machine->symbol_context,
2774 PLAYSTATION2_SIFBIOS, 0x10000, "[SIFBIOS entry]", 0, 0);
2775 store_32bit_word(cpu, PLAYSTATION2_BDA + 0, PLAYSTATION2_SIFBIOS);
2776 store_buf(cpu, PLAYSTATION2_BDA + 4, "PS2b", 4);
2777
2778 store_32bit_word(cpu, 0xa0000000 + machine->physical_ram_in_mb*1048576 - 0x1000 + 0x4, PLAYSTATION2_OPTARGS);
2779 if (tmp == NULL) {
2780 fprintf(stderr, "out of memory\n");
2781 exit(1);
2782 }
2783
2784 strlcpy(tmp, "root=/dev/hda1 crtmode=vesa0,60", tmplen);
2785
2786 if (machine->boot_string_argument[0])
2787 snprintf(tmp+strlen(tmp), tmplen-strlen(tmp),
2788 " %s", machine->boot_string_argument);
2789 tmp[tmplen-1] = '\0';
2790
2791 bootstr = tmp;
2792 store_string(cpu, PLAYSTATION2_OPTARGS, bootstr);
2793
2794 /* TODO: netbsd's bootinfo.h, for symbolic names */
2795
2796 /* RTC data given by the BIOS: */
2797 timet = time(NULL) + 9*3600; /* PS2 uses Japanese time */
2798 tm_ptr = gmtime(&timet);
2799 /* TODO: are these 0- or 1-based? */
2800 store_byte(cpu, 0xa0000000 + machine->physical_ram_in_mb*1048576 - 0x1000 + 0x10 + 1, int_to_bcd(tm_ptr->tm_sec));
2801 store_byte(cpu, 0xa0000000 + machine->physical_ram_in_mb*1048576 - 0x1000 + 0x10 + 2, int_to_bcd(tm_ptr->tm_min));
2802 store_byte(cpu, 0xa0000000 + machine->physical_ram_in_mb*1048576 - 0x1000 + 0x10 + 3, int_to_bcd(tm_ptr->tm_hour));
2803 store_byte(cpu, 0xa0000000 + machine->physical_ram_in_mb*1048576 - 0x1000 + 0x10 + 5, int_to_bcd(tm_ptr->tm_mday));
2804 store_byte(cpu, 0xa0000000 + machine->physical_ram_in_mb*1048576 - 0x1000 + 0x10 + 6, int_to_bcd(tm_ptr->tm_mon + 1));
2805 store_byte(cpu, 0xa0000000 + machine->physical_ram_in_mb*1048576 - 0x1000 + 0x10 + 7, int_to_bcd(tm_ptr->tm_year - 100));
2806
2807 /* "BOOTINFO_PCMCIA_TYPE" in NetBSD's bootinfo.h. This contains the sbus controller type. */
2808 store_32bit_word(cpu, 0xa0000000 + machine->physical_ram_in_mb*1048576 - 0x1000 + 0x1c, 2);
2809 }
2810
2811 break;
2812
2813 case MACHINE_SGI:
2814 case MACHINE_ARC:
2815 /*
2816 * SGI and ARC emulation share a lot of code. (SGI is a special case of
2817 * "almost ARC".)
2818 *
2819 * http://obsolete.majix.org/computers/sgi/iptable.shtml contains a pretty
2820 * detailed list of IP ("Inhouse Processor") model numbers.
2821 * (Or http://hardware.majix.org/computers/sgi/iptable.shtml)
2822 */
2823 machine->machine_name = malloc(MACHINE_NAME_MAXBUF);
2824 if (machine->machine_name == NULL) {
2825 fprintf(stderr, "out of memory\n");
2826 exit(1);
2827 }
2828
2829 if (machine->machine_type == MACHINE_SGI) {
2830 cpu->byte_order = EMUL_BIG_ENDIAN;
2831 snprintf(machine->machine_name, MACHINE_NAME_MAXBUF,
2832 "SGI-IP%i", machine->machine_subtype);
2833
2834 sgi_ram_offset = 1048576 * machine->memory_offset_in_mb;
2835
2836 /* Special cases for IP20,22,24,26 memory offset: */
2837 if (machine->machine_subtype == 20 || machine->machine_subtype == 22 ||
2838 machine->machine_subtype == 24 || machine->machine_subtype == 26) {
2839 dev_ram_init(machine, 0x00000000, 0x10000, DEV_RAM_MIRROR
2840 | DEV_RAM_MIGHT_POINT_TO_DEVICES, sgi_ram_offset);
2841 dev_ram_init(machine, 0x00050000, sgi_ram_offset-0x50000,
2842 DEV_RAM_MIRROR | DEV_RAM_MIGHT_POINT_TO_DEVICES, sgi_ram_offset + 0x50000);
2843 }
2844
2845 /* Special cases for IP28,30 memory offset: */
2846 if (machine->machine_subtype == 28 || machine->machine_subtype == 30) {
2847 /* TODO: length below should maybe not be 128MB? */
2848 dev_ram_init(machine, 0x00000000, 128*1048576, DEV_RAM_MIRROR | DEV_RAM_MIGHT_POINT_TO_DEVICES, sgi_ram_offset);
2849 }
2850 } else {
2851 cpu->byte_order = EMUL_LITTLE_ENDIAN;
2852 snprintf(machine->machine_name,
2853 MACHINE_NAME_MAXBUF, "ARC");
2854 }
2855
2856 if (machine->machine_type == MACHINE_SGI) {
2857 /* TODO: Other SGI machine types? */
2858 switch (machine->machine_subtype) {
2859 case 10:
2860 strlcat(machine->machine_name, " (4D/25)", MACHINE_NAME_MAXBUF);
2861 /* TODO */
2862 break;
2863 case 12:
2864 strlcat(machine->machine_name,
2865 " (Iris Indigo IP12)", MACHINE_NAME_MAXBUF);
2866
2867 /* TODO */
2868 /* 33 MHz R3000, according to http://www.irisindigo.com/ */
2869 /* "capable of addressing up to 96MB of memory." */
2870
2871 break;
2872 case 19:
2873 strlcat(machine->machine_name,
2874 " (Everest IP19)", MACHINE_NAME_MAXBUF);
2875 machine->main_console_handle =
2876 dev_zs_init(machine, mem, 0x1fbd9830, 0, 1, "serial zs"); /* serial? netbsd? */
2877 dev_scc_init(machine, mem, 0x10086000, 0, machine->use_x11, 0, 8); /* serial? irix? */
2878
2879 device_add(machine, "sgi_ip19 addr=0x18000000");
2880
2881 /* Irix' <everest_du_init+0x130> reads this device: */
2882 device_add(machine, "random addr=0x10006000 len=16");
2883
2884 /* Irix' get_mpconf() looks for this: (TODO) */
2885 store_32bit_word(cpu, 0xa0000000 + 0x3000,
2886 0xbaddeed2);
2887
2888 /* Memory size, not 4096 byte pages, but 256 bytes? (16 is size of kernel... approx) */
2889 store_32bit_word(cpu, 0xa0000000 + 0x26d0,
2890 30000); /* (machine->physical_ram_in_mb - 16) * (1048576 / 256)); */
2891
2892 break;
2893 case 20:
2894 strlcat(machine->machine_name,
2895 " (Indigo)", MACHINE_NAME_MAXBUF);
2896
2897 /*
2898 * Guesses based on NetBSD 2.0 beta, 20040606.
2899 *
2900 * int0 at mainbus0 addr 0x1fb801c0: bus 1MHz, CPU 2MHz
2901 * imc0 at mainbus0 addr 0x1fa00000: revision 0
2902 * gio0 at imc0
2903 * unknown GIO card (product 0x00 revision 0x00) at gio0 slot 0 addr 0x1f400000 not configured
2904 * unknown GIO card (product 0x00 revision 0x00) at gio0 slot 1 addr 0x1f600000 not configured
2905 * unknown GIO card (product 0x00 revision 0x00) at gio0 slot 2 addr 0x1f000000 not configured
2906 * hpc0 at gio0 addr 0x1fb80000: SGI HPC1
2907 * zsc0 at hpc0 offset 0xd10 (channels 0 and 1, channel 1 for console)
2908 * zsc1 at hpc0 offset 0xd00 (2 channels)
2909 * sq0 at hpc0 offset 0x100: SGI Seeq 80c03
2910 * wdsc0 at hpc0 offset 0x11f
2911 * dpclock0 at hpc0 offset 0xe00
2912 */
2913
2914 /* int0 at mainbus0 addr 0x1fb801c0 */
2915 machine->md_int.sgi_ip20_data = dev_sgi_ip20_init(cpu, mem, DEV_SGI_IP20_BASE);
2916
2917 /* imc0 at mainbus0 addr 0x1fa00000: revision 0: TODO (or in dev_sgi_ip20?) */
2918
2919 dev_zs_init(machine, mem, 0x1fbd9830, 0, 1, "zs console");
2920
2921 /* This is the zsc0 reported by NetBSD: TODO: irqs */
2922 machine->main_console_handle = dev_zs_init(machine, mem, 0x1fb80d10, 0, 1, "zsc0"); /* zsc0 */
2923 dev_zs_init(machine, mem, 0x1fb80d00, 0, 1, "zsc1"); /* zsc1 */
2924
2925 /* WDSC SCSI controller: */
2926 dev_wdsc_init(machine, mem, 0x1fb8011f, 0, 0);
2927
2928 /* Return memory read errors so that hpc1
2929 and hpc2 are not detected: */
2930 device_add(machine, "unreadable addr=0x1fb00000 len=0x10000");
2931 device_add(machine, "unreadable addr=0x1f980000 len=0x10000");
2932
2933 /* Return nothing for gio slots 0, 1, and 2: */
2934 device_add(machine, "unreadable addr=0x1f400000 len=0x1000"); /* gio0 slot 0 */
2935 device_add(machine, "unreadable addr=0x1f600000 len=0x1000"); /* gio0 slot 1 */
2936 device_add(machine, "unreadable addr=0x1f000000 len=0x1000"); /* gio0 slot 2 */
2937
2938 break;
2939 case 21:
2940 strlcat(machine->machine_name, /* TODO */
2941 " (uknown SGI-IP21 ?)", MACHINE_NAME_MAXBUF);
2942 /* NOTE: Special case for arc_wordlen: */
2943 arc_wordlen = sizeof(uint64_t);
2944
2945 device_add(machine, "random addr=0x418000200, len=0x20000");
2946
2947 break;
2948 case 22:
2949 case 24:
2950 if (machine->machine_subtype == 22) {
2951 strlcat(machine->machine_name,
2952 " (Indy, Indigo2, Challenge S; Full-house)",
2953 MACHINE_NAME_MAXBUF);
2954 machine->md_int.sgi_ip22_data = dev_sgi_ip22_init(machine, mem, 0x1fbd9000, 0);
2955 } else {
2956 strlcat(machine->machine_name,
2957 " (Indy, Indigo2, Challenge S; Guiness)",
2958 MACHINE_NAME_MAXBUF);
2959 machine->md_int.sgi_ip22_data = dev_sgi_ip22_init(machine, mem, 0x1fbd9880, 1);
2960 }
2961
2962 /*
2963 Why is this here? TODO
2964 dev_ram_init(machine, 0x88000000ULL,
2965 128 * 1048576, DEV_RAM_MIRROR, 0x08000000);
2966 */
2967 machine->md_interrupt = sgi_ip22_interrupt;
2968
2969 /*
2970 * According to NetBSD 1.6.2:
2971 *
2972 * imc0 at mainbus0 addr 0x1fa00000, Revision 0
2973 * gio0 at imc0
2974 * hpc0 at gio0 addr 0x1fb80000: SGI HPC3
2975 * zsc0 at hpc0 offset 0x59830
2976 * zstty0 at zsc0 channel 1 (console i/o)
2977 * zstty1 at zsc0 channel 0
2978 * sq0 at hpc0 offset 0x54000: SGI Seeq 80c03 (Ethernet)
2979 * wdsc0 at hpc0 offset 0x44000: WD33C93 SCSI, rev=0, target 7
2980 * scsibus2 at wdsc0: 8 targets, 8 luns per target
2981 * dsclock0 at hpc0 offset 0x60000
2982 *
2983 * According to Linux/IP22:
2984 * tty00 at 0xbfbd9830 (irq = 45) is a Zilog8530
2985 * tty01 at 0xbfbd9838 (irq = 45) is a Zilog8530
2986 *
2987 * and according to NetBSD 2.0_BETA (20040606):
2988 *
2989 * haltwo0 at hpc0 offset 0x58000: HAL2 revision 0.0.0
2990 * audio0 at haltwo0: half duplex
2991 *
2992 * IRQ numbers are of the form 8 + x, where x = 0..31 for local0
2993 * interrupts, and 32..63 for local1. + y*65 for "mappable".
2994 */
2995
2996 /* zsc0 serial console. */
2997 i = dev_zs_init(machine, mem, 0x1fbd9830,
2998 8 + 32 + 3 + 64*5, 1, "zsc0");
2999
3000 /* Not supported by NetBSD 1.6.2, but by 2.0_BETA: */
3001 j = dev_pckbc_init(machine, mem, 0x1fbd9840, PCKBC_8242,
3002 0, 0, machine->use_x11, 0); /* TODO: irq numbers */
3003
3004 if (machine->use_x11)
3005 machine->main_console_handle = j;
3006
3007 /* sq0: Ethernet. TODO: This should have irq_nr = 8 + 3 */
3008 /* dev_sq_init... */
3009
3010 /* wdsc0: SCSI */
3011 dev_wdsc_init(machine, mem, 0x1fbc4000, 0, 8 + 1);
3012
3013 /* wdsc1: SCSI TODO: irq nr */
3014 dev_wdsc_init(machine, mem, 0x1fbcc000, 1, 8 + 1);
3015
3016 /* dsclock0: TODO: possibly irq 8 + 33 */
3017
3018 /* Return memory read errors so that hpc1 and hpc2 are not detected: */
3019 device_add(machine, "unreadable addr=0x1fb00000, len=0x10000");
3020 device_add(machine, "unreadable addr=0x1f980000, len=0x10000");
3021
3022 /* Similarly for gio slots 0, 1, and 2: */
3023 device_add(machine, "unreadable addr=0x1f400000, len=0x1000"); /* gio0 slot 0 */
3024 device_add(machine, "unreadable addr=0x1f600000, len=0x1000"); /* gio0 slot 1 */
3025 device_add(machine, "unreadable addr=0x1f000000, len=0x1000"); /* gio0 slot 2 */
3026
3027 break;
3028 case 25:
3029 /* NOTE: Special case for arc_wordlen: */
3030 arc_wordlen = sizeof(uint64_t);
3031 strlcat(machine->machine_name,
3032 " (Everest IP25)", MACHINE_NAME_MAXBUF);
3033
3034 /* serial? irix? */
3035 dev_scc_init(machine, mem,
3036 0x400086000ULL, 0, machine->use_x11, 0, 8);
3037
3038 /* NOTE: ip19! (perhaps not really the same */
3039 device_add(machine, "sgi_ip19 addr=0x18000000");
3040
3041 /*
3042 * Memory size, not 4096 byte pages, but 256
3043 * bytes? (16 is size of kernel... approx)
3044 */
3045 store_32bit_word(cpu, 0xa0000000ULL + 0x26d0,
3046 30000); /* (machine->physical_ram_in_mb - 16)
3047 * (1048576 / 256)); */
3048
3049 break;
3050 case 26:
3051 /* NOTE: Special case for arc_wordlen: */
3052 arc_wordlen = sizeof(uint64_t);
3053 strlcat(machine->machine_name,
3054 " (uknown SGI-IP26 ?)",
3055 MACHINE_NAME_MAXBUF); /* TODO */
3056 machine->main_console_handle =
3057 dev_zs_init(machine, mem, 0x1fbd9830,
3058 0, 1, "zs console");
3059 break;
3060 case 27:
3061 strlcat(machine->machine_name,
3062 " (Origin 200/2000, Onyx2)",
3063 MACHINE_NAME_MAXBUF);
3064 arc_wordlen = sizeof(uint64_t);
3065 /* 2 cpus per node */
3066
3067 machine->main_console_handle =
3068 dev_zs_init(machine, mem, 0x1fbd9830,
3069 0, 1, "zs console");
3070 break;
3071 case 28:
3072 /* NOTE: Special case for arc_wordlen: */
3073 arc_wordlen = sizeof(uint64_t);
3074 strlcat(machine->machine_name,
3075 " (Impact Indigo2 ?)", MACHINE_NAME_MAXBUF);
3076
3077 device_add(machine, "random addr=0x1fbe0000, len=1");
3078
3079 /* Something at paddr 0x1880fb0000. */
3080
3081 break;
3082 case 30:
3083 /* NOTE: Special case for arc_wordlen: */
3084 arc_wordlen = sizeof(uint64_t);
3085 strlcat(machine->machine_name,
3086 " (Octane)", MACHINE_NAME_MAXBUF);
3087
3088 machine->md_int.sgi_ip30_data = dev_sgi_ip30_init(machine, mem, 0x0ff00000);
3089 machine->md_interrupt = sgi_ip30_interrupt;
3090
3091 dev_ram_init(machine, 0xa0000000ULL,
3092 128 * 1048576, DEV_RAM_MIRROR
3093 | DEV_RAM_MIGHT_POINT_TO_DEVICES,
3094 0x00000000);
3095
3096 dev_ram_init(machine, 0x80000000ULL,
3097 32 * 1048576, DEV_RAM_RAM, 0x00000000);
3098
3099 /*
3100 * Something at paddr=1f022004: TODO
3101 * Something at paddr=813f0510 - paddr=813f0570 ?
3102 * Something at paddr=813f04b8
3103 * Something at paddr=f8000003c used by Linux/Octane
3104 *
3105 * 16550 serial port at paddr=1f620178, addr mul 1
3106 * (Error messages are printed to this serial port by the PROM.)
3107 *
3108 * There seems to also be a serial port at 1f620170. The "symmon"
3109 * program dumps something there, but it doesn't look like
3110 * readable text. (TODO)
3111 */
3112
3113 /* TODO: irq! */
3114 snprintf(tmpstr, sizeof(tmpstr), "ns16550 irq=0 addr=0x1f620170 name2=tty0 in_use=%i", machine->use_x11? 0 : 1);
3115 machine->main_console_handle = (size_t)device_add(machine, tmpstr);
3116 snprintf(tmpstr, sizeof(tmpstr), "ns16550 irq=0 addr=0x1f620178 name2=tty1 in_use=0");
3117 device_add(machine, tmpstr);
3118
3119 /* MardiGras graphics: */
3120 device_add(machine, "sgi_mardigras addr=0x1c000000");
3121
3122 break;
3123 case 32:
3124 strlcat(machine->machine_name,
3125 " (O2)", MACHINE_NAME_MAXBUF);
3126
3127 /* TODO: Find out where the physical ram is actually located. */
3128 dev_ram_init(machine, 0x07ffff00ULL, 256, DEV_RAM_MIRROR, 0x03ffff00);
3129 dev_ram_init(machine, 0x10000000ULL, 256, DEV_RAM_MIRROR, 0x00000000);
3130 dev_ram_init(machine, 0x11ffff00ULL, 256, DEV_RAM_MIRROR, 0x01ffff00);
3131 dev_ram_init(machine, 0x12000000ULL, 256, DEV_RAM_MIRROR, 0x02000000);
3132 dev_ram_init(machine, 0x17ffff00ULL, 256, DEV_RAM_MIRROR, 0x03ffff00);
3133 dev_ram_init(machine, 0x20000000ULL, 128 * 1048576, DEV_RAM_MIRROR, 0x00000000);
3134 dev_ram_init(machine, 0x40000000ULL, 128 * 1048576, DEV_RAM_MIRROR, 0x10000000);
3135
3136 machine->md_int.ip32.crime_data = dev_crime_init(machine, mem, 0x14000000, 2, machine->use_x11); /* crime0 */
3137 dev_sgi_mte_init(mem, 0x15000000); /* mte ??? memory thing */
3138 dev_sgi_gbe_init(machine, mem, 0x16000000); /* gbe? framebuffer? */
3139
3140 /*
3141 * A combination of NetBSD and Linux info:
3142 *
3143 * 17000000 vice (Video Image Compression Engine)
3144 * 1f000000 mace
3145 * 1f080000 macepci
3146 * 1f100000 vin1
3147 * 1f180000 vin2
3148 * 1f200000 vout
3149 * 1f280000 enet (mec0, MAC-110 Ethernet)
3150 * 1f300000 perif:
3151 * 1f300000 audio
3152 * 1f310000 isa
3153 * 1f318000 (accessed by Irix' pciio_pio_write64)
3154 * 1f320000 kbdms
3155 * 1f330000 i2c
3156 * 1f340000 ust
3157 * 1f380000 isa ext
3158 * 1f390000 com0 (serial)
3159 * 1f398000 com1 (serial)
3160 * 1f3a0000 mcclock0
3161 */
3162
3163 machine->md_int.ip32.mace_data = dev_mace_init(mem, 0x1f310000, 2);
3164 machine->md_interrupt = sgi_ip32_interrupt;
3165
3166 /*
3167 * IRQ mapping is really ugly. TODO: fix
3168 *
3169 * com0 at mace0 offset 0x390000 intr 4 intrmask 0x3f00000: ns16550a, working fifo
3170 * com1 at mace0 offset 0x398000 intr 4 intrmask 0xfc000000: ns16550a, working fifo
3171 * pckbc0 at mace0 offset 0x320000 intr 5 intrmask 0x0
3172 * mcclock0 at mace0 offset 0x3a0000 intrmask 0x0
3173 * macepci0 at mace0 offset 0x80000 intr 7 intrmask 0x0: rev 1
3174 *
3175 * intr 4 = MACE_PERIPH_SERIAL
3176 * intr 5 = MACE_PERIPH_MISC
3177 * intr 7 = MACE_PCI_BRIDGE
3178 */
3179
3180 net_generate_unique_mac(machine, macaddr);
3181 eaddr_string = malloc(ETHERNET_STRING_MAXLEN);
3182 if (eaddr_string == NULL) {
3183 fprintf(stderr, "out of memory\n");
3184 exit(1);
3185 }
3186 snprintf(eaddr_string, ETHERNET_STRING_MAXLEN,
3187 "eaddr=%02x:%02x:%02x:%02x:%02x:%02x",
3188 macaddr[0], macaddr[1], macaddr[2],
3189 macaddr[3], macaddr[4], macaddr[5]);
3190 dev_sgi_mec_init(machine, mem, 0x1f280000,
3191 MACE_ETHERNET, macaddr);
3192
3193 dev_sgi_ust_init(mem, 0x1f340000); /* ust? */
3194
3195 snprintf(tmpstr, sizeof(tmpstr), "ns16550 irq=%i addr=0x1f390000 addr_mult=0x100 in_use=%i name2=tty0",
3196 (1<<20) + MACE_PERIPH_SERIAL, machine->use_x11? 0 : 1);
3197 j = (size_t)device_add(machine, tmpstr);
3198 snprintf(tmpstr, sizeof(tmpstr), "ns16550 irq=%i addr=0x1f398000 addr_mult=0x100 in_use=%i name2=tty1",
3199 (1<<26) + MACE_PERIPH_SERIAL, 0);
3200 device_add(machine, tmpstr);
3201
3202 machine->main_console_handle = j;
3203
3204 /* TODO: Once this works, it should be enabled
3205 always, not just when using X! */
3206 if (machine->use_x11) {
3207 i = dev_pckbc_init(machine, mem, 0x1f320000,
3208 PCKBC_8242, 0x200 + MACE_PERIPH_MISC,
3209 0x800 + MACE_PERIPH_MISC, machine->use_x11, 0);
3210 /* keyb+mouse (mace irq numbers) */
3211 machine->main_console_handle = i;
3212 }
3213
3214 dev_mc146818_init(machine, mem, 0x1f3a0000, (1<<8) + MACE_PERIPH_MISC, MC146818_SGI, 0x40); /* mcclock0 */
3215 dev_zs_init(machine, mem, 0x1fbd9830, 0, 1, "zs console");
3216
3217 /*
3218 * PCI devices: (according to NetBSD's GENERIC config file for sgimips)
3219 *
3220 * ne* at pci? dev ? function ?
3221 * ahc0 at pci0 dev 1 function ?
3222 * ahc1 at pci0 dev 2 function ?
3223 */
3224
3225 pci_data = dev_macepci_init(mem, 0x1f080000, MACE_PCI_BRIDGE); /* macepci0 */
3226 /* bus_pci_add(machine, pci_data, mem, 0, 0, 0, pci_ne2000_init, pci_ne2000_rr); TODO */
3227
3228 /* TODO: make this nicer */
3229 if (diskimage_exist(machine, 0, DISKIMAGE_SCSI) ||
3230 diskimage_exist(machine, 1, DISKIMAGE_SCSI) ||
3231 diskimage_exist(machine, 2, DISKIMAGE_SCSI) ||
3232 diskimage_exist(machine, 3, DISKIMAGE_SCSI) ||
3233 diskimage_exist(machine, 4, DISKIMAGE_SCSI) ||
3234 diskimage_exist(machine, 5, DISKIMAGE_SCSI) ||
3235 diskimage_exist(machine, 6, DISKIMAGE_SCSI) ||
3236 diskimage_exist(machine, 7, DISKIMAGE_SCSI))
3237 bus_pci_add(machine, pci_data, mem, 0, 1, 0, pci_ahc_init, pci_ahc_rr);
3238
3239 /* TODO: second ahc */
3240 /* bus_pci_add(machine, pci_data, mem, 0, 2, 0, pci_ahc_init, pci_ahc_rr); */
3241
3242 break;
3243 case 35:
3244 strlcat(machine->machine_name,
3245 " (Origin 3000)", MACHINE_NAME_MAXBUF);
3246 /* 4 cpus per node */
3247
3248 machine->main_console_handle =
3249 dev_zs_init(machine, mem, 0x1fbd9830,
3250 0, 1, "zs console");
3251 break;
3252 case 53:
3253 strlcat(machine->machine_name,
3254 " (Origin 350)", MACHINE_NAME_MAXBUF);
3255 /*
3256 * According to http://kumba.drachentekh.net/xml/myguide.html
3257 * Origin 350, Tezro IP53 R16000
3258 */
3259 break;
3260 default:
3261 fatal("unimplemented SGI machine type IP%i\n",
3262 machine->machine_subtype);
3263 exit(1);
3264 }
3265 } else {
3266 switch (machine->machine_subtype) {
3267
3268 case MACHINE_ARC_NEC_RD94:
3269 case MACHINE_ARC_NEC_R94:
3270 case MACHINE_ARC_NEC_R96:
3271 /*
3272 * "NEC-RD94" (NEC RISCstation 2250)
3273 * "NEC-R94" (NEC RISCstation 2200)
3274 * "NEC-R96" (NEC Express RISCserver)
3275 *
3276 * http://mirror.aarnet.edu.au/pub/NetBSD/misc/chs/arcdiag.out (NEC-R96)
3277 */
3278
3279 switch (machine->machine_subtype) {
3280 case MACHINE_ARC_NEC_RD94:
3281 strlcat(machine->machine_name,
3282 " (NEC-RD94, NEC RISCstation 2250)",
3283 MACHINE_NAME_MAXBUF);
3284 break;
3285 case MACHINE_ARC_NEC_R94:
3286 strlcat(machine->machine_name, " (NEC-R94; NEC RISCstation 2200)",
3287 MACHINE_NAME_MAXBUF);
3288 break;
3289 case MACHINE_ARC_NEC_R96:
3290 strlcat(machine->machine_name, " (NEC-R96; NEC Express RISCserver)",
3291 MACHINE_NAME_MAXBUF);
3292 break;
3293 }
3294
3295 /* TODO: interrupt controller! */
3296
3297 pci_data = device_add(machine,
3298 "rd94 addr=0x80000000, irq=0");
3299
3300 device_add(machine, "sn addr=0x80001000 irq=0");
3301 dev_mc146818_init(machine, mem, 0x80004000ULL, 0, MC146818_ARC_NEC, 1);
3302 i = dev_pckbc_init(machine, mem, 0x80005000ULL, PCKBC_8042, 0, 0, machine->use_x11, 0);
3303
3304 snprintf(tmpstr, sizeof(tmpstr), "ns16550 irq=3 addr=0x80006000 in_use=%i name2=tty0", machine->use_x11? 0 : 1);
3305 j = (size_t)device_add(machine, tmpstr);
3306 snprintf(tmpstr, sizeof(tmpstr), "ns16550 irq=0 addr=0x80007000 in_use=%i name2=tty1", 0);
3307 device_add(machine, tmpstr);
3308
3309 if (machine->use_x11)
3310 machine->main_console_handle = i;
3311 else
3312 machine->main_console_handle = j;
3313
3314 /* lpt at 0x80008000 */
3315
3316 device_add(machine, "fdc addr=0x8000c000, irq=0");
3317
3318 switch (machine->machine_subtype) {
3319 case MACHINE_ARC_NEC_RD94:
3320 case MACHINE_ARC_NEC_R94:
3321 /* PCI devices: (NOTE: bus must be 0, device must be 3, 4, or 5, for NetBSD to accept interrupts) */
3322 bus_pci_add(machine, pci_data, mem, 0, 3, 0, pci_dec21030_init, pci_dec21030_rr); /* tga graphics */
3323 break;
3324 case MACHINE_ARC_NEC_R96:
3325 dev_fb_init(machine, mem, 0x100e00000ULL,
3326 VFB_GENERIC, 640,480, 1024,480,
3327 8, "necvdfrb");
3328 break;
3329 }
3330 break;
3331
3332 case MACHINE_ARC_NEC_R98:
3333 /*
3334 * "NEC-R98" (NEC RISCserver 4200)
3335 *
3336 * According to http://mail-index.netbsd.org/port-arc/2004/02/01/0001.html:
3337 *
3338 * Network adapter at "start: 0x 0 18600000, length: 0x1000, level: 4, vector: 9"
3339 * Disk at "start: 0x 0 18c103f0, length: 0x1000, level: 5, vector: 6"
3340 * Keyboard at "start: 0x 0 18c20060, length: 0x1000, level: 5, vector: 3"
3341 * Serial at "start: 0x 0 18c103f8, length: 0x1000, level: 5, vector: 4"
3342 * Serial at "start: 0x 0 18c102f8, length: 0x1000, level: 5, vector: 4"
3343 * Parallel at "start: 0x 0 18c10278, length: 0x1000, level: 5, vector: 5"
3344 */
3345
3346 strlcat(machine->machine_name,
3347 " (NEC-R98; NEC RISCserver 4200)",
3348 MACHINE_NAME_MAXBUF);
3349
3350 /*
3351 * Windows NT access stuff at these addresses:
3352 *
3353 * 19980308, 18000210, 18c0a008,
3354 * 19022018, 19026010, andso on.
3355 */
3356 break;
3357
3358 case MACHINE_ARC_JAZZ_PICA:
3359 case MACHINE_ARC_JAZZ_MAGNUM:
3360 /*
3361 * "PICA-61"
3362 *
3363 * According to NetBSD 1.6.2:
3364 *
3365 * jazzio0 at mainbus0
3366 * timer0 at jazzio0 addr 0xe0000228
3367 * mcclock0 at jazzio0 addr 0xe0004000: mc146818 or compatible
3368 * lpt at jazzio0 addr 0xe0008000 intr 0 not configured
3369 * fdc at jazzio0 addr 0xe0003000 intr 1 not configured
3370 * MAGNUM at jazzio0 addr 0xe000c000 intr 2 not configured
3371 * ALI_S3 at jazzio0 addr 0xe0800000 intr 3 not configured
3372 * sn0 at jazzio0 addr 0xe0001000 intr 4: SONIC Ethernet
3373 * sn0: Ethernet address 69:6a:6b:6c:00:00
3374 * asc0 at jazzio0 addr 0xe0002000 intr 5: NCR53C94, target 0
3375 * pckbd at jazzio0 addr 0xe0005000 intr 6 not configured
3376 * pms at jazzio0 addr 0xe0005000 intr 7 not configured
3377 * com0 at jazzio0 addr 0xe0006000 intr 8: ns16550a, working fifo
3378 * com at jazzio0 addr 0xe0007000 intr 9 not configured
3379 * jazzisabr0 at mainbus0
3380 * isa0 at jazzisabr0 isa_io_base 0xe2000000 isa_mem_base 0xe3000000
3381 *
3382 * "Microsoft-Jazz", "MIPS Magnum"
3383 *
3384 * timer0 at jazzio0 addr 0xe0000228
3385 * mcclock0 at jazzio0 addr 0xe0004000: mc146818 or compatible
3386 * lpt at jazzio0 addr 0xe0008000 intr 0 not configured
3387 * fdc at jazzio0 addr 0xe0003000 intr 1 not configured
3388 * MAGNUM at jazzio0 addr 0xe000c000 intr 2 not configured
3389 * VXL at jazzio0 addr 0xe0800000 intr 3 not configured
3390 * sn0 at jazzio0 addr 0xe0001000 intr 4: SONIC Ethernet
3391 * sn0: Ethernet address 69:6a:6b:6c:00:00
3392 * asc0 at jazzio0 addr 0xe0002000 intr 5: NCR53C94, target 0
3393 * scsibus0 at asc0: 8 targets, 8 luns per target
3394 * pckbd at jazzio0 addr 0xe0005000 intr 6 not configured
3395 * pms at jazzio0 addr 0xe0005000 intr 7 not configured
3396 * com0 at jazzio0 addr 0xe0006000 intr 8: ns16550a, working fifo
3397 * com at jazzio0 addr 0xe0007000 intr 9 not configured
3398 * jazzisabr0 at mainbus0
3399 * isa0 at jazzisabr0 isa_io_base 0xe2000000 isa_mem_base 0xe3000000
3400 */
3401
3402 switch (machine->machine_subtype) {
3403 case MACHINE_ARC_JAZZ_PICA:
3404 strlcat(machine->machine_name, " (Microsoft Jazz, Acer PICA-61)",
3405 MACHINE_NAME_MAXBUF);
3406 break;
3407 case MACHINE_ARC_JAZZ_MAGNUM:
3408 strlcat(machine->machine_name, " (Microsoft Jazz, MIPS Magnum)",
3409 MACHINE_NAME_MAXBUF);
3410 break;
3411 default:
3412 fatal("error in machine.c. jazz\n");
3413 exit(1);
3414 }
3415
3416 machine->md_int.jazz_data = device_add(machine,
3417 "jazz addr=0x80000000");
3418 machine->md_interrupt = jazz_interrupt;
3419
3420 i = dev_pckbc_init(machine, mem, 0x80005000ULL,
3421 PCKBC_JAZZ, 8 + 6, 8 + 7, machine->use_x11, 0);
3422
3423 snprintf(tmpstr, sizeof(tmpstr), "ns16550 irq=16 addr=0x80006000 in_use=%i name2=tty0", machine->use_x11? 0 : 1);
3424 j = (size_t)device_add(machine, tmpstr);
3425 snprintf(tmpstr, sizeof(tmpstr), "ns16550 irq=17 addr=0x80007000 in_use=%i name2=tty1", 0);
3426 device_add(machine, tmpstr);
3427
3428 if (machine->use_x11)
3429 machine->main_console_handle = i;
3430 else
3431 machine->main_console_handle = j;
3432
3433 switch (machine->machine_subtype) {
3434 case MACHINE_ARC_JAZZ_PICA:
3435 if (machine->use_x11) {
3436 dev_vga_init(machine, mem,
3437 0x400a0000ULL, 0x600003c0ULL,
3438 machine->machine_name);
3439 arcbios_console_init(machine,
3440 0x400b8000ULL, 0x600003c0ULL);
3441 }
3442 break;
3443 case MACHINE_ARC_JAZZ_MAGNUM:
3444 /* PROM mirror? */
3445 dev_ram_init(machine, 0xfff00000, 0x100000,
3446 DEV_RAM_MIRROR | DEV_RAM_MIGHT_POINT_TO_DEVICES, 0x1fc00000);
3447
3448 /* VXL. TODO */
3449 /* control at 0x60100000? */
3450 dev_fb_init(machine, mem, 0x60200000ULL,
3451 VFB_GENERIC, 1024,768, 1024,768,
3452 8, "VXL");
3453 break;
3454 }
3455
3456 /* irq 8 + 4 */
3457 device_add(machine, "sn addr=0x80001000 irq=12");
3458
3459 dev_asc_init(machine, mem,
3460 0x80002000ULL, 8 + 5, NULL, DEV_ASC_PICA,
3461 dev_jazz_dma_controller,
3462 machine->md_int.jazz_data);
3463
3464 device_add(machine, "fdc addr=0x80003000, irq=0");
3465
3466 dev_mc146818_init(machine, mem,
3467 0x80004000ULL, 2, MC146818_ARC_JAZZ, 1);
3468
3469 #if 0
3470 Not yet.
3471 /* irq = 8+16 + 14 */
3472 device_add(machine, "wdc addr=0x900001f0, irq=38");
3473 #endif
3474
3475 break;
3476
3477 case MACHINE_ARC_JAZZ_M700:
3478 /*
3479 * "Microsoft-Jazz", "Olivetti M700"
3480 *
3481 * Different enough from Pica and Magnum to be
3482 * separate here.
3483 *
3484 * See http://mail-index.netbsd.org/port-arc/2000/10/18/0001.html.
3485 */
3486
3487 strlcat(machine->machine_name, " (Microsoft Jazz, Olivetti M700)",
3488 MACHINE_NAME_MAXBUF);
3489
3490 machine->md_int.jazz_data = device_add(machine,
3491 "jazz addr=0x80000000");
3492 machine->md_interrupt = jazz_interrupt;
3493
3494 dev_mc146818_init(machine, mem,
3495 0x80004000ULL, 2, MC146818_ARC_JAZZ, 1);
3496
3497 i = 0; /* TODO: Yuck! */
3498 #if 0
3499 i = dev_pckbc_init(machine, mem, 0x80005000ULL,
3500 PCKBC_JAZZ, 8 + 6, 8 + 7, machine->use_x11, 0);
3501 #endif
3502
3503 snprintf(tmpstr, sizeof(tmpstr), "ns16550 irq=16 addr=0x80006000 in_use=%i name2=tty0", machine->use_x11? 0 : 1);
3504 j = (size_t)device_add(machine, tmpstr);
3505 snprintf(tmpstr, sizeof(tmpstr), "ns16550 irq=17 addr=0x80007000 in_use=%i name2=tty1", 0);
3506 device_add(machine, tmpstr);
3507
3508 if (machine->use_x11)
3509 machine->main_console_handle = i;
3510 else
3511 machine->main_console_handle = j;
3512
3513 dev_m700_fb_init(machine, mem,
3514 0x180080000ULL, 0x100000000ULL);
3515
3516 break;
3517
3518 case MACHINE_ARC_DESKTECH_TYNE:
3519 /*
3520 * "Deskstation Tyne" (?)
3521 *
3522 * TODO
3523 * http://mail-index.netbsd.org/port-arc/2000/10/14/0000.html
3524 */
3525
3526 strlcat(machine->machine_name, " (Deskstation Tyne)",
3527 MACHINE_NAME_MAXBUF);
3528
3529 snprintf(tmpstr, sizeof(tmpstr), "ns16550 irq=0 addr=0x9000003f8 in_use=%i name2=tty0", machine->use_x11? 0 : 1);
3530 i = (size_t)device_add(machine, tmpstr);
3531 device_add(machine, "ns16550 irq=0 addr=0x9000002f8 in_use=0 name2=tty1");
3532 device_add(machine, "ns16550 irq=0 addr=0x9000003e8 in_use=0 name2=tty2");
3533 device_add(machine, "ns16550 irq=0 addr=0x9000002e8 in_use=0 name2=tty3");
3534
3535 dev_mc146818_init(machine, mem,
3536 0x900000070ULL, 2, MC146818_PC_CMOS, 1);
3537
3538 #if 0
3539 /* TODO: irq, etc */
3540 device_add(machine, "wdc addr=0x9000001f0, irq=0");
3541 device_add(machine, "wdc addr=0x900000170, irq=0");
3542 #endif
3543 /* PC kbd */
3544 j = dev_pckbc_init(machine, mem, 0x900000060ULL,
3545 PCKBC_8042, 0, 0, machine->use_x11, 0);
3546
3547 if (machine->use_x11)
3548 machine->main_console_handle = j;
3549 else
3550 machine->main_console_handle = i;
3551
3552 if (machine->use_x11) {
3553 dev_vga_init(machine, mem, 0x1000a0000ULL,
3554 0x9000003c0ULL, machine->machine_name);
3555
3556 arcbios_console_init(machine,
3557 0x1000b8000ULL, 0x9000003c0ULL);
3558 }
3559 break;
3560
3561 default:
3562 fatal("Unimplemented ARC machine type %i\n",
3563 machine->machine_subtype);
3564 exit(1);
3565 }
3566 }
3567
3568 /*
3569 * This is important: :-)
3570 *
3571 * TODO: There should not be any use of ARCBIOS before this
3572 * point.
3573 */
3574
3575 if (machine->prom_emulation) {
3576 arcbios_init(machine, arc_wordlen == sizeof(uint64_t),
3577 sgi_ram_offset);
3578
3579 /*
3580 * TODO: How to build the component tree intermixed with
3581 * the rest of device initialization?
3582 */
3583
3584 /*
3585 * Boot string in ARC format:
3586 *
3587 * TODO: How about floppies? multi()disk()fdisk()
3588 * Is tftp() good for netbooting?
3589 */
3590 init_bootpath = malloc(500);
3591 if (init_bootpath == NULL) {
3592 fprintf(stderr, "out of mem, bootpath\n");
3593 exit(1);
3594 }
3595 init_bootpath[0] = '\0';
3596
3597 if (bootdev_id < 0 || machine->force_netboot) {
3598 snprintf(init_bootpath, 400, "tftp()");
3599 } else {
3600 /* TODO: Make this nicer. */
3601 if (machine->machine_type == MACHINE_SGI) {
3602 if (machine->machine_subtype == 30)
3603 strlcat(init_bootpath, "xio(0)pci(15)",
3604 MACHINE_NAME_MAXBUF);
3605 if (machine->machine_subtype == 32)
3606 strlcat(init_bootpath, "pci(0)",
3607 MACHINE_NAME_MAXBUF);
3608 }
3609
3610 if (diskimage_is_a_cdrom(machine, bootdev_id,
3611 bootdev_type))
3612 snprintf(init_bootpath + strlen(init_bootpath),
3613 400,"scsi(0)cdrom(%i)fdisk(0)", bootdev_id);
3614 else
3615 snprintf(init_bootpath + strlen(init_bootpath),
3616 400,"scsi(0)disk(%i)rdisk(0)partition(1)",
3617 bootdev_id);
3618 }
3619
3620 if (machine->machine_type == MACHINE_ARC)
3621 strlcat(init_bootpath, "\\", MACHINE_NAME_MAXBUF);
3622
3623 bootstr = malloc(BOOTSTR_BUFLEN);
3624 if (bootstr == NULL) {
3625 fprintf(stderr, "out of memory\n");
3626 exit(1);
3627 }
3628 strlcpy(bootstr, init_bootpath, BOOTSTR_BUFLEN);
3629 if (strlcat(bootstr, machine->boot_kernel_filename,
3630 BOOTSTR_BUFLEN) >= BOOTSTR_BUFLEN) {
3631 fprintf(stderr, "boot string too long?\n");
3632 exit(1);
3633 }
3634
3635 /* Boot args., eg "-a" */
3636 bootarg = machine->boot_string_argument;
3637
3638 /* argc, argv, envp in a0, a1, a2: */
3639 cpu->cd.mips.gpr[MIPS_GPR_A0] = 0; /* note: argc is increased later */
3640
3641 /* TODO: not needed? */
3642 cpu->cd.mips.gpr[MIPS_GPR_SP] = (int64_t)(int32_t)
3643 (machine->physical_ram_in_mb * 1048576 + 0x80000000 - 0x2080);
3644
3645 /* Set up argc/argv: */
3646 addr = ARC_ENV_STRINGS;
3647 addr2 = ARC_ARGV_START;
3648 cpu->cd.mips.gpr[MIPS_GPR_A1] = addr2;
3649
3650 /* bootstr: */
3651 store_pointer_and_advance(cpu, &addr2, addr, arc_wordlen==sizeof(uint64_t));
3652 add_environment_string(cpu, bootstr, &addr);
3653 cpu->cd.mips.gpr[MIPS_GPR_A0] ++;
3654
3655 /* bootarg: */
3656 if (bootarg[0] != '\0') {
3657 store_pointer_and_advance(cpu, &addr2, addr, arc_wordlen==sizeof(uint64_t));
3658 add_environment_string(cpu, bootarg, &addr);
3659 cpu->cd.mips.gpr[MIPS_GPR_A0] ++;
3660 }
3661
3662 cpu->cd.mips.gpr[MIPS_GPR_A2] = addr2;
3663
3664 /*
3665 * Add environment variables. For each variable, add it
3666 * as a string using add_environment_string(), and add a
3667 * pointer to it to the ARC_ENV_POINTERS array.
3668 */
3669 if (machine->use_x11) {
3670 if (machine->machine_type == MACHINE_ARC) {
3671 store_pointer_and_advance(cpu, &addr2, addr, arc_wordlen==sizeof(uint64_t));
3672 add_environment_string(cpu, "CONSOLEIN=multi()key()keyboard()console()", &addr);
3673 store_pointer_and_advance(cpu, &addr2, addr, arc_wordlen==sizeof(uint64_t));
3674 add_environment_string(cpu, "CONSOLEOUT=multi()video()monitor()console()", &addr);
3675 } else {
3676 store_pointer_and_advance(cpu, &addr2, addr, arc_wordlen==sizeof(uint64_t));
3677 add_environment_string(cpu, "ConsoleIn=keyboard()", &addr);
3678 store_pointer_and_advance(cpu, &addr2, addr, arc_wordlen==sizeof(uint64_t));
3679 add_environment_string(cpu, "ConsoleOut=video()", &addr);
3680
3681 /* g for graphical mode. G for graphical mode
3682 with SGI logo visible on Irix? */
3683 store_pointer_and_advance(cpu, &addr2, addr, arc_wordlen==sizeof(uint64_t));
3684 add_environment_string(cpu, "console=g", &addr);
3685 }
3686 } else {
3687 if (machine->machine_type == MACHINE_ARC) {
3688 /* TODO: serial console for ARC? */
3689 store_pointer_and_advance(cpu, &addr2, addr, arc_wordlen==sizeof(uint64_t));
3690 add_environment_string(cpu, "CONSOLEIN=multi()serial(0)", &addr);
3691 store_pointer_and_advance(cpu, &addr2, addr, arc_wordlen==sizeof(uint64_t));
3692 add_environment_string(cpu, "CONSOLEOUT=multi()serial(0)", &addr);
3693 } else {
3694 store_pointer_and_advance(cpu, &addr2, addr, arc_wordlen==sizeof(uint64_t));
3695 add_environment_string(cpu, "ConsoleIn=serial(0)", &addr);
3696 store_pointer_and_advance(cpu, &addr2, addr, arc_wordlen==sizeof(uint64_t));
3697 add_environment_string(cpu, "ConsoleOut=serial(0)", &addr);
3698
3699 /* 'd' or 'd2' in Irix, 'ttyS0' in Linux? */
3700 store_pointer_and_advance(cpu, &addr2, addr, arc_wordlen==sizeof(uint64_t));
3701 add_environment_string(cpu, "console=d", &addr); /* d2 = serial? */
3702 }
3703 }
3704
3705 if (machine->machine_type == MACHINE_SGI) {
3706 store_pointer_and_advance(cpu, &addr2, addr, arc_wordlen==sizeof(uint64_t));
3707 add_environment_string(cpu, "AutoLoad=No", &addr);
3708 store_pointer_and_advance(cpu, &addr2, addr, arc_wordlen==sizeof(uint64_t));
3709 add_environment_string(cpu, "diskless=0", &addr);
3710 store_pointer_and_advance(cpu, &addr2, addr, arc_wordlen==sizeof(uint64_t));
3711 add_environment_string(cpu, "volume=80", &addr);
3712 store_pointer_and_advance(cpu, &addr2, addr, arc_wordlen==sizeof(uint64_t));
3713 add_environment_string(cpu, "sgilogo=y", &addr);
3714
3715 store_pointer_and_advance(cpu, &addr2, addr, arc_wordlen==sizeof(uint64_t));
3716 add_environment_string(cpu, "monitor=h", &addr);
3717 store_pointer_and_advance(cpu, &addr2, addr, arc_wordlen==sizeof(uint64_t));
3718 add_environment_string(cpu, "TimeZone=GMT", &addr);
3719 store_pointer_and_advance(cpu, &addr2, addr, arc_wordlen==sizeof(uint64_t));
3720 add_environment_string(cpu, "nogfxkbd=1", &addr);
3721
3722 /* TODO: 'xio(0)pci(15)scsi(0)disk(1)rdisk(0)partition(0)' on IP30 at least */
3723
3724 store_pointer_and_advance(cpu, &addr2, addr, arc_wordlen==sizeof(uint64_t));
3725 add_environment_string(cpu, "SystemPartition=pci(0)scsi(0)disk(2)rdisk(0)partition(8)", &addr);
3726 store_pointer_and_advance(cpu, &addr2, addr, arc_wordlen==sizeof(uint64_t));
3727 add_environment_string(cpu, "OSLoadPartition=pci(0)scsi(0)disk(2)rdisk(0)partition(0)", &addr);
3728 store_pointer_and_advance(cpu, &addr2, addr, arc_wordlen==sizeof(uint64_t));
3729 add_environment_string(cpu, "OSLoadFilename=/unix", &addr);
3730 store_pointer_and_advance(cpu, &addr2, addr, arc_wordlen==sizeof(uint64_t));
3731 add_environment_string(cpu, "OSLoader=sash", &addr);
3732
3733 store_pointer_and_advance(cpu, &addr2, addr, arc_wordlen==sizeof(uint64_t));
3734 add_environment_string(cpu, "rbaud=9600", &addr);
3735 store_pointer_and_advance(cpu, &addr2, addr, arc_wordlen==sizeof(uint64_t));
3736 add_environment_string(cpu, "rebound=y", &addr);
3737 store_pointer_and_advance(cpu, &addr2, addr, arc_wordlen==sizeof(uint64_t));
3738 add_environment_string(cpu, "crt_option=1", &addr);
3739 store_pointer_and_advance(cpu, &addr2, addr, arc_wordlen==sizeof(uint64_t));
3740 add_environment_string(cpu, "netaddr=10.0.0.1", &addr);
3741
3742 store_pointer_and_advance(cpu, &addr2, addr, arc_wordlen==sizeof(uint64_t));
3743 add_environment_string(cpu, "keybd=US", &addr);
3744
3745 store_pointer_and_advance(cpu, &addr2, addr, arc_wordlen==sizeof(uint64_t));
3746 add_environment_string(cpu, "cpufreq=3", &addr);
3747 store_pointer_and_advance(cpu, &addr2, addr, arc_wordlen==sizeof(uint64_t));
3748 add_environment_string(cpu, "dbaud=9600", &addr);
3749 store_pointer_and_advance(cpu, &addr2, addr, arc_wordlen==sizeof(uint64_t));
3750 add_environment_string(cpu, eaddr_string, &addr);
3751 store_pointer_and_advance(cpu, &addr2, addr, arc_wordlen==sizeof(uint64_t));
3752 add_environment_string(cpu, "verbose=istrue", &addr);
3753 store_pointer_and_advance(cpu, &addr2, addr, arc_wordlen==sizeof(uint64_t));
3754 add_environment_string(cpu, "showconfig=istrue", &addr);
3755 store_pointer_and_advance(cpu, &addr2, addr, arc_wordlen==sizeof(uint64_t));
3756 add_environment_string(cpu, "diagmode=v", &addr);
3757 store_pointer_and_advance(cpu, &addr2, addr, arc_wordlen==sizeof(uint64_t));
3758 add_environment_string(cpu, "kernname=unix", &addr);
3759 } else {
3760 char *tmp;
3761 size_t mlen = strlen(bootarg) + strlen("OSLOADOPTIONS=") + 2;
3762 tmp = malloc(mlen);
3763 snprintf(tmp, mlen, "OSLOADOPTIONS=%s", bootarg);
3764 store_pointer_and_advance(cpu, &addr2, addr, arc_wordlen==sizeof(uint64_t));
3765 add_environment_string(cpu, tmp, &addr);
3766
3767 store_pointer_and_advance(cpu, &addr2, addr, arc_wordlen==sizeof(uint64_t));
3768 add_environment_string(cpu, "OSLOADPARTITION=scsi(0)cdrom(6)fdisk(0);scsi(0)disk(0)rdisk(0)partition(1)", &addr);
3769
3770 store_pointer_and_advance(cpu, &addr2, addr, arc_wordlen==sizeof(uint64_t));
3771 add_environment_string(cpu, "SYSTEMPARTITION=scsi(0)cdrom(6)fdisk(0);scsi(0)disk(0)rdisk(0)partition(1)", &addr);
3772 }
3773
3774 /* End the environment strings with an empty zero-terminated
3775 string, and the envp array with a NULL pointer. */
3776 add_environment_string(cpu, "", &addr); /* the end */
3777 store_pointer_and_advance(cpu, &addr2,
3778 0, arc_wordlen==sizeof(uint64_t));
3779
3780 /* Return address: (0x20 = ReturnFromMain()) */
3781 cpu->cd.mips.gpr[MIPS_GPR_RA] = ARC_FIRMWARE_ENTRIES + 0x20;
3782 }
3783
3784 break;
3785
3786 case MACHINE_MESHCUBE:
3787 machine->machine_name = "MeshCube";
3788
3789 if (machine->physical_ram_in_mb != 64)
3790 fprintf(stderr, "WARNING! MeshCubes are supposed to have exactly 64 MB RAM. Continuing anyway.\n");
3791 if (machine->use_x11)
3792 fprintf(stderr, "WARNING! MeshCube with -X is meaningless. Continuing anyway.\n");
3793
3794 /* First of all, the MeshCube has an Au1500 in it: */
3795 machine->md_interrupt = au1x00_interrupt;
3796 machine->md_int.au1x00_ic_data = dev_au1x00_init(machine, mem);
3797
3798 /*
3799 * TODO: Which non-Au1500 devices, and at what addresses?
3800 *
3801 * "4G Systems MTX-1 Board" at ?
3802 * 1017fffc, 14005004, 11700000, 11700008, 11900014,
3803 * 1190002c, 11900100, 11900108, 1190010c,
3804 * 10400040 - 10400074,
3805 * 14001000 (possibly LCD?)
3806 * 11100028 (possibly ttySx?)
3807 *
3808 * "usb_ohci=base:0x10100000,len:0x100000,irq:26"
3809 */
3810
3811 device_add(machine, "random addr=0x1017fffc len=4");
3812
3813 if (machine->prom_emulation) {
3814 /*
3815 * TODO: A Linux kernel wants "memsize" from somewhere... I
3816 * haven't found any docs on how it is used though.
3817 */
3818 cpu->cd.mips.gpr[MIPS_GPR_A0] = 1;
3819 cpu->cd.mips.gpr[MIPS_GPR_A1] = 0xa0001000ULL;
3820 store_32bit_word(cpu, cpu->cd.mips.gpr[MIPS_GPR_A1],
3821 0xa0002000ULL);
3822 store_string(cpu, 0xa0002000ULL, "something=somethingelse");
3823
3824 cpu->cd.mips.gpr[MIPS_GPR_A2] = 0xa0003000ULL;
3825 store_string(cpu, 0xa0002000ULL, "hello=world\n");
3826 }
3827 break;
3828
3829 case MACHINE_NETGEAR:
3830 machine->machine_name = "NetGear WG602v1";
3831
3832 if (machine->use_x11)
3833 fprintf(stderr, "WARNING! NetGear with -X is meaningless. Continuing anyway.\n");
3834 if (machine->physical_ram_in_mb != 16)
3835 fprintf(stderr, "WARNING! Real NetGear WG602v1 boxes have exactly 16 MB RAM. Continuing anyway.\n");
3836
3837 /*
3838 * Lots of info about the IDT 79RC 32334
3839 * http://www.idt.com/products/pages/Integrated_Processors-79RC32334.html
3840 */
3841 device_add(machine, "8250 addr=0x18000800 addr_mult=4 irq=0");
3842 break;
3843
3844 case MACHINE_SONYNEWS:
3845 /*
3846 * There are several models, according to
3847 * http://www.netbsd.org/Ports/newsmips/:
3848 *
3849 * "R3000 and hyper-bus based models"
3850 * NWS-3470D, -3410, -3460, -3710, -3720
3851 *
3852 * "R4000/4400 and apbus based models"
3853 * NWS-5000
3854 *
3855 * For example: (found using google)
3856 *
3857 * cpu_model = news3700
3858 * SONY NET WORK STATION, Model NWS-3710, Machine ID #30145
3859 * cpu0: MIPS R3000 (0x220) Rev. 2.0 with MIPS R3010 Rev.2.0
3860 * 64KB/4B direct-mapped I, 64KB/4B direct-mapped w-thr. D
3861 *
3862 * See http://katsu.watanabe.name/doc/sonynews/model.html
3863 * for more details.
3864 */
3865 cpu->byte_order = EMUL_BIG_ENDIAN;
3866 machine->machine_name = "Sony NeWS (NET WORK STATION)";
3867
3868 if (machine->prom_emulation) {
3869 /* This is just a test. TODO */
3870 int i;
3871 for (i=0; i<32; i++)
3872 cpu->cd.mips.gpr[i] =
3873 0x01230000 + (i << 8) + 0x55;
3874 }
3875
3876 machine->main_console_handle =
3877 dev_zs_init(machine, mem, 0x1e950000, 0, 1, "zs console");
3878
3879 break;
3880
3881 case MACHINE_EVBMIPS:
3882 /* http://www.netbsd.org/Ports/evbmips/ */
3883 cpu->byte_order = EMUL_LITTLE_ENDIAN;
3884
3885 switch (machine->machine_subtype) {
3886 case MACHINE_EVBMIPS_MALTA:
3887 case MACHINE_EVBMIPS_MALTA_BE:
3888 machine->machine_name = "MALTA (evbmips, little endian)";
3889 cpu->byte_order = EMUL_LITTLE_ENDIAN;
3890
3891 if (machine->machine_subtype == MACHINE_EVBMIPS_MALTA_BE) {
3892 machine->machine_name = "MALTA (evbmips, big endian)";
3893 cpu->byte_order = EMUL_BIG_ENDIAN;
3894 }
3895
3896 /* ISA interrupt controllers: */
3897 snprintf(tmpstr, sizeof(tmpstr), "8259 irq=24 addr=0x18000020");
3898 machine->isa_pic_data.pic1 = device_add(machine, tmpstr);
3899 snprintf(tmpstr, sizeof(tmpstr), "8259 irq=24 addr=0x180000a0");
3900 machine->isa_pic_data.pic2 = device_add(machine, tmpstr);
3901 machine->md_interrupt = malta_interrupt;
3902
3903 dev_mc146818_init(machine, mem, 0x18000070, 8 + 8, MC146818_PC_CMOS, 1);
3904
3905 machine->main_console_handle = (size_t)
3906 device_add(machine, "ns16550 irq=12 addr=0x180003f8 name2=tty0");
3907 device_add(machine, "ns16550 irq=11 addr=0x180002f8 name2=tty1");
3908
3909 snprintf(tmpstr, sizeof(tmpstr), "ns16550 irq=4 addr=0x%x name2=tty2", MALTA_CBUSUART);
3910 device_add(machine, tmpstr);
3911 /* TODO: Irqs */
3912 pci_data = dev_gt_init(machine, mem, 0x1be00000, 8+9, 8+9, 120);
3913
3914 /* TODO: Haha, this is bogus. Just a cut&paste
3915 from the Cobalt emulation above. */
3916 bus_pci_add(machine, pci_data, mem, 0, 9, 0, pci_vt82c586_isa_init, pci_vt82c586_isa_rr);
3917 bus_pci_add(machine, pci_data, mem, 0, 9, 1, pci_vt82c586_ide_init, pci_vt82c586_ide_rr);
3918
3919 device_add(machine, "malta_lcd addr=0x1f000400");
3920 break;
3921 case MACHINE_EVBMIPS_PB1000:
3922 machine->machine_name = "PB1000 (evbmips)";
3923 cpu->byte_order = EMUL_BIG_ENDIAN;
3924
3925 machine->md_interrupt = au1x00_interrupt;
3926 machine->md_int.au1x00_ic_data = dev_au1x00_init(machine, mem);
3927 /* TODO */
3928 break;
3929 default:
3930 fatal("Unimplemented EVBMIPS model.\n");
3931 exit(1);
3932 }
3933
3934 if (machine->prom_emulation) {
3935 /* This is just a test. TODO */
3936 for (i=0; i<32; i++)
3937 cpu->cd.mips.gpr[i] =
3938 0x01230000 + (i << 8) + 0x55;
3939
3940 /* NetBSD/evbmips wants these: (at least for Malta) */
3941
3942 /* a0 = argc */
3943 cpu->cd.mips.gpr[MIPS_GPR_A0] = 2;
3944
3945 /* a1 = argv */
3946 cpu->cd.mips.gpr[MIPS_GPR_A1] = (int32_t)0x9fc01000;
3947 store_32bit_word(cpu, (int32_t)0x9fc01000, 0x9fc01040);
3948 store_32bit_word(cpu, (int32_t)0x9fc01004, 0x9fc01200);
3949 store_32bit_word(cpu, (int32_t)0x9fc01008, 0);
3950
3951 bootstr = strdup(machine->boot_kernel_filename);
3952 bootarg = strdup(machine->boot_string_argument);
3953 store_string(cpu, (int32_t)0x9fc01040, bootstr);
3954 store_string(cpu, (int32_t)0x9fc01200, bootarg);
3955
3956 /* a2 = (yamon_env_var *)envp */
3957 cpu->cd.mips.gpr[MIPS_GPR_A2] = (int32_t)0x9fc01800;
3958 {
3959 uint64_t env = cpu->cd.mips.gpr[MIPS_GPR_A2];
3960 uint64_t tmpptr = 0xffffffff9fc01c00ULL;
3961 char tmps[50];
3962
3963 snprintf(tmps, sizeof(tmps), "0x%08x",
3964 machine->physical_ram_in_mb * 1048576);
3965 add_environment_string_dual(cpu,
3966 &env, &tmpptr, "memsize", tmps);
3967
3968 add_environment_string_dual(cpu,
3969 &env, &tmpptr, "yamonrev", "02.06");
3970
3971 /* End of env: */
3972 tmpptr = 0;
3973 add_environment_string_dual(cpu,
3974 &env, &tmpptr, NULL, NULL);
3975 }
3976
3977 /* a3 = memsize */
3978 cpu->cd.mips.gpr[MIPS_GPR_A3] =
3979 machine->physical_ram_in_mb * 1048576;
3980 /* Hm. Linux ignores a3. */
3981
3982 /*
3983 * TODO:
3984 * Core ID numbers.
3985 * How much of this is not valid for PBxxxx?
3986 *
3987 * See maltareg.h for more info.
3988 */
3989 store_32bit_word(cpu, (int32_t)(0x80000000 + MALTA_REVISION), (1 << 10) + 0x26);
3990
3991 /* Call vectors at 0x9fc005xx: */
3992 for (i=0; i<0x100; i+=4)
3993 store_32bit_word(cpu, (int64_t)(int32_t)0x9fc00500 + i,
3994 (int64_t)(int32_t)0x9fc00800 + i);
3995 }
3996 break;
3997
3998 case MACHINE_PSP:
3999 /*
4000 * The Playstation Portable seems to be a strange beast.
4001 *
4002 * http://yun.cup.com/psppg004.html (in Japanese) seems to
4003 * suggest that virtual addresses are not displaced by
4004 * 0x80000000 as on normal CPUs, but by 0x40000000?
4005 */
4006 machine->machine_name = "Playstation Portable";
4007 cpu->byte_order = EMUL_LITTLE_ENDIAN;
4008
4009 if (!machine->use_x11 && !quiet_mode)
4010 fprintf(stderr, "-------------------------------------"
4011 "------------------------------------------\n"
4012 "\n WARNING! You are emulating a PSP without -X. "
4013 "You will miss graphical output!\n\n"
4014 "-------------------------------------"
4015 "------------------------------------------\n");
4016
4017 /* 480 x 272 pixels framebuffer (512 bytes per line) */
4018 fb = dev_fb_init(machine, mem, 0x04000000, VFB_HPC,
4019 480,272, 512,1088, -15, "Playstation Portable");
4020
4021 /*
4022 * TODO/NOTE: This is ugly, but necessary since GXemul doesn't
4023 * emulate any MIPS CPU without MMU right now.
4024 */
4025 mips_coproc_tlb_set_entry(cpu, 0, 1048576*16,
4026 0x44000000 /*vaddr*/, 0x4000000, 0x4000000 + 1048576*16,
4027 1,1,1,1,1, 0, 2, 2);
4028 mips_coproc_tlb_set_entry(cpu, 1, 1048576*16,
4029 0x8000000 /*vaddr*/, 0x0, 0x0 + 1048576*16,
4030 1,1,1,1,1, 0, 2, 2);
4031 mips_coproc_tlb_set_entry(cpu, 2, 1048576*16,
4032 0x9000000 /*vaddr*/, 0x01000000, 0x01000000 + 1048576*16,
4033 1,1,1,1,1, 0, 2, 2);
4034 mips_coproc_tlb_set_entry(cpu, 3, 1048576*16,
4035 0x0 /*vaddr*/, 0, 0 + 1048576*16, 1,1,1,1,1, 0, 2, 2);
4036
4037 cpu->cd.mips.gpr[MIPS_GPR_SP] = 0xfff0;
4038
4039 break;
4040 #endif /* ENABLE_MIPS */
4041
4042 #ifdef ENABLE_PPC
4043 case MACHINE_BAREPPC:
4044 /*
4045 * A "bare" PPC machine.
4046 *
4047 * NOTE: NO devices at all.
4048 */
4049 machine->machine_name = "\"Bare\" PPC machine";
4050 break;
4051
4052 case MACHINE_TESTPPC:
4053 /*
4054 * A PPC test machine, similar to the test machine for MIPS.
4055 */
4056 machine->machine_name = "PPC test machine";
4057
4058 /* TODO: interrupt for PPC? */
4059 snprintf(tmpstr, sizeof(tmpstr), "cons addr=0x%llx irq=0",
4060 (long long)DEV_CONS_ADDRESS);
4061 cons_data = device_add(machine, tmpstr);
4062 machine->main_console_handle = cons_data->console_handle;
4063
4064 snprintf(tmpstr, sizeof(tmpstr), "mp addr=0x%llx",
4065 (long long)DEV_MP_ADDRESS);
4066 device_add(machine, tmpstr);
4067
4068 fb = dev_fb_init(machine, mem, DEV_FB_ADDRESS, VFB_GENERIC,
4069 640,480, 640,480, 24, "testppc generic");
4070
4071 snprintf(tmpstr, sizeof(tmpstr), "disk addr=0x%llx",
4072 (long long)DEV_DISK_ADDRESS);
4073 device_add(machine, tmpstr);
4074
4075 snprintf(tmpstr, sizeof(tmpstr), "ether addr=0x%llx irq=0",
4076 (long long)DEV_ETHER_ADDRESS);
4077 device_add(machine, tmpstr);
4078
4079 break;
4080
4081 case MACHINE_WALNUT:
4082 /*
4083 * NetBSD/evbppc (http://www.netbsd.org/Ports/evbppc/)
4084 */
4085 machine->machine_name = "Walnut evaluation board";
4086
4087 break;
4088
4089 case MACHINE_PMPPC:
4090 /*
4091 * NetBSD/pmppc (http://www.netbsd.org/Ports/pmppc/)
4092 */
4093 machine->machine_name = "Artesyn's PM/PPC board";
4094
4095 dev_pmppc_init(mem);
4096
4097 /* com0 = 0xff600300, com1 = 0xff600400 */
4098
4099 machine->main_console_handle = (size_t)device_add(machine, "ns16550 irq=0 addr=0xff600300 name2=tty0");
4100 device_add(machine, "ns16550 irq=0 addr=0xff600400 in_use=0 name2=tty1");
4101
4102 break;
4103
4104 case MACHINE_SANDPOINT:
4105 /*
4106 * NetBSD/sandpoint (http://www.netbsd.org/Ports/sandpoint/)
4107 */
4108 machine->machine_name = "Motorola Sandpoint";
4109
4110 {
4111 int i;
4112 for (i=0; i<32; i++)
4113 cpu->cd.ppc.gpr[i] =
4114 0x12340000 + (i << 8) + 0x55;
4115 }
4116
4117 break;
4118
4119 case MACHINE_BEBOX:
4120 /*
4121 * NetBSD/bebox (http://www.netbsd.org/Ports/bebox/)
4122 */
4123 machine->machine_name = "BeBox";
4124
4125 device_add(machine, "bebox");
4126
4127 machine->main_console_handle = (size_t)
4128 device_add(machine, "ns16550 irq=0 addr=0x800003f8 name2=tty0");
4129 device_add(machine, "ns16550 irq=0 addr=0x800002f8 name2=tty1 in_use=0");
4130
4131 dev_pckbc_init(machine, mem, 0x80000060, PCKBC_8042,
4132 1, 12, machine->use_x11, 1);
4133
4134 if (machine->use_x11)
4135 dev_vga_init(machine, mem, 0xc00a0000ULL, 0x800003c0ULL,
4136 machine->machine_name);
4137
4138 if (machine->prom_emulation) {
4139 store_32bit_word(cpu, 0x3010, machine->physical_ram_in_mb * 1048576);
4140
4141 /* TODO: List of stuff, see http://www.beatjapan.org/
4142 mirror/www.be.com/aboutbe/benewsletter/
4143 Issue27.html#Cookbook for the details. */
4144 store_32bit_word(cpu, 0x301c, 0);
4145
4146 /* NetBSD/bebox: r3 = startkernel, r4 = endkernel,
4147 r5 = args, r6 = ptr to bootinfo? */
4148 cpu->cd.ppc.gpr[3] = 0x3100;
4149 cpu->cd.ppc.gpr[4] = 0x200000;
4150 cpu->cd.ppc.gpr[5] = 0x2000;
4151 store_string(cpu, cpu->cd.ppc.gpr[5], "-a");
4152 cpu->cd.ppc.gpr[6] = machine->physical_ram_in_mb * 1048576 - 0x100;
4153
4154 /* See NetBSD's bebox/include/bootinfo.h for details */
4155 store_32bit_word(cpu, cpu->cd.ppc.gpr[6] + 0, 12); /* next */
4156 store_32bit_word(cpu, cpu->cd.ppc.gpr[6] + 4, 0); /* mem */
4157 store_32bit_word(cpu, cpu->cd.ppc.gpr[6] + 8,
4158 machine->physical_ram_in_mb * 1048576);
4159
4160 store_32bit_word(cpu, cpu->cd.ppc.gpr[6] + 12, 20); /* next */
4161 store_32bit_word(cpu, cpu->cd.ppc.gpr[6] + 16, 1); /* console */
4162 store_buf(cpu, cpu->cd.ppc.gpr[6] + 20,
4163 machine->use_x11? "vga" : "com", 4);
4164 store_32bit_word(cpu, cpu->cd.ppc.gpr[6] + 24, 0x3f8);/* addr */
4165 store_32bit_word(cpu, cpu->cd.ppc.gpr[6] + 28, 9600);/* speed */
4166
4167 store_32bit_word(cpu, cpu->cd.ppc.gpr[6] + 32, 0); /* next */
4168 store_32bit_word(cpu, cpu->cd.ppc.gpr[6] + 36, 2); /* clock */
4169 store_32bit_word(cpu, cpu->cd.ppc.gpr[6] + 40, 100);
4170 }
4171 break;
4172
4173 case MACHINE_PREP:
4174 /*
4175 * NetBSD/prep (http://www.netbsd.org/Ports/prep/)
4176 */
4177 machine->machine_name = "PowerPC Reference Platform";
4178
4179 if (machine->prom_emulation) {
4180 /* Linux on PReP has 0xdeadc0de at address 0? (See
4181 http://joshua.raleigh.nc.us/docs/linux-2.4.10_html/113568.html) */
4182 store_32bit_word(cpu, 0, 0xdeadc0de);
4183
4184 /* r6 should point to "residual data"? */
4185 cpu->cd.ppc.gpr[6] = machine->physical_ram_in_mb * 1048576 - 0x1000;
4186 }
4187 break;
4188
4189 case MACHINE_MACPPC:
4190 /*
4191 * NetBSD/macppc (http://www.netbsd.org/Ports/macppc/)
4192 * OpenBSD/macppc (http://www.openbsd.org/macppc.html)
4193 */
4194 machine->machine_name = "Macintosh (PPC)";
4195
4196 if (machine->prom_emulation) {
4197 uint64_t b = 8 * 1048576, a = b - 0x800;
4198 int i;
4199 /*
4200 * r3 = pointer to boot_args (for the Mach kernel).
4201 * See http://darwinsource.opendarwin.org/10.3/
4202 * BootX-59/bootx.tproj/include.subproj/boot_args.h
4203 * for more info.
4204 */
4205 cpu->cd.ppc.gpr[3] = a;
4206 store_16bit_word(cpu, a + 0x0000, 1); /* revision */
4207 store_16bit_word(cpu, a + 0x0002, 2); /* version */
4208 store_buf(cpu, a + 0x0004, machine->boot_string_argument, 256);
4209 /* 26 dram banks; "long base; long size" */
4210 store_32bit_word(cpu, a + 0x0104, 0); /* base */
4211 store_32bit_word(cpu, a + 0x0108, machine->physical_ram_in_mb
4212 * 256); /* size (in pages) */
4213 for (i=8; i<26*8; i+= 4)
4214 store_32bit_word(cpu, a + 0x0104 + i, 0);
4215 a += (0x104 + 26 * 8);
4216 /* Video info: */
4217 store_32bit_word(cpu, a+0, 0xd0000000); /* video base */
4218 store_32bit_word(cpu, a+4, 0); /* display code (?) */
4219 store_32bit_word(cpu, a+8, 800); /* bytes per pixel row */
4220 store_32bit_word(cpu, a+12, 800); /* width */
4221 store_32bit_word(cpu, a+16, 600); /* height */
4222 store_32bit_word(cpu, a+20, 8); /* pixel depth */
4223 a += 24;
4224 store_32bit_word(cpu, a+0, 127); /* gestalt number (TODO) */
4225 store_32bit_word(cpu, a+4, 0); /* device tree pointer (TODO) */
4226 store_32bit_word(cpu, a+8, 0); /* device tree length */
4227 store_32bit_word(cpu, a+12, b); /* last address of kernel data area */
4228
4229 /* r4 = "MOSX" (0x4D4F5358) */
4230 cpu->cd.ppc.gpr[4] = 0x4D4F5358;
4231
4232 /*
4233 * r5 = OpenFirmware entry point. NOTE: See
4234 * cpu_ppc.c for the rest of this semi-ugly hack.
4235 */
4236 dev_ram_init(machine, cpu->cd.ppc.of_emul_addr,
4237 0x1000, DEV_RAM_RAM, 0x0);
4238 store_32bit_word(cpu, cpu->cd.ppc.of_emul_addr,
4239 0x44ee0002);
4240 cpu->cd.ppc.gpr[5] = cpu->cd.ppc.of_emul_addr;
4241 }
4242 break;
4243
4244 case MACHINE_DB64360:
4245 /* For playing with PMON2000 for PPC: */
4246 machine->machine_name = "DB64360";
4247
4248 machine->main_console_handle = (size_t)device_add(machine,
4249 "ns16550 irq=0 addr=0x1d000020 addr_mult=4");
4250
4251 if (machine->prom_emulation) {
4252 int i;
4253 for (i=0; i<32; i++)
4254 cpu->cd.ppc.gpr[i] =
4255 0x12340000 + (i << 8) + 0x55;
4256 }
4257
4258 break;
4259 #endif /* ENABLE_PPC */
4260
4261 #ifdef ENABLE_SH
4262 case MACHINE_BARESH:
4263 /* A bare SH machine, with no devices. */
4264 machine->machine_name = "\"Bare\" SH machine";
4265 break;
4266
4267 case MACHINE_TESTSH:
4268 machine->machine_name = "SH test machine";
4269
4270 snprintf(tmpstr, sizeof(tmpstr), "cons addr=0x%llx irq=0",
4271 (long long)DEV_CONS_ADDRESS);
4272 cons_data = device_add(machine, tmpstr);
4273 machine->main_console_handle = cons_data->console_handle;
4274
4275 snprintf(tmpstr, sizeof(tmpstr), "mp addr=0x%llx",
4276 (long long)DEV_MP_ADDRESS);
4277 device_add(machine, tmpstr);
4278
4279 fb = dev_fb_init(machine, mem, DEV_FB_ADDRESS, VFB_GENERIC,
4280 640,480, 640,480, 24, "testsh generic");
4281
4282 snprintf(tmpstr, sizeof(tmpstr), "disk addr=0x%llx",
4283 (long long)DEV_DISK_ADDRESS);
4284 device_add(machine, tmpstr);
4285
4286 snprintf(tmpstr, sizeof(tmpstr), "ether addr=0x%llx irq=0",
4287 (long long)DEV_ETHER_ADDRESS);
4288 device_add(machine, tmpstr);
4289
4290 break;
4291
4292 case MACHINE_HPCSH:
4293 /* Handheld SH-based machines: */
4294 machine->machine_name = "HPCsh";
4295
4296 /* TODO */
4297
4298 break;
4299 #endif /* ENABLE_SH */
4300
4301 #ifdef ENABLE_HPPA
4302 case MACHINE_BAREHPPA:
4303 /* A bare HPPA machine, with no devices. */
4304 machine->machine_name = "\"Bare\" HPPA machine";
4305 break;
4306
4307 case MACHINE_TESTHPPA:
4308 machine->machine_name = "HPPA test machine";
4309
4310 snprintf(tmpstr, sizeof(tmpstr), "cons addr=0x%llx irq=0",
4311 (long long)DEV_CONS_ADDRESS);
4312 cons_data = device_add(machine, tmpstr);
4313 machine->main_console_handle = cons_data->console_handle;
4314
4315 snprintf(tmpstr, sizeof(tmpstr), "mp addr=0x%llx",
4316 (long long)DEV_MP_ADDRESS);
4317 device_add(machine, tmpstr);
4318
4319 fb = dev_fb_init(machine, mem, DEV_FB_ADDRESS, VFB_GENERIC,
4320 640,480, 640,480, 24, "testhppa generic");
4321
4322 snprintf(tmpstr, sizeof(tmpstr), "disk addr=0x%llx",
4323 (long long)DEV_DISK_ADDRESS);
4324 device_add(machine, tmpstr);
4325
4326 snprintf(tmpstr, sizeof(tmpstr), "ether addr=0x%llx irq=0",
4327 (long long)DEV_ETHER_ADDRESS);
4328 device_add(machine, tmpstr);
4329
4330 break;
4331 #endif /* ENABLE_HPPA */
4332
4333 #ifdef ENABLE_I960
4334 case MACHINE_BAREI960:
4335 /* A bare I960 machine, with no devices. */
4336 machine->machine_name = "\"Bare\" i960 machine";
4337 break;
4338
4339 case MACHINE_TESTI960:
4340 machine->machine_name = "i960 test machine";
4341
4342 snprintf(tmpstr, sizeof(tmpstr), "cons addr=0x%llx irq=0",
4343 (long long)DEV_CONS_ADDRESS);
4344 cons_data = device_add(machine, tmpstr);
4345 machine->main_console_handle = cons_data->console_handle;
4346
4347 snprintf(tmpstr, sizeof(tmpstr), "mp addr=0x%llx",
4348 (long long)DEV_MP_ADDRESS);
4349 device_add(machine, tmpstr);
4350
4351 fb = dev_fb_init(machine, mem, DEV_FB_ADDRESS, VFB_GENERIC,
4352 640,480, 640,480, 24, "testi960 generic");
4353
4354 snprintf(tmpstr, sizeof(tmpstr), "disk addr=0x%llx",
4355 (long long)DEV_DISK_ADDRESS);
4356 device_add(machine, tmpstr);
4357
4358 snprintf(tmpstr, sizeof(tmpstr), "ether addr=0x%llx irq=0",
4359 (long long)DEV_ETHER_ADDRESS);
4360 device_add(machine, tmpstr);
4361
4362 break;
4363 #endif /* ENABLE_I960 */
4364
4365 #ifdef ENABLE_SPARC
4366 case MACHINE_BARESPARC:
4367 /* A bare SPARC machine, with no devices. */
4368 machine->machine_name = "\"Bare\" SPARC machine";
4369 break;
4370
4371 case MACHINE_TESTSPARC:
4372 machine->machine_name = "SPARC test machine";
4373
4374 snprintf(tmpstr, sizeof(tmpstr), "cons addr=0x%llx irq=0",
4375 (long long)DEV_CONS_ADDRESS);
4376 cons_data = device_add(machine, tmpstr);
4377 machine->main_console_handle = cons_data->console_handle;
4378
4379 snprintf(tmpstr, sizeof(tmpstr), "mp addr=0x%llx",
4380 (long long)DEV_MP_ADDRESS);
4381 device_add(machine, tmpstr);
4382
4383 fb = dev_fb_init(machine, mem, DEV_FB_ADDRESS, VFB_GENERIC,
4384 640,480, 640,480, 24, "testsparc generic");
4385
4386 snprintf(tmpstr, sizeof(tmpstr), "disk addr=0x%llx",
4387 (long long)DEV_DISK_ADDRESS);
4388 device_add(machine, tmpstr);
4389
4390 snprintf(tmpstr, sizeof(tmpstr), "ether addr=0x%llx irq=0",
4391 (long long)DEV_ETHER_ADDRESS);
4392 device_add(machine, tmpstr);
4393
4394 break;
4395
4396 case MACHINE_ULTRA1:
4397 /*
4398 * NetBSD/sparc64 (http://www.netbsd.org/Ports/sparc64/)
4399 * OpenBSD/sparc64 (http://www.openbsd.org/sparc64.html)
4400 */
4401 machine->machine_name = "Sun Ultra1";
4402 break;
4403 #endif /* ENABLE_SPARC */
4404
4405 #ifdef ENABLE_ALPHA
4406 case MACHINE_BAREALPHA:
4407 machine->machine_name = "\"Bare\" Alpha machine";
4408 break;
4409
4410 case MACHINE_TESTALPHA:
4411 machine->machine_name = "Alpha test machine";
4412
4413 snprintf(tmpstr, sizeof(tmpstr), "cons addr=0x%llx irq=0",
4414 (long long)DEV_CONS_ADDRESS);
4415 cons_data = device_add(machine, tmpstr);
4416 machine->main_console_handle = cons_data->console_handle;
4417
4418 snprintf(tmpstr, sizeof(tmpstr), "mp addr=0x%llx",
4419 (long long)DEV_MP_ADDRESS);
4420 device_add(machine, tmpstr);
4421
4422 fb = dev_fb_init(machine, mem, DEV_FB_ADDRESS, VFB_GENERIC,
4423 640,480, 640,480, 24, "testalpha generic");
4424
4425 snprintf(tmpstr, sizeof(tmpstr), "disk addr=0x%llx",
4426 (long long)DEV_DISK_ADDRESS);
4427 device_add(machine, tmpstr);
4428
4429 snprintf(tmpstr, sizeof(tmpstr), "ether addr=0x%llx irq=0",
4430 (long long)DEV_ETHER_ADDRESS);
4431 device_add(machine, tmpstr);
4432
4433 break;
4434
4435 case MACHINE_ALPHA:
4436 if (machine->prom_emulation) {
4437 struct rpb rpb;
4438 struct crb crb;
4439 struct ctb ctb;
4440
4441 /* TODO: Most of these... They are used by NetBSD/alpha: */
4442 /* a0 = First free Page Frame Number */
4443 /* a1 = PFN of current Level 1 page table */
4444 /* a2 = Bootinfo magic */
4445 /* a3 = Bootinfo pointer */
4446 /* a4 = Bootinfo version */
4447 cpu->cd.alpha.r[ALPHA_A0] = 16*1024*1024 / 8192;
4448 cpu->cd.alpha.r[ALPHA_A1] = 0;
4449 cpu->cd.alpha.r[ALPHA_A2] = 0;
4450 cpu->cd.alpha.r[ALPHA_A3] = 0;
4451 cpu->cd.alpha.r[ALPHA_A4] = 0;
4452
4453 /* HWRPB: Hardware Restart Parameter Block */
4454 memset(&rpb, 0, sizeof(struct rpb));
4455 store_64bit_word_in_host(cpu, (unsigned char *)
4456 &(rpb.rpb_phys), HWRPB_ADDR);
4457 strlcpy((char *)&(rpb.rpb_magic), "HWRPB", 8);
4458 store_64bit_word_in_host(cpu, (unsigned char *)
4459 &(rpb.rpb_size), sizeof(struct rpb));
4460 store_64bit_word_in_host(cpu, (unsigned char *)
4461 &(rpb.rpb_page_size), 8192);
4462 store_64bit_word_in_host(cpu, (unsigned char *)
4463 &(rpb.rpb_type), machine->machine_subtype);
4464 store_64bit_word_in_host(cpu, (unsigned char *)
4465 &(rpb.rpb_cc_freq), 100000000);
4466 store_64bit_word_in_host(cpu, (unsigned char *)
4467 &(rpb.rpb_ctb_off), CTB_ADDR - HWRPB_ADDR);
4468 store_64bit_word_in_host(cpu, (unsigned char *)
4469 &(rpb.rpb_crb_off), CRB_ADDR - HWRPB_ADDR);
4470
4471 /* CTB: Console Terminal Block */
4472 memset(&ctb, 0, sizeof(struct ctb));
4473 store_64bit_word_in_host(cpu, (unsigned char *)
4474 &(ctb.ctb_term_type), machine->use_x11?
4475 CTB_GRAPHICS : CTB_PRINTERPORT);
4476
4477 /* CRB: Console Routine Block */
4478 memset(&crb, 0, sizeof(struct crb));
4479 store_64bit_word_in_host(cpu, (unsigned char *)
4480 &(crb.crb_v_dispatch), CRB_ADDR - 0x100);
4481 store_64bit_word(cpu, CRB_ADDR - 0x100 + 8, 0x10000);
4482
4483 /*
4484 * Place a special "hack" palcode call at 0x10000:
4485 * (Hopefully nothing else will be there.)
4486 */
4487 store_32bit_word(cpu, 0x10000, 0x3fffffe);
4488
4489 store_buf(cpu, HWRPB_ADDR, (char *)&rpb, sizeof(struct rpb));
4490 store_buf(cpu, CTB_ADDR, (char *)&ctb, sizeof(struct ctb));
4491 store_buf(cpu, CRB_ADDR, (char *)&crb, sizeof(struct crb));
4492 }
4493
4494 switch (machine->machine_subtype) {
4495 case ST_DEC_3000_300:
4496 machine->machine_name = "DEC 3000/300";
4497 machine->main_console_handle =
4498 dev_zs_init(machine, mem, 0x1b0200000ULL,
4499 0, 4, "serial zs"); /* serial? netbsd? */
4500 break;
4501 case ST_EB164:
4502 machine->machine_name = "EB164";
4503 break;
4504 default:fatal("Unimplemented Alpha machine type %i\n",
4505 machine->machine_subtype);
4506 exit(1);
4507 }
4508
4509 break;
4510 #endif /* ENABLE_ALPHA */
4511
4512 #ifdef ENABLE_ARM
4513 case MACHINE_BAREARM:
4514 machine->machine_name = "\"Bare\" ARM machine";
4515 break;
4516
4517 case MACHINE_TESTARM:
4518 machine->machine_name = "ARM test machine";
4519
4520 snprintf(tmpstr, sizeof(tmpstr), "cons addr=0x%llx irq=0",
4521 (long long)DEV_CONS_ADDRESS);
4522 cons_data = device_add(machine, tmpstr);
4523 machine->main_console_handle = cons_data->console_handle;
4524
4525 snprintf(tmpstr, sizeof(tmpstr), "mp addr=0x%llx",
4526 (long long)DEV_MP_ADDRESS);
4527 device_add(machine, tmpstr);
4528
4529 fb = dev_fb_init(machine, mem, DEV_FB_ADDRESS, VFB_GENERIC,
4530 640,480, 640,480, 24, "testarm generic");
4531
4532 snprintf(tmpstr, sizeof(tmpstr), "disk addr=0x%llx",
4533 (long long)DEV_DISK_ADDRESS);
4534 device_add(machine, tmpstr);
4535
4536 snprintf(tmpstr, sizeof(tmpstr), "ether addr=0x%llx irq=0",
4537 (long long)DEV_ETHER_ADDRESS);
4538 device_add(machine, tmpstr);
4539
4540 /* Place a tiny stub at end of memory, and set the link
4541 register to point to it. This stub halts the machine. */
4542 cpu->cd.arm.r[ARM_SP] =
4543 machine->physical_ram_in_mb * 1048576 - 4096;
4544 cpu->cd.arm.r[ARM_LR] = cpu->cd.arm.r[ARM_SP] + 32;
4545 store_32bit_word(cpu, cpu->cd.arm.r[ARM_LR] + 0, 0xe3a00201);
4546 store_32bit_word(cpu, cpu->cd.arm.r[ARM_LR] + 4, 0xe5c00010);
4547 store_32bit_word(cpu, cpu->cd.arm.r[ARM_LR] + 8,
4548 0xeafffffe);
4549 break;
4550
4551 case MACHINE_CATS:
4552 machine->machine_name = "CATS evaluation board";
4553
4554 if (machine->emulated_hz == 0)
4555 machine->emulated_hz = 50000000;
4556
4557 if (machine->physical_ram_in_mb > 256)
4558 fprintf(stderr, "WARNING! Real CATS machines cannot"
4559 " have more than 256 MB RAM. Continuing anyway.\n");
4560
4561 machine->md_int.footbridge_data =
4562 device_add(machine, "footbridge addr=0x42000000");
4563 machine->md_interrupt = footbridge_interrupt;
4564
4565 /* NetBSD and OpenBSD clean their caches here: */
4566 dev_ram_init(machine, 0x50000000, 0x4000, DEV_RAM_RAM, 0);
4567
4568 /* Interrupt ack space? */
4569 dev_ram_init(machine, 0x80000000, 0x1000, DEV_RAM_RAM, 0);
4570
4571 snprintf(tmpstr, sizeof(tmpstr), "8259 irq=64 addr=0x7c000020");
4572 machine->isa_pic_data.pic1 = device_add(machine, tmpstr);
4573 snprintf(tmpstr, sizeof(tmpstr), "8259 irq=64 addr=0x7c0000a0");
4574 machine->isa_pic_data.pic2 = device_add(machine, tmpstr);
4575
4576 device_add(machine, "pccmos addr=0x7c000070");
4577
4578 if (machine->use_x11) {
4579 bus_pci_add(machine, machine->md_int.footbridge_data->pcibus,
4580 mem, 0xc0, 8, 0, pci_s3_virge_init, pci_s3_virge_rr);
4581 dev_vga_init(machine, mem, 0x800a0000ULL, 0x7c0003c0, machine->machine_name);
4582 j = dev_pckbc_init(machine, mem, 0x7c000060, PCKBC_8042,
4583 32 + 1, 32 + 12, machine->use_x11, 0);
4584 machine->main_console_handle = j;
4585 }
4586
4587 device_add(machine, "ns16550 irq=36 addr=0x7c0003f8 name2=com0 in_use=0");
4588 device_add(machine, "ns16550 irq=35 addr=0x7c0002f8 name2=com1 in_use=0");
4589
4590 device_add(machine, "lpt irq=39 addr=0x7c000378 name2=lpt in_use=0");
4591
4592 if (machine->prom_emulation) {
4593 struct ebsaboot ebsaboot;
4594 char bs[300];
4595 int boot_id = bootdev_id >= 0? bootdev_id : 0;
4596
4597 cpu->cd.arm.r[0] = /* machine->physical_ram_in_mb */
4598 7 * 1048576 - 0x1000;
4599
4600 memset(&ebsaboot, 0, sizeof(struct ebsaboot));
4601 store_32bit_word_in_host(cpu, (unsigned char *)
4602 &(ebsaboot.bt_magic), BT_MAGIC_NUMBER_CATS);
4603 store_32bit_word_in_host(cpu, (unsigned char *)
4604 &(ebsaboot.bt_vargp), 0);
4605 store_32bit_word_in_host(cpu, (unsigned char *)
4606 &(ebsaboot.bt_pargp), 0);
4607 store_32bit_word_in_host(cpu, (unsigned char *)
4608 &(ebsaboot.bt_args), cpu->cd.arm.r[0]
4609 + sizeof(struct ebsaboot));
4610 store_32bit_word_in_host(cpu, (unsigned char *)
4611 &(ebsaboot.bt_l1), 7 * 1048576 - 32768);
4612 store_32bit_word_in_host(cpu, (unsigned char *)
4613 &(ebsaboot.bt_memstart), 0);
4614 store_32bit_word_in_host(cpu, (unsigned char *)
4615 &(ebsaboot.bt_memend),
4616 machine->physical_ram_in_mb * 1048576);
4617 store_32bit_word_in_host(cpu, (unsigned char *)
4618 &(ebsaboot.bt_memavail), 7 * 1048576);
4619 store_32bit_word_in_host(cpu, (unsigned char *)
4620 &(ebsaboot.bt_fclk), 50 * 1000000);
4621 store_32bit_word_in_host(cpu, (unsigned char *)
4622 &(ebsaboot.bt_pciclk), 66 * 1000000);
4623 /* TODO: bt_vers */
4624 /* TODO: bt_features */
4625
4626 store_buf(cpu, cpu->cd.arm.r[0],
4627 (char *)&ebsaboot, sizeof(struct ebsaboot));
4628
4629 snprintf(bs, sizeof(bs), "(hd%i)%s%s%s",
4630 boot_id, machine->boot_kernel_filename,
4631 (machine->boot_string_argument[0])? " " : "",
4632 machine->boot_string_argument);
4633
4634 store_string(cpu, cpu->cd.arm.r[0] +
4635 sizeof(struct ebsaboot), bs);
4636
4637 arm_setup_initial_translation_table(cpu,
4638 7 * 1048576 - 32768);
4639 }
4640 break;
4641
4642 case MACHINE_HPCARM:
4643 cpu->byte_order = EMUL_LITTLE_ENDIAN;
4644 memset(&hpc_bootinfo, 0, sizeof(hpc_bootinfo));
4645 switch (machine->machine_subtype) {
4646 case MACHINE_HPCARM_IPAQ:
4647 /* SA-1110 206MHz */
4648 machine->machine_name = "Compaq iPAQ H3600";
4649 hpc_fb_addr = 0x48200000; /* TODO */
4650 hpc_fb_xsize = 240;
4651 hpc_fb_ysize = 320;
4652 hpc_fb_xsize_mem = 256;
4653 hpc_fb_ysize_mem = 320;
4654 hpc_fb_bits = 15;
4655 hpc_fb_encoding = BIFB_D16_0000;
4656 hpc_platid_cpu_arch = 3; /* ARM */
4657 hpc_platid_cpu_series = 1; /* StrongARM */
4658 hpc_platid_cpu_model = 2; /* SA-1110 */
4659 hpc_platid_cpu_submodel = 0;
4660 hpc_platid_vendor = 7; /* Compaq */
4661 hpc_platid_series = 4; /* IPAQ */
4662 hpc_platid_model = 2; /* H36xx */
4663 hpc_platid_submodel = 1; /* H3600 */
4664 break;
4665 case MACHINE_HPCARM_JORNADA720:
4666 /* SA-1110 206MHz */
4667 machine->machine_name = "Jornada 720";
4668 hpc_fb_addr = 0x48200000;
4669 hpc_fb_xsize = 640;
4670 hpc_fb_ysize = 240;
4671 hpc_fb_xsize_mem = 640;
4672 hpc_fb_ysize_mem = 240;
4673 hpc_fb_bits = 16;
4674 hpc_fb_encoding = BIFB_D16_0000;
4675 hpc_platid_cpu_arch = 3; /* ARM */
4676 hpc_platid_cpu_series = 1; /* StrongARM */
4677 hpc_platid_cpu_model = 2; /* SA-1110 */
4678 hpc_platid_cpu_submodel = 0;
4679 hpc_platid_vendor = 11; /* HP */
4680 hpc_platid_series = 2; /* Jornada */
4681 hpc_platid_model = 2; /* 7xx */
4682 hpc_platid_submodel = 1; /* 720 */
4683 break;
4684 default:
4685 printf("Unimplemented hpcarm machine number.\n");
4686 exit(1);
4687 }
4688
4689 store_32bit_word_in_host(cpu, (unsigned char *)&hpc_bootinfo.platid_cpu,
4690 (hpc_platid_cpu_arch << 26) + (hpc_platid_cpu_series << 20)
4691 + (hpc_platid_cpu_model << 14) + (hpc_platid_cpu_submodel << 8)
4692 + hpc_platid_flags);
4693 store_32bit_word_in_host(cpu, (unsigned char *)&hpc_bootinfo.platid_machine,
4694 (hpc_platid_vendor << 22) + (hpc_platid_series << 16)
4695 + (hpc_platid_model << 8) + hpc_platid_submodel);
4696
4697 if (machine->prom_emulation) {
4698 /* NetBSD/hpcarm and possibly others expects the following: */
4699
4700 cpu->cd.arm.r[0] = 1; /* argc */
4701 cpu->cd.arm.r[1] = machine->physical_ram_in_mb * 1048576 - 512; /* argv */
4702 cpu->cd.arm.r[2] = machine->physical_ram_in_mb * 1048576 - 256; /* ptr to hpc_bootinfo */
4703
4704 bootstr = machine->boot_kernel_filename;
4705 store_32bit_word(cpu, machine->physical_ram_in_mb * 1048576 - 512,
4706 machine->physical_ram_in_mb * 1048576 - 512 + 16);
4707 store_32bit_word(cpu, machine->physical_ram_in_mb * 1048576 - 512 + 4, 0);
4708 store_string(cpu, machine->physical_ram_in_mb * 1048576 - 512 + 16, bootstr);
4709
4710 if (machine->boot_string_argument[0]) {
4711 cpu->cd.arm.r[0] ++; /* argc */
4712
4713 store_32bit_word(cpu, machine->physical_ram_in_mb * 1048576 - 512 + 4, machine->physical_ram_in_mb * 1048576 - 512 + 64);
4714 store_32bit_word(cpu, machine->physical_ram_in_mb * 1048576 - 512 + 8, 0);
4715
4716 store_string(cpu, machine->physical_ram_in_mb * 1048576 - 512 + 64,
4717 machine->boot_string_argument);
4718
4719 bootarg = machine->boot_string_argument;
4720 }
4721
4722 store_16bit_word_in_host(cpu, (unsigned char *)&hpc_bootinfo.length, sizeof(hpc_bootinfo));
4723 store_32bit_word_in_host(cpu, (unsigned char *)&hpc_bootinfo.magic, HPC_BOOTINFO_MAGIC);
4724 store_32bit_word_in_host(cpu, (unsigned char *)&hpc_bootinfo.fb_addr, hpc_fb_addr);
4725 store_16bit_word_in_host(cpu, (unsigned char *)&hpc_bootinfo.fb_line_bytes, hpc_fb_xsize_mem * (((hpc_fb_bits-1)|7)+1) / 8);
4726 store_16bit_word_in_host(cpu, (unsigned char *)&hpc_bootinfo.fb_width, hpc_fb_xsize);
4727 store_16bit_word_in_host(cpu, (unsigned char *)&hpc_bootinfo.fb_height, hpc_fb_ysize);
4728 store_16bit_word_in_host(cpu, (unsigned char *)&hpc_bootinfo.fb_type, hpc_fb_encoding);
4729 store_16bit_word_in_host(cpu, (unsigned char *)&hpc_bootinfo.bi_cnuse,
4730 machine->use_x11? BI_CNUSE_BUILTIN : BI_CNUSE_SERIAL);
4731
4732 store_32bit_word_in_host(cpu, (unsigned char *)&hpc_bootinfo.timezone, 0);
4733 store_buf(cpu, machine->physical_ram_in_mb * 1048576 - 256, (char *)&hpc_bootinfo, sizeof(hpc_bootinfo));
4734
4735 /*
4736 * TODO: ugly hack, only works with small NetBSD
4737 * kernels!
4738 */
4739 cpu->cd.arm.r[ARM_SP] = 0xc02c0000;
4740 }
4741
4742 /* Physical RAM at 0xc0000000: */
4743 dev_ram_init(machine, 0xc0000000, 0x20000000,
4744 DEV_RAM_MIRROR, 0x0);
4745
4746 /* Cache flush region: */
4747 dev_ram_init(machine, 0xe0000000, 0x10000, DEV_RAM_RAM, 0x0);
4748
4749 if (hpc_fb_addr != 0) {
4750 dev_fb_init(machine, mem, hpc_fb_addr, VFB_HPC,
4751 hpc_fb_xsize, hpc_fb_ysize,
4752 hpc_fb_xsize_mem, hpc_fb_ysize_mem,
4753 hpc_fb_bits, machine->machine_name);
4754 }
4755 break;
4756
4757 case MACHINE_ZAURUS:
4758 machine->machine_name = "Zaurus";
4759 dev_ram_init(machine, 0xa0000000, 0x20000000,
4760 DEV_RAM_MIRROR, 0x0);
4761 device_add(machine, "ns16550 irq=0 addr=0x40100000 addr_mult=4");
4762 /* TODO */
4763 if (machine->prom_emulation) {
4764 arm_setup_initial_translation_table(cpu, 0x4000);
4765 }
4766 break;
4767
4768 case MACHINE_NETWINDER:
4769 machine->machine_name = "NetWinder";
4770
4771 if (machine->physical_ram_in_mb > 256)
4772 fprintf(stderr, "WARNING! Real NetWinders cannot"
4773 " have more than 256 MB RAM. Continuing anyway.\n");
4774
4775 machine->md_int.footbridge_data =
4776 device_add(machine, "footbridge addr=0x42000000");
4777 machine->md_interrupt = footbridge_interrupt;
4778
4779 snprintf(tmpstr, sizeof(tmpstr), "8259 irq=64 addr=0x7c000020");
4780 machine->isa_pic_data.pic1 = device_add(machine, tmpstr);
4781 snprintf(tmpstr, sizeof(tmpstr), "8259 irq=64 addr=0x7c0000a0");
4782 machine->isa_pic_data.pic2 = device_add(machine, tmpstr);
4783
4784 device_add(machine, "ns16550 irq=36 addr=0x7c0003f8 name2=com0");
4785 device_add(machine, "ns16550 irq=35 addr=0x7c0002f8 name2=com1");
4786
4787 if (machine->use_x11) {
4788 bus_pci_add(machine, machine->md_int.footbridge_data->pcibus,
4789 mem, 0xc0, 8, 0, pci_igsfb_init, pci_igsfb_rr);
4790 dev_vga_init(machine, mem, 0x800a0000ULL, 0x7c0003c0, machine->machine_name);
4791 j = dev_pckbc_init(machine, mem, 0x7c000060, PCKBC_8042,
4792 32 + 1, 32 + 12, machine->use_x11, 0);
4793 machine->main_console_handle = j;
4794 }
4795
4796 if (machine->prom_emulation) {
4797 arm_setup_initial_translation_table(cpu, 0x4000);
4798 }
4799 break;
4800
4801 case MACHINE_SHARK:
4802 machine->machine_name = "Digital DNARD (\"Shark\")";
4803 if (machine->prom_emulation) {
4804 arm_setup_initial_translation_table(cpu,
4805 machine->physical_ram_in_mb * 1048576 - 65536);
4806
4807 /*
4808 * r0 = OpenFirmware entry point. NOTE: See
4809 * cpu_arm.c for the rest of this semi-ugly hack.
4810 */
4811 cpu->cd.arm.r[0] = cpu->cd.arm.of_emul_addr;
4812 }
4813 break;
4814
4815 case MACHINE_IQ80321:
4816 /*
4817 * Intel IQ80321. See http://sources.redhat.com/ecos/docs-latest/redboot/iq80321.html
4818 * for more details about the memory map.
4819 */
4820 machine->machine_name = "Intel IQ80321 (ARM)";
4821 cpu->cd.arm.coproc[6] = arm_coproc_i80321;
4822 cpu->cd.arm.coproc[14] = arm_coproc_i80321_14;
4823 device_add(machine, "ns16550 irq=0 addr=0xfe800000");
4824
4825 /* 0xa0000000 = physical ram, 0xc0000000 = uncached */
4826 dev_ram_init(machine, 0xa0000000, 0x20000000,
4827 DEV_RAM_MIRROR, 0x0);
4828 dev_ram_init(machine, 0xc0000000, 0x20000000,
4829 DEV_RAM_MIRROR, 0x0);
4830
4831 /* 0xe0000000 and 0xff000000 = cache flush regions */
4832 dev_ram_init(machine, 0xe0000000, 0x100000, DEV_RAM_RAM, 0x0);
4833 dev_ram_init(machine, 0xff000000, 0x100000, DEV_RAM_RAM, 0x0);
4834
4835 device_add(machine, "i80321 addr=0xffffe000");
4836
4837 if (machine->prom_emulation) {
4838 arm_setup_initial_translation_table(cpu, 0x4000);
4839 arm_translation_table_set_l1(cpu, 0xa0000000, 0xa0000000);
4840 arm_translation_table_set_l1(cpu, 0xc0000000, 0xa0000000);
4841 arm_translation_table_set_l1(cpu, 0xe0000000, 0xe0000000);
4842 arm_translation_table_set_l1(cpu, 0xf0000000, 0xf0000000);
4843 }
4844 break;
4845
4846 case MACHINE_IYONIX:
4847 machine->machine_name = "Iyonix";
4848 cpu->cd.arm.coproc[6] = arm_coproc_i80321;
4849 cpu->cd.arm.coproc[14] = arm_coproc_i80321_14;
4850
4851 device_add(machine, "ns16550 irq=0 addr=0xfe800000");
4852
4853 /* 0xa0000000 = physical ram, 0xc0000000 = uncached */
4854 dev_ram_init(machine, 0xa0000000, 0x20000000,
4855 DEV_RAM_MIRROR, 0x0);
4856 dev_ram_init(machine, 0xc0000000, 0x20000000,
4857 DEV_RAM_MIRROR, 0x0);
4858
4859 device_add(machine, "i80321 addr=0xffffe000");
4860
4861 if (machine->prom_emulation) {
4862 arm_setup_initial_translation_table(cpu,
4863 machine->physical_ram_in_mb * 1048576 - 65536);
4864 arm_translation_table_set_l1(cpu, 0xa0000000, 0xa0000000);
4865 arm_translation_table_set_l1(cpu, 0xc0000000, 0xa0000000);
4866 arm_translation_table_set_l1_b(cpu, 0xff000000, 0xff000000);
4867 }
4868 break;
4869 #endif /* ENABLE_ARM */
4870
4871 #ifdef ENABLE_AVR
4872 case MACHINE_BAREAVR:
4873 /* A bare Atmel AVR machine, with no devices. */
4874 machine->machine_name = "\"Bare\" Atmel AVR machine";
4875 break;
4876 #endif /* ENABLE_AVR */
4877
4878 #ifdef ENABLE_IA64
4879 case MACHINE_BAREIA64:
4880 machine->machine_name = "\"Bare\" IA64 machine";
4881 break;
4882
4883 case MACHINE_TESTIA64:
4884 machine->machine_name = "IA64 test machine";
4885
4886 snprintf(tmpstr, sizeof(tmpstr), "cons addr=0x%llx irq=0",
4887 (long long)DEV_CONS_ADDRESS);
4888 cons_data = device_add(machine, tmpstr);
4889 machine->main_console_handle = cons_data->console_handle;
4890
4891 snprintf(tmpstr, sizeof(tmpstr), "mp addr=0x%llx",
4892 (long long)DEV_MP_ADDRESS);
4893 device_add(machine, tmpstr);
4894
4895 fb = dev_fb_init(machine, mem, DEV_FB_ADDRESS, VFB_GENERIC,
4896 640,480, 640,480, 24, "testia64 generic");
4897
4898 snprintf(tmpstr, sizeof(tmpstr), "disk addr=0x%llx",
4899 (long long)DEV_DISK_ADDRESS);
4900 device_add(machine, tmpstr);
4901
4902 snprintf(tmpstr, sizeof(tmpstr), "ether addr=0x%llx irq=0",
4903 (long long)DEV_ETHER_ADDRESS);
4904 device_add(machine, tmpstr);
4905
4906 break;
4907 #endif /* ENABLE_IA64 */
4908
4909 #ifdef ENABLE_M68K
4910 case MACHINE_BAREM68K:
4911 machine->machine_name = "\"Bare\" M68K machine";
4912 break;
4913
4914 case MACHINE_TESTM68K:
4915 machine->machine_name = "M68K test machine";
4916
4917 snprintf(tmpstr, sizeof(tmpstr), "cons addr=0x%llx irq=0",
4918 (long long)DEV_CONS_ADDRESS);
4919 cons_data = device_add(machine, tmpstr);
4920 machine->main_console_handle = cons_data->console_handle;
4921
4922 snprintf(tmpstr, sizeof(tmpstr), "mp addr=0x%llx",
4923 (long long)DEV_MP_ADDRESS);
4924 device_add(machine, tmpstr);
4925
4926 fb = dev_fb_init(machine, mem, DEV_FB_ADDRESS, VFB_GENERIC,
4927 640,480, 640,480, 24, "testm68k generic");
4928
4929 snprintf(tmpstr, sizeof(tmpstr), "disk addr=0x%llx",
4930 (long long)DEV_DISK_ADDRESS);
4931 device_add(machine, tmpstr);
4932
4933 snprintf(tmpstr, sizeof(tmpstr), "ether addr=0x%llx irq=0",
4934 (long long)DEV_ETHER_ADDRESS);
4935 device_add(machine, tmpstr);
4936
4937 break;
4938 #endif /* ENABLE_M68K */
4939
4940 #ifdef ENABLE_X86
4941 case MACHINE_BAREX86:
4942 machine->machine_name = "\"Bare\" x86 machine";
4943 break;
4944
4945 case MACHINE_X86:
4946 if (machine->machine_subtype == MACHINE_X86_XT)
4947 machine->machine_name = "PC XT";
4948 else
4949 machine->machine_name = "Generic x86 PC";
4950
4951 /* Interrupt controllers: */
4952 snprintf(tmpstr, sizeof(tmpstr), "8259 irq=16 addr=0x%llx",
4953 (long long)(X86_IO_BASE + 0x20));
4954 machine->isa_pic_data.pic1 = device_add(machine, tmpstr);
4955 if (machine->machine_subtype != MACHINE_X86_XT) {
4956 snprintf(tmpstr, sizeof(tmpstr), "8259 irq=16 addr=0x%llx irq=2",
4957 (long long)(X86_IO_BASE + 0xa0));
4958 machine->isa_pic_data.pic2 = device_add(machine, tmpstr);
4959 }
4960
4961 machine->md_interrupt = x86_pc_interrupt;
4962
4963 /* Timer: */
4964 snprintf(tmpstr, sizeof(tmpstr), "8253 addr=0x%llx irq=0",
4965 (long long)(X86_IO_BASE + 0x40));
4966 device_add(machine, tmpstr);
4967
4968 snprintf(tmpstr, sizeof(tmpstr), "pccmos addr=0x%llx",
4969 (long long)(X86_IO_BASE + 0x70));
4970 device_add(machine, tmpstr);
4971
4972 /* TODO: IRQ when emulating a PC XT? */
4973
4974 /* IDE controllers: */
4975 if (diskimage_exist(machine, 0, DISKIMAGE_IDE) ||
4976 diskimage_exist(machine, 1, DISKIMAGE_IDE)) {
4977 snprintf(tmpstr, sizeof(tmpstr), "wdc addr=0x%llx irq=%i",
4978 X86_IO_BASE + 0x1f0, 14);
4979 device_add(machine, tmpstr);
4980 }
4981 if (diskimage_exist(machine, 2, DISKIMAGE_IDE) ||
4982 diskimage_exist(machine, 3, DISKIMAGE_IDE)) {
4983 snprintf(tmpstr, sizeof(tmpstr), "wdc addr=0x%llx irq=%i",
4984 X86_IO_BASE + 0x170, 15);
4985 device_add(machine, tmpstr);
4986 }
4987
4988 /* Floppy controller at irq 6 */
4989 snprintf(tmpstr, sizeof(tmpstr), "fdc addr=0x%llx irq=6",
4990 (long long)(X86_IO_BASE + 0x3f0));
4991 device_add(machine, tmpstr);
4992
4993 /* TODO: sound blaster (eventually) at irq 7? */
4994
4995 /* TODO: parallel port */
4996
4997 /* Serial ports: (TODO: 8250 for PC XT?) */
4998
4999 snprintf(tmpstr, sizeof(tmpstr), "ns16550 irq=4 addr=0x%llx name2=com1 in_use=0",
5000 (long long)X86_IO_BASE + 0x3f8);
5001 device_add(machine, tmpstr);
5002 snprintf(tmpstr, sizeof(tmpstr), "ns16550 irq=3 addr=0x%llx name2=com2 in_use=0",
5003 (long long)X86_IO_BASE + 0x2f8);
5004 device_add(machine, tmpstr);
5005
5006 /* VGA + keyboard: */
5007 dev_vga_init(machine, mem, 0xa0000ULL, X86_IO_BASE + 0x3c0,
5008 "Generic x86 PC");
5009 machine->main_console_handle = dev_pckbc_init(machine,
5010 mem, X86_IO_BASE + 0x60, PCKBC_8042, 1, 12, 1, 1);
5011
5012 if (machine->prom_emulation)
5013 pc_bios_init(cpu);
5014
5015 if (!machine->use_x11 && !quiet_mode)
5016 fprintf(stderr, "-------------------------------------"
5017 "------------------------------------------\n"
5018 "\n WARNING! You are emulating a PC without -X. "
5019 "You will miss graphical output!\n\n"
5020 "-------------------------------------"
5021 "------------------------------------------\n");
5022 break;
5023 #endif /* ENABLE_X86 */
5024
5025 default:
5026 fatal("Unknown emulation type %i\n", machine->machine_type);
5027 exit(1);
5028 }
5029
5030 if (machine->machine_name != NULL)
5031 debug("machine: %s", machine->machine_name);
5032
5033 if (machine->emulated_hz > 0)
5034 debug(" (%.2f MHz)", (float)machine->emulated_hz / 1000000);
5035 debug("\n");
5036
5037 if (machine->emulated_hz < 1)
5038 machine->emulated_hz = 1000000;
5039
5040 if (bootstr != NULL) {
5041 debug("bootstring%s: %s", (bootarg!=NULL &&
5042 strlen(bootarg) >= 1)? "(+bootarg)" : "", bootstr);
5043 if (bootarg != NULL && strlen(bootarg) >= 1)
5044 debug(" %s", bootarg);
5045 debug("\n");
5046 }
5047 }
5048
5049
5050 /*
5051 * machine_memsize_fix():
5052 *
5053 * Sets physical_ram_in_mb (if not already set), and memory_offset_in_mb,
5054 * depending on machine type.
5055 */
5056 void machine_memsize_fix(struct machine *m)
5057 {
5058 if (m == NULL) {
5059 fatal("machine_defaultmemsize(): m == NULL?\n");
5060 exit(1);
5061 }
5062
5063 if (m->physical_ram_in_mb == 0) {
5064 switch (m->machine_type) {
5065 case MACHINE_PS2:
5066 m->physical_ram_in_mb = 32;
5067 break;
5068 case MACHINE_SGI:
5069 m->physical_ram_in_mb = 64;
5070 break;
5071 case MACHINE_HPCMIPS:
5072 /* Most have 32 MB by default. */
5073 m->physical_ram_in_mb = 32;
5074 switch (m->machine_subtype) {
5075 case MACHINE_HPCMIPS_CASIO_BE300:
5076 m->physical_ram_in_mb = 16;
5077 break;
5078 case MACHINE_HPCMIPS_CASIO_E105:
5079 m->physical_ram_in_mb = 32;
5080 break;
5081 case MACHINE_HPCMIPS_AGENDA_VR3:
5082 m->physical_ram_in_mb = 16;
5083 break;
5084 }
5085 break;
5086 case MACHINE_MESHCUBE:
5087 m->physical_ram_in_mb = 64;
5088 break;
5089 case MACHINE_NETGEAR:
5090 m->physical_ram_in_mb = 16;
5091 break;
5092 case MACHINE_EVBMIPS:
5093 m->physical_ram_in_mb = 64;
5094 break;
5095 case MACHINE_PSP:
5096 /*
5097 * According to
5098 * http://wiki.ps2dev.org/psp:memory_map:
5099 * 0×08000000 = 8 MB kernel memory
5100 * 0×08800000 = 24 MB user memory
5101 */
5102 m->physical_ram_in_mb = 8 + 24;
5103 break;
5104 case MACHINE_ARC:
5105 switch (m->machine_subtype) {
5106 case MACHINE_ARC_JAZZ_PICA:
5107 m->physical_ram_in_mb = 64;
5108 break;
5109 case MACHINE_ARC_JAZZ_M700:
5110 m->physical_ram_in_mb = 64;
5111 break;
5112 default:
5113 m->physical_ram_in_mb = 32;
5114 }
5115 break;
5116 case MACHINE_DEC:
5117 switch (m->machine_subtype) {
5118 case MACHINE_DEC_PMAX_3100:
5119 m->physical_ram_in_mb = 24;
5120 break;
5121 default:
5122 m->physical_ram_in_mb = 32;
5123 }
5124 break;
5125 case MACHINE_ALPHA:
5126 m->physical_ram_in_mb = 64;
5127 break;
5128 case MACHINE_BEBOX:
5129 m->physical_ram_in_mb = 64;
5130 break;
5131 case MACHINE_CATS:
5132 m->physical_ram_in_mb = 64;
5133 break;
5134 case MACHINE_ZAURUS:
5135 m->physical_ram_in_mb = 64;
5136 break;
5137 case MACHINE_HPCARM:
5138 m->physical_ram_in_mb = 32;
5139 break;
5140 case MACHINE_NETWINDER:
5141 m->physical_ram_in_mb = 16;
5142 break;
5143 case MACHINE_X86:
5144 if (m->machine_subtype == MACHINE_X86_XT)
5145 m->physical_ram_in_mb = 1;
5146 break;
5147 }
5148 }
5149
5150 /* Special hack for hpcmips machines: */
5151 if (m->machine_type == MACHINE_HPCMIPS) {
5152 m->dbe_on_nonexistant_memaccess = 0;
5153 }
5154
5155 /* Special SGI memory offsets: */
5156 if (m->machine_type == MACHINE_SGI) {
5157 switch (m->machine_subtype) {
5158 case 20:
5159 case 22:
5160 case 24:
5161 case 26:
5162 m->memory_offset_in_mb = 128;
5163 break;
5164 case 28:
5165 case 30:
5166 m->memory_offset_in_mb = 512;
5167 break;
5168 }
5169 }
5170
5171 if (m->physical_ram_in_mb == 0)
5172 m->physical_ram_in_mb = DEFAULT_RAM_IN_MB;
5173 }
5174
5175
5176 /*
5177 * machine_default_cputype():
5178 *
5179 * Sets m->cpu_name, if it isn't already set, depending on the machine
5180 * type.
5181 */
5182 void machine_default_cputype(struct machine *m)
5183 {
5184 if (m == NULL) {
5185 fatal("machine_default_cputype(): m == NULL?\n");
5186 exit(1);
5187 }
5188
5189 if (m->cpu_name != NULL)
5190 return;
5191
5192 switch (m->machine_type) {
5193 case MACHINE_BAREMIPS:
5194 case MACHINE_TESTMIPS:
5195 m->cpu_name = strdup("R4000");
5196 break;
5197 case MACHINE_PS2:
5198 m->cpu_name = strdup("R5900");
5199 break;
5200 case MACHINE_DEC:
5201 if (m->machine_subtype > 2)
5202 m->cpu_name = strdup("R3000A");
5203 if (m->machine_subtype > 1 && m->cpu_name == NULL)
5204 m->cpu_name = strdup("R3000");
5205 if (m->cpu_name == NULL)
5206 m->cpu_name = strdup("R2000");
5207 break;
5208 case MACHINE_SONYNEWS:
5209 m->cpu_name = strdup("R3000");
5210 break;
5211 case MACHINE_HPCMIPS:
5212 switch (m->machine_subtype) {
5213 case MACHINE_HPCMIPS_CASIO_BE300:
5214 m->cpu_name = strdup("VR4131");
5215 break;
5216 case MACHINE_HPCMIPS_CASIO_E105:
5217 m->cpu_name = strdup("VR4121");
5218 break;
5219 case MACHINE_HPCMIPS_NEC_MOBILEPRO_770:
5220 case MACHINE_HPCMIPS_NEC_MOBILEPRO_780:
5221 case MACHINE_HPCMIPS_NEC_MOBILEPRO_800:
5222 case MACHINE_HPCMIPS_NEC_MOBILEPRO_880:
5223 m->cpu_name = strdup("VR4121");
5224 break;
5225 case MACHINE_HPCMIPS_AGENDA_VR3:
5226 m->cpu_name = strdup("VR4181");
5227 break;
5228 case MACHINE_HPCMIPS_IBM_WORKPAD_Z50:
5229 m->cpu_name = strdup("VR4121");
5230 break;
5231 default:
5232 printf("Unimplemented HPCMIPS model?\n");
5233 exit(1);
5234 }
5235 break;
5236 case MACHINE_COBALT:
5237 m->cpu_name = strdup("RM5200");
5238 break;
5239 case MACHINE_MESHCUBE:
5240 m->cpu_name = strdup("R4400");
5241 /* TODO: Should be AU1500, but Linux doesn't like
5242 the absence of caches in the emulator */
5243 break;
5244 case MACHINE_NETGEAR:
5245 m->cpu_name = strdup("RC32334");
5246 break;
5247 case MACHINE_ARC:
5248 switch (m->machine_subtype) {
5249 case MACHINE_ARC_JAZZ_PICA:
5250 m->cpu_name = strdup("R4000");
5251 break;
5252 default:
5253 m->cpu_name = strdup("R4400");
5254 }
5255 break;
5256 case MACHINE_SGI:
5257 if (m->machine_subtype <= 12)
5258 m->cpu_name = strdup("R3000");
5259 if (m->cpu_name == NULL && m->machine_subtype == 35)
5260 m->cpu_name = strdup("R12000");
5261 if (m->cpu_name == NULL && (m->machine_subtype == 25 ||
5262 m->machine_subtype == 27 ||
5263 m->machine_subtype == 28 ||
5264 m->machine_subtype == 30 ||
5265 m->machine_subtype == 32))
5266 m->cpu_name = strdup("R10000");
5267 if (m->cpu_name == NULL && (m->machine_subtype == 21 ||
5268 m->machine_subtype == 26))
5269 m->cpu_name = strdup("R8000");
5270 if (m->cpu_name == NULL && m->machine_subtype == 24)
5271 m->cpu_name = strdup("R5000");
5272
5273 /* Other SGIs should probably work with
5274 R4000, R4400 or R5000 or similar: */
5275 if (m->cpu_name == NULL)
5276 m->cpu_name = strdup("R4400");
5277 break;
5278 case MACHINE_EVBMIPS:
5279 switch (m->machine_subtype) {
5280 case MACHINE_EVBMIPS_MALTA:
5281 case MACHINE_EVBMIPS_MALTA_BE:
5282 m->cpu_name = strdup("5Kc");
5283 break;
5284 case MACHINE_EVBMIPS_PB1000:
5285 m->cpu_name = strdup("AU1000");
5286 break;
5287 default:fatal("Unimpl. evbmips.\n");
5288 exit(1);
5289 }
5290 break;
5291 case MACHINE_PSP:
5292 m->cpu_name = strdup("Allegrex");
5293 break;
5294
5295 /* PowerPC: */
5296 case MACHINE_BAREPPC:
5297 case MACHINE_TESTPPC:
5298 m->cpu_name = strdup("PPC970");
5299 break;
5300 case MACHINE_WALNUT:
5301 /* For NetBSD/evbppc. */
5302 m->cpu_name = strdup("PPC405GP");
5303 break;
5304 case MACHINE_PMPPC:
5305 /* For NetBSD/pmppc. */
5306 m->cpu_name = strdup("PPC750");
5307 break;
5308 case MACHINE_SANDPOINT:
5309 /*
5310 * For NetBSD/sandpoint. According to NetBSD's page:
5311 *
5312 * "Unity" module has an MPC8240.
5313 * "Altimus" module has an MPC7400 (G4) or an MPC107.
5314 */
5315 m->cpu_name = strdup("MPC7400");
5316 break;
5317 case MACHINE_BEBOX:
5318 /* For NetBSD/bebox. Dual 133 MHz 603e CPUs, for example. */
5319 m->cpu_name = strdup("PPC603e");
5320 break;
5321 case MACHINE_PREP:
5322 /* For NetBSD/prep. TODO */
5323 m->cpu_name = strdup("PPC603e");
5324 break;
5325 case MACHINE_MACPPC:
5326 switch (m->machine_subtype) {
5327 case MACHINE_MACPPC_G4:
5328 m->cpu_name = strdup("PPC750");
5329 break;
5330 case MACHINE_MACPPC_G5:
5331 m->cpu_name = strdup("PPC970");
5332 break;
5333 }
5334 break;
5335 case MACHINE_DB64360:
5336 m->cpu_name = strdup("PPC750");
5337 break;
5338
5339 /* SH: */
5340 case MACHINE_BARESH:
5341 case MACHINE_TESTSH:
5342 case MACHINE_HPCSH:
5343 m->cpu_name = strdup("SH");
5344 break;
5345
5346 /* HPPA: */
5347 case MACHINE_BAREHPPA:
5348 case MACHINE_TESTHPPA:
5349 m->cpu_name = strdup("HPPA");
5350 break;
5351
5352 /* i960: */
5353 case MACHINE_BAREI960:
5354 case MACHINE_TESTI960:
5355 m->cpu_name = strdup("i960");
5356 break;
5357
5358 /* SPARC: */
5359 case MACHINE_BARESPARC:
5360 case MACHINE_TESTSPARC:
5361 case MACHINE_ULTRA1:
5362 m->cpu_name = strdup("SPARCv9");
5363 break;
5364
5365 /* Alpha: */
5366 case MACHINE_BAREALPHA:
5367 case MACHINE_TESTALPHA:
5368 case MACHINE_ALPHA:
5369 m->cpu_name = strdup("Alpha");
5370 break;
5371
5372 /* ARM: */
5373 case MACHINE_BAREARM:
5374 case MACHINE_TESTARM:
5375 case MACHINE_HPCARM:
5376 m->cpu_name = strdup("SA1110");
5377 break;
5378 case MACHINE_IQ80321:
5379 case MACHINE_IYONIX:
5380 m->cpu_name = strdup("80321_600_B0");
5381 break;
5382 case MACHINE_CATS:
5383 case MACHINE_NETWINDER:
5384 case MACHINE_SHARK:
5385 m->cpu_name = strdup("SA110");
5386 break;
5387 case MACHINE_ZAURUS:
5388 m->cpu_name = strdup("PXA210");
5389 break;
5390
5391 /* AVR: */
5392 case MACHINE_BAREAVR:
5393 m->cpu_name = strdup("AVR");
5394 break;
5395
5396 /* IA64: */
5397 case MACHINE_BAREIA64:
5398 case MACHINE_TESTIA64:
5399 m->cpu_name = strdup("IA64");
5400 break;
5401
5402 /* M68K: */
5403 case MACHINE_BAREM68K:
5404 case MACHINE_TESTM68K:
5405 m->cpu_name = strdup("68020");
5406 break;
5407
5408 /* x86: */
5409 case MACHINE_BAREX86:
5410 case MACHINE_X86:
5411 if (m->machine_subtype == MACHINE_X86_XT)
5412 m->cpu_name = strdup("8086");
5413 else
5414 m->cpu_name = strdup("AMD64");
5415 break;
5416 }
5417
5418 if (m->cpu_name == NULL) {
5419 fprintf(stderr, "machine_default_cputype(): no default"
5420 " cpu for machine type %i subtype %i\n",
5421 m->machine_type, m->machine_subtype);
5422 exit(1);
5423 }
5424 }
5425
5426
5427 /*
5428 * machine_dumpinfo():
5429 *
5430 * Dumps info about a machine in some kind of readable format. (Used by
5431 * the 'machine' debugger command.)
5432 */
5433 void machine_dumpinfo(struct machine *m)
5434 {
5435 int i;
5436
5437 debug("serial nr: %i", m->serial_nr);
5438 if (m->nr_of_nics > 0)
5439 debug(" (nr of nics: %i)", m->nr_of_nics);
5440 debug("\n");
5441
5442 debug("memory: %i MB", m->physical_ram_in_mb);
5443 if (m->memory_offset_in_mb != 0)
5444 debug(" (offset by %i MB)", m->memory_offset_in_mb);
5445 if (m->random_mem_contents)
5446 debug(", randomized contents");
5447 if (m->dbe_on_nonexistant_memaccess)
5448 debug(", dbe_on_nonexistant_memaccess");
5449 debug("\n");
5450
5451 if (m->single_step_on_bad_addr)
5452 debug("single-step on bad addresses\n");
5453
5454 if (m->arch == ARCH_MIPS) {
5455 if (m->bintrans_enable)
5456 debug("bintrans enabled (%i MB cache)\n",
5457 (int) (m->bintrans_size / 1048576));
5458 else
5459 debug("bintrans disabled, other speedtricks %s\n",
5460 m->speed_tricks? "enabled" : "disabled");
5461 }
5462
5463 debug("clock: ");
5464 if (m->automatic_clock_adjustment)
5465 debug("adjusted automatically");
5466 else
5467 debug("fixed at %i Hz", m->emulated_hz);
5468 debug("\n");
5469
5470 if (!m->prom_emulation)
5471 debug("PROM emulation disabled\n");
5472
5473 for (i=0; i<m->ncpus; i++)
5474 cpu_dumpinfo(m, m->cpus[i]);
5475
5476 if (m->ncpus > 1)
5477 debug("Bootstrap cpu is nr %i\n", m->bootstrap_cpu);
5478
5479 if (m->slow_serial_interrupts_hack_for_linux)
5480 debug("Using slow_serial_interrupts_hack_for_linux\n");
5481
5482 if (m->use_x11) {
5483 debug("Using X11");
5484 if (m->x11_scaledown > 1)
5485 debug(", scaledown %i", m->x11_scaledown);
5486 if (m->x11_n_display_names > 0) {
5487 for (i=0; i<m->x11_n_display_names; i++) {
5488 debug(i? ", " : " (");
5489 debug("\"%s\"", m->x11_display_names[i]);
5490 }
5491 debug(")");
5492 }
5493 debug("\n");
5494 }
5495
5496 diskimage_dump_info(m);
5497
5498 if (m->force_netboot)
5499 debug("Forced netboot\n");
5500 }
5501
5502
5503 /*
5504 * machine_entry_new():
5505 *
5506 * This function creates a new machine_entry struct, and fills it with some
5507 * valid data; it is up to the caller to add additional data that weren't
5508 * passed as arguments to this function.
5509 *
5510 * For internal use.
5511 */
5512 static struct machine_entry *machine_entry_new(const char *name,
5513 int arch, int oldstyle_type, int n_aliases, int n_subtypes)
5514 {
5515 struct machine_entry *me;
5516
5517 me = malloc(sizeof(struct machine_entry));
5518 if (me == NULL) {
5519 fprintf(stderr, "machine_entry_new(): out of memory (1)\n");
5520 exit(1);
5521 }
5522
5523 memset(me, 0, sizeof(struct machine_entry));
5524
5525 me->name = name;
5526 me->arch = arch;
5527 me->machine_type = oldstyle_type;
5528 me->n_aliases = n_aliases;
5529 me->aliases = malloc(sizeof(char *) * n_aliases);
5530 if (me->aliases == NULL) {
5531 fprintf(stderr, "machine_entry_new(): out of memory (2)\n");
5532 exit(1);
5533 }
5534 me->n_subtypes = n_subtypes;
5535
5536 if (n_subtypes > 0) {
5537 me->subtype = malloc(sizeof(struct machine_entry_subtype *) *
5538 n_subtypes);
5539 if (me->subtype == NULL) {
5540 fprintf(stderr, "machine_entry_new(): out of "
5541 "memory (3)\n");
5542 exit(1);
5543 }
5544 }
5545
5546 return me;
5547 }
5548
5549
5550 /*
5551 * machine_entry_subtype_new():
5552 *
5553 * This function creates a new machine_entry_subtype struct, and fills it with
5554 * some valid data; it is up to the caller to add additional data that weren't
5555 * passed as arguments to this function.
5556 *
5557 * For internal use.
5558 */
5559 static struct machine_entry_subtype *machine_entry_subtype_new(
5560 const char *name, int oldstyle_type, int n_aliases)
5561 {
5562 struct machine_entry_subtype *mes;
5563
5564 mes = malloc(sizeof(struct machine_entry_subtype));
5565 if (mes == NULL) {
5566 fprintf(stderr, "machine_entry_subtype_new(): out "
5567 "of memory (1)\n");
5568 exit(1);
5569 }
5570
5571 memset(mes, 0, sizeof(struct machine_entry_subtype));
5572 mes->name = name;
5573 mes->machine_subtype = oldstyle_type;
5574 mes->n_aliases = n_aliases;
5575 mes->aliases = malloc(sizeof(char *) * n_aliases);
5576 if (mes->aliases == NULL) {
5577 fprintf(stderr, "machine_entry_subtype_new(): "
5578 "out of memory (2)\n");
5579 exit(1);
5580 }
5581
5582 return mes;
5583 }
5584
5585
5586 /*
5587 * machine_list_available_types_and_cpus():
5588 *
5589 * List all available machine types (for example when running the emulator
5590 * with just -H as command line argument).
5591 */
5592 void machine_list_available_types_and_cpus(void)
5593 {
5594 struct machine_entry *me;
5595 int iadd = 8;
5596
5597 debug("Available CPU types:\n\n");
5598
5599 debug_indentation(iadd);
5600 cpu_list_available_types();
5601 debug_indentation(-iadd);
5602
5603 debug("\nMost of the CPU types are bogus, and not really implemented."
5604 " The main effect of\nselecting a specific CPU type is to choose "
5605 "what kind of 'id' it will have.\n\nAvailable machine types (with "
5606 "aliases) and their subtypes:\n\n");
5607
5608 debug_indentation(iadd);
5609 me = first_machine_entry;
5610
5611 if (me == NULL)
5612 fatal("No machines defined!\n");
5613
5614 while (me != NULL) {
5615 int i, j, iadd = 4;
5616
5617 debug("%s", me->name);
5618 debug(" (");
5619 for (i=0; i<me->n_aliases; i++)
5620 debug("%s\"%s\"", i? ", " : "", me->aliases[i]);
5621 debug(")\n");
5622
5623 debug_indentation(iadd);
5624 for (i=0; i<me->n_subtypes; i++) {
5625 struct machine_entry_subtype *mes;
5626 mes = me->subtype[i];
5627 debug("- %s", mes->name);
5628 debug(" (");
5629 for (j=0; j<mes->n_aliases; j++)
5630 debug("%s\"%s\"", j? ", " : "",
5631 mes->aliases[j]);
5632 debug(")\n");
5633 }
5634 debug_indentation(-iadd);
5635
5636 me = me->next;
5637 }
5638 debug_indentation(-iadd);
5639
5640 debug("\nMost of the machine types are bogus too. Please read the "
5641 "GXemul\ndocumentation for information about which machine"
5642 " types that actually\nwork. Use the alias when selecting a "
5643 "machine type or subtype, not the\nreal name.\n");
5644
5645 debug("\n");
5646
5647 useremul_list_emuls();
5648 debug("Userland emulation works for programs with the complexity"
5649 " of Hello World,\nbut not much more.\n");
5650 }
5651
5652
5653 /*
5654 * machine_init():
5655 *
5656 * This function should be called before any other machine_*() function
5657 * is used.
5658 */
5659 void machine_init(void)
5660 {
5661 struct machine_entry *me;
5662
5663 /*
5664 * NOTE: This list is in reverse order, so that the
5665 * entries will appear in normal order when listed. :-)
5666 */
5667
5668 /* Zaurus: */
5669 me = machine_entry_new("Zaurus (ARM)",
5670 ARCH_ARM, MACHINE_ZAURUS, 1, 0);
5671 me->aliases[0] = "zaurus";
5672 if (cpu_family_ptr_by_number(ARCH_ARM) != NULL) {
5673 me->next = first_machine_entry; first_machine_entry = me;
5674 }
5675
5676 /* X86 machine: */
5677 me = machine_entry_new("x86-based PC", ARCH_X86,
5678 MACHINE_X86, 2, 2);
5679 me->aliases[0] = "pc";
5680 me->aliases[1] = "x86";
5681 me->subtype[0] = machine_entry_subtype_new("Generic PC",
5682 MACHINE_X86_GENERIC, 1);
5683 me->subtype[0]->aliases[0] = "generic";
5684 me->subtype[1] = machine_entry_subtype_new("PC XT", MACHINE_X86_XT, 1);
5685 me->subtype[1]->aliases[0] = "xt";
5686 if (cpu_family_ptr_by_number(ARCH_X86) != NULL) {
5687 me->next = first_machine_entry; first_machine_entry = me;
5688 }
5689
5690 /* Walnut: (NetBSD/evbppc) */
5691 me = machine_entry_new("Walnut evaluation board", ARCH_PPC,
5692 MACHINE_WALNUT, 2, 0);
5693 me->aliases[0] = "walnut";
5694 me->aliases[1] = "evbppc";
5695 if (cpu_family_ptr_by_number(ARCH_PPC) != NULL) {
5696 me->next = first_machine_entry; first_machine_entry = me;
5697 }
5698
5699 /* Test-machine for SPARC: */
5700 me = machine_entry_new("Test-machine for SPARC", ARCH_SPARC,
5701 MACHINE_TESTSPARC, 1, 0);
5702 me->aliases[0] = "testsparc";
5703 if (cpu_family_ptr_by_number(ARCH_SPARC) != NULL) {
5704 me->next = first_machine_entry; first_machine_entry = me;
5705 }
5706
5707 /* Test-machine for SH: */
5708 me = machine_entry_new("Test-machine for SH", ARCH_SH,
5709 MACHINE_TESTSH, 1, 0);
5710 me->aliases[0] = "testsh";
5711 if (cpu_family_ptr_by_number(ARCH_SH) != NULL) {
5712 me->next = first_machine_entry; first_machine_entry = me;
5713 }
5714
5715 /* Test-machine for PPC: */
5716 me = machine_entry_new("Test-machine for PPC", ARCH_PPC,
5717 MACHINE_TESTPPC, 1, 0);
5718 me->aliases[0] = "testppc";
5719 if (cpu_family_ptr_by_number(ARCH_PPC) != NULL) {
5720 me->next = first_machine_entry; first_machine_entry = me;
5721 }
5722
5723 /* Test-machine for MIPS: */
5724 me = machine_entry_new("Test-machine for MIPS", ARCH_MIPS,
5725 MACHINE_TESTMIPS, 1, 0);
5726 me->aliases[0] = "testmips";
5727 if (cpu_family_ptr_by_number(ARCH_MIPS) != NULL) {
5728 me->next = first_machine_entry; first_machine_entry = me;
5729 }
5730
5731 /* Test-machine for M68K: */
5732 me = machine_entry_new("Test-machine for M68K", ARCH_M68K,
5733 MACHINE_TESTM68K, 1, 0);
5734 me->aliases[0] = "testm68k";
5735 if (cpu_family_ptr_by_number(ARCH_M68K) != NULL) {
5736 me->next = first_machine_entry; first_machine_entry = me;
5737 }
5738
5739 /* Test-machine for IA64: */
5740 me = machine_entry_new("Test-machine for IA64", ARCH_IA64,
5741 MACHINE_TESTIA64, 1, 0);
5742 me->aliases[0] = "testia64";
5743 if (cpu_family_ptr_by_number(ARCH_IA64) != NULL) {
5744 me->next = first_machine_entry; first_machine_entry = me;
5745 }
5746
5747 /* Test-machine for i960: */
5748 me = machine_entry_new("Test-machine for i960", ARCH_I960,
5749 MACHINE_TESTI960, 1, 0);
5750 me->aliases[0] = "testi960";
5751 if (cpu_family_ptr_by_number(ARCH_I960) != NULL) {
5752 me->next = first_machine_entry; first_machine_entry = me;
5753 }
5754
5755 /* Test-machine for HPPA: */
5756 me = machine_entry_new("Test-machine for HPPA", ARCH_HPPA,
5757 MACHINE_TESTHPPA, 1, 0);
5758 me->aliases[0] = "testhppa";
5759 if (cpu_family_ptr_by_number(ARCH_HPPA) != NULL) {
5760 me->next = first_machine_entry; first_machine_entry = me;
5761 }
5762
5763 /* Test-machine for ARM: */
5764 me = machine_entry_new("Test-machine for ARM", ARCH_ARM,
5765 MACHINE_TESTARM, 1, 0);
5766 me->aliases[0] = "testarm";
5767 if (cpu_family_ptr_by_number(ARCH_ARM) != NULL) {
5768 me->next = first_machine_entry; first_machine_entry = me;
5769 }
5770
5771 /* Test-machine for Alpha: */
5772 me = machine_entry_new("Test-machine for Alpha", ARCH_ALPHA,
5773 MACHINE_TESTALPHA, 1, 0);
5774 me->aliases[0] = "testalpha";
5775 if (cpu_family_ptr_by_number(ARCH_ALPHA) != NULL) {
5776 me->next = first_machine_entry; first_machine_entry = me;
5777 }
5778
5779 /* Sun Ultra1: */
5780 me = machine_entry_new("Sun Ultra1", ARCH_SPARC, MACHINE_ULTRA1, 1, 0);
5781 me->aliases[0] = "ultra1";
5782 if (cpu_family_ptr_by_number(ARCH_SPARC) != NULL) {
5783 me->next = first_machine_entry; first_machine_entry = me;
5784 }
5785
5786 /* Sony Playstation 2: */
5787 me = machine_entry_new("Sony Playstation 2", ARCH_MIPS,
5788 MACHINE_PS2, 2, 0);
5789 me->aliases[0] = "playstation2";
5790 me->aliases[1] = "ps2";
5791 if (cpu_family_ptr_by_number(ARCH_MIPS) != NULL) {
5792 me->next = first_machine_entry; first_machine_entry = me;
5793 }
5794
5795 /* Sony NeWS: */
5796 me = machine_entry_new("Sony NeWS", ARCH_MIPS,
5797 MACHINE_SONYNEWS, 2, 0);
5798 me->aliases[0] = "sonynews";
5799 me->aliases[1] = "news";
5800 if (cpu_family_ptr_by_number(ARCH_MIPS) != NULL) {
5801 me->next = first_machine_entry; first_machine_entry = me;
5802 }
5803
5804 /* SGI: */
5805 me = machine_entry_new("SGI", ARCH_MIPS, MACHINE_SGI, 2, 10);
5806 me->aliases[0] = "silicon graphics";
5807 me->aliases[1] = "sgi";
5808 me->subtype[0] = machine_entry_subtype_new("IP12", 12, 1);
5809 me->subtype[0]->aliases[0] = "ip12";
5810 me->subtype[1] = machine_entry_subtype_new("IP19", 19, 1);
5811 me->subtype[1]->aliases[0] = "ip19";
5812 me->subtype[2] = machine_entry_subtype_new("IP20", 20, 1);
5813 me->subtype[2]->aliases[0] = "ip20";
5814 me->subtype[3] = machine_entry_subtype_new("IP22", 22, 2);
5815 me->subtype[3]->aliases[0] = "ip22";
5816 me->subtype[3]->aliases[1] = "indy";
5817 me->subtype[4] = machine_entry_subtype_new("IP24", 24, 1);
5818 me->subtype[4]->aliases[0] = "ip24";
5819 me->subtype[5] = machine_entry_subtype_new("IP27", 27, 3);
5820 me->subtype[5]->aliases[0] = "ip27";
5821 me->subtype[5]->aliases[1] = "origin 200";
5822 me->subtype[5]->aliases[2] = "origin 2000";
5823 me->subtype[6] = machine_entry_subtype_new("IP28", 28, 1);
5824 me->subtype[6]->aliases[0] = "ip28";
5825 me->subtype[7] = machine_entry_subtype_new("IP30", 30, 2);
5826 me->subtype[7]->aliases[0] = "ip30";
5827 me->subtype[7]->aliases[1] = "octane";
5828 me->subtype[8] = machine_entry_subtype_new("IP32", 32, 2);
5829 me->subtype[8]->aliases[0] = "ip32";
5830 me->subtype[8]->aliases[1] = "o2";
5831 me->subtype[9] = machine_entry_subtype_new("IP35", 35, 1);
5832 me->subtype[9]->aliases[0] = "ip35";
5833 if (cpu_family_ptr_by_number(ARCH_MIPS) != NULL) {
5834 me->next = first_machine_entry; first_machine_entry = me;
5835 }
5836
5837 /* PReP: (NetBSD/prep etc.) */
5838 me = machine_entry_new("PowerPC Reference Platform", ARCH_PPC,
5839 MACHINE_PREP, 1, 0);
5840 me->aliases[0] = "prep";
5841 if (cpu_family_ptr_by_number(ARCH_PPC) != NULL) {
5842 me->next = first_machine_entry; first_machine_entry = me;
5843 }
5844
5845 /* Playstation Portable: */
5846 me = machine_entry_new("Playstation Portable", ARCH_MIPS,
5847 MACHINE_PSP, 1, 0);
5848 me->aliases[0] = "psp";
5849 if (cpu_family_ptr_by_number(ARCH_MIPS) != NULL) {
5850 me->next = first_machine_entry; first_machine_entry = me;
5851 }
5852
5853 /* NetWinder: */
5854 me = machine_entry_new("NetWinder", ARCH_ARM, MACHINE_NETWINDER, 1, 0);
5855 me->aliases[0] = "netwinder";
5856 if (cpu_family_ptr_by_number(ARCH_ARM) != NULL) {
5857 me->next = first_machine_entry; first_machine_entry = me;
5858 }
5859
5860 /* NetGear: */
5861 me = machine_entry_new("NetGear WG602v1", ARCH_MIPS,
5862 MACHINE_NETGEAR, 2, 0);
5863 me->aliases[0] = "netgear";
5864 me->aliases[1] = "wg602v1";
5865 if (cpu_family_ptr_by_number(ARCH_MIPS) != NULL) {
5866 me->next = first_machine_entry; first_machine_entry = me;
5867 }
5868
5869 /* Motorola Sandpoint: (NetBSD/sandpoint) */
5870 me = machine_entry_new("Motorola Sandpoint",
5871 ARCH_PPC, MACHINE_SANDPOINT, 1, 0);
5872 me->aliases[0] = "sandpoint";
5873 if (cpu_family_ptr_by_number(ARCH_PPC) != NULL) {
5874 me->next = first_machine_entry; first_machine_entry = me;
5875 }
5876
5877 /* Meshcube: */
5878 me = machine_entry_new("Meshcube", ARCH_MIPS, MACHINE_MESHCUBE, 1, 0);
5879 me->aliases[0] = "meshcube";
5880 if (cpu_family_ptr_by_number(ARCH_MIPS) != NULL) {
5881 me->next = first_machine_entry; first_machine_entry = me;
5882 }
5883
5884 /* Macintosh (PPC): */
5885 me = machine_entry_new("Macintosh (PPC)", ARCH_PPC,
5886 MACHINE_MACPPC, 1, 2);
5887 me->aliases[0] = "macppc";
5888 me->subtype[0] = machine_entry_subtype_new("MacPPC G4",
5889 MACHINE_MACPPC_G4, 1);
5890 me->subtype[0]->aliases[0] = "g4";
5891 me->subtype[1] = machine_entry_subtype_new("MacPPC G5",
5892 MACHINE_MACPPC_G5, 1);
5893 me->subtype[1]->aliases[0] = "g5";
5894 if (cpu_family_ptr_by_number(ARCH_PPC) != NULL) {
5895 me->next = first_machine_entry; first_machine_entry = me;
5896 }
5897
5898 /* Iyonix: */
5899 me = machine_entry_new("Iyonix", ARCH_ARM,
5900 MACHINE_IYONIX, 1, 0);
5901 me->aliases[0] = "iyonix";
5902 if (cpu_family_ptr_by_number(ARCH_ARM) != NULL) {
5903 me->next = first_machine_entry; first_machine_entry = me;
5904 }
5905
5906 /* Intel IQ80321 (ARM): */
5907 me = machine_entry_new("Intel IQ80321 (ARM)", ARCH_ARM,
5908 MACHINE_IQ80321, 1, 0);
5909 me->aliases[0] = "iq80321";
5910 if (cpu_family_ptr_by_number(ARCH_ARM) != NULL) {
5911 me->next = first_machine_entry; first_machine_entry = me;
5912 }
5913
5914 /* HPCarm: */
5915 me = machine_entry_new("Handheld SH (HPCsh)",
5916 ARCH_SH, MACHINE_HPCSH, 1, 2);
5917 me->aliases[0] = "hpcsh";
5918 me->subtype[0] = machine_entry_subtype_new("Jornada 680",
5919 MACHINE_HPCSH_JORNADA680, 1);
5920 me->subtype[0]->aliases[0] = "jornada680";
5921 me->subtype[1] = machine_entry_subtype_new(
5922 "Jornada 690", MACHINE_HPCSH_JORNADA690, 1);
5923 me->subtype[1]->aliases[0] = "jornada690";
5924 if (cpu_family_ptr_by_number(ARCH_SH) != NULL) {
5925 me->next = first_machine_entry; first_machine_entry = me;
5926 }
5927
5928 /* HPCmips: */
5929 me = machine_entry_new("Handheld MIPS (HPCmips)",
5930 ARCH_MIPS, MACHINE_HPCMIPS, 1, 8);
5931 me->aliases[0] = "hpcmips";
5932 me->subtype[0] = machine_entry_subtype_new(
5933 "Casio Cassiopeia BE-300", MACHINE_HPCMIPS_CASIO_BE300, 2);
5934 me->subtype[0]->aliases[0] = "be-300";
5935 me->subtype[0]->aliases[1] = "be300";
5936 me->subtype[1] = machine_entry_subtype_new(
5937 "Casio Cassiopeia E-105", MACHINE_HPCMIPS_CASIO_E105, 2);
5938 me->subtype[1]->aliases[0] = "e-105";
5939 me->subtype[1]->aliases[1] = "e105";
5940 me->subtype[2] = machine_entry_subtype_new(
5941 "Agenda VR3", MACHINE_HPCMIPS_AGENDA_VR3, 2);
5942 me->subtype[2]->aliases[0] = "agenda";
5943 me->subtype[2]->aliases[1] = "vr3";
5944 me->subtype[3] = machine_entry_subtype_new(
5945 "IBM WorkPad Z50", MACHINE_HPCMIPS_IBM_WORKPAD_Z50, 2);
5946 me->subtype[3]->aliases[0] = "workpad";
5947 me->subtype[3]->aliases[1] = "z50";
5948 me->subtype[4] = machine_entry_subtype_new(
5949 "NEC MobilePro 770", MACHINE_HPCMIPS_NEC_MOBILEPRO_770, 1);
5950 me->subtype[4]->aliases[0] = "mobilepro770";
5951 me->subtype[5] = machine_entry_subtype_new(
5952 "NEC MobilePro 780", MACHINE_HPCMIPS_NEC_MOBILEPRO_780, 1);
5953 me->subtype[5]->aliases[0] = "mobilepro780";
5954 me->subtype[6] = machine_entry_subtype_new(
5955 "NEC MobilePro 800", MACHINE_HPCMIPS_NEC_MOBILEPRO_800, 1);
5956 me->subtype[6]->aliases[0] = "mobilepro800";
5957 me->subtype[7] = machine_entry_subtype_new(
5958 "NEC MobilePro 880", MACHINE_HPCMIPS_NEC_MOBILEPRO_880, 1);
5959 me->subtype[7]->aliases[0] = "mobilepro880";
5960 if (cpu_family_ptr_by_number(ARCH_MIPS) != NULL) {
5961 me->next = first_machine_entry; first_machine_entry = me;
5962 }
5963
5964 /* HPCarm: */
5965 me = machine_entry_new("Handheld ARM (HPCarm)",
5966 ARCH_ARM, MACHINE_HPCARM, 1, 2);
5967 me->aliases[0] = "hpcarm";
5968 me->subtype[0] = machine_entry_subtype_new("Ipaq",
5969 MACHINE_HPCARM_IPAQ, 1);
5970 me->subtype[0]->aliases[0] = "ipaq";
5971 me->subtype[1] = machine_entry_subtype_new(
5972 "Jornada 720", MACHINE_HPCARM_JORNADA720, 1);
5973 me->subtype[1]->aliases[0] = "jornada720";
5974 if (cpu_family_ptr_by_number(ARCH_ARM) != NULL) {
5975 me->next = first_machine_entry; first_machine_entry = me;
5976 }
5977
5978 /* Generic "bare" X86 machine: */
5979 me = machine_entry_new("Generic \"bare\" X86 machine", ARCH_X86,
5980 MACHINE_BAREX86, 1, 0);
5981 me->aliases[0] = "barex86";
5982 if (cpu_family_ptr_by_number(ARCH_X86) != NULL) {
5983 me->next = first_machine_entry; first_machine_entry = me;
5984 }
5985
5986 /* Generic "bare" SPARC machine: */
5987 me = machine_entry_new("Generic \"bare\" SPARC machine", ARCH_SPARC,
5988 MACHINE_BARESPARC, 1, 0);
5989 me->aliases[0] = "baresparc";
5990 if (cpu_family_ptr_by_number(ARCH_SPARC) != NULL) {
5991 me->next = first_machine_entry; first_machine_entry = me;
5992 }
5993
5994 /* Generic "bare" SH machine: */
5995 me = machine_entry_new("Generic \"bare\" SH machine", ARCH_SH,
5996 MACHINE_BARESH, 1, 0);
5997 me->aliases[0] = "baresh";
5998 if (cpu_family_ptr_by_number(ARCH_SH) != NULL) {
5999 me->next = first_machine_entry; first_machine_entry = me;
6000 }
6001
6002 /* Generic "bare" PPC machine: */
6003 me = machine_entry_new("Generic \"bare\" PPC machine", ARCH_PPC,
6004 MACHINE_BAREPPC, 1, 0);
6005 me->aliases[0] = "bareppc";
6006 if (cpu_family_ptr_by_number(ARCH_PPC) != NULL) {
6007 me->next = first_machine_entry; first_machine_entry = me;
6008 }
6009
6010 /* Generic "bare" MIPS machine: */
6011 me = machine_entry_new("Generic \"bare\" MIPS machine", ARCH_MIPS,
6012 MACHINE_BAREMIPS, 1, 0);
6013 me->aliases[0] = "baremips";
6014 if (cpu_family_ptr_by_number(ARCH_MIPS) != NULL) {
6015 me->next = first_machine_entry; first_machine_entry = me;
6016 }
6017
6018 /* Generic "bare" M68K machine: */
6019 me = machine_entry_new("Generic \"bare\" M68K machine", ARCH_M68K,
6020 MACHINE_BAREM68K, 1, 0);
6021 me->aliases[0] = "barem68k";
6022 if (cpu_family_ptr_by_number(ARCH_M68K) != NULL) {
6023 me->next = first_machine_entry; first_machine_entry = me;
6024 }
6025
6026 /* Generic "bare" IA64 machine: */
6027 me = machine_entry_new("Generic \"bare\" IA64 machine", ARCH_IA64,
6028 MACHINE_BAREIA64, 1, 0);
6029 me->aliases[0] = "bareia64";
6030 if (cpu_family_ptr_by_number(ARCH_IA64) != NULL) {
6031 me->next = first_machine_entry; first_machine_entry = me;
6032 }
6033
6034 /* Generic "bare" i960 machine: */
6035 me = machine_entry_new("Generic \"bare\" i960 machine", ARCH_I960,
6036 MACHINE_BAREI960, 1, 0);
6037 me->aliases[0] = "barei960";
6038 if (cpu_family_ptr_by_number(ARCH_I960) != NULL) {
6039 me->next = first_machine_entry; first_machine_entry = me;
6040 }
6041
6042 /* Generic "bare" HPPA machine: */
6043 me = machine_entry_new("Generic \"bare\" HPPA machine", ARCH_HPPA,
6044 MACHINE_BAREHPPA, 1, 0);
6045 me->aliases[0] = "barehppa";
6046 if (cpu_family_ptr_by_number(ARCH_HPPA) != NULL) {
6047 me->next = first_machine_entry; first_machine_entry = me;
6048 }
6049
6050 /* Generic "bare" Atmel AVR machine: */
6051 me = machine_entry_new("Generic \"bare\" Atmel AVR machine", ARCH_AVR,
6052 MACHINE_BAREAVR, 1, 0);
6053 me->aliases[0] = "bareavr";
6054 if (cpu_family_ptr_by_number(ARCH_AVR) != NULL) {
6055 me->next = first_machine_entry; first_machine_entry = me;
6056 }
6057
6058 /* Generic "bare" ARM machine: */
6059 me = machine_entry_new("Generic \"bare\" ARM machine", ARCH_ARM,
6060 MACHINE_BAREARM, 1, 0);
6061 me->aliases[0] = "barearm";
6062 if (cpu_family_ptr_by_number(ARCH_ARM) != NULL) {
6063 me->next = first_machine_entry; first_machine_entry = me;
6064 }
6065
6066 /* Generic "bare" Alpha machine: */
6067 me = machine_entry_new("Generic \"bare\" Alpha machine", ARCH_ALPHA,
6068 MACHINE_BAREALPHA, 1, 0);
6069 me->aliases[0] = "barealpha";
6070 if (cpu_family_ptr_by_number(ARCH_ALPHA) != NULL) {
6071 me->next = first_machine_entry; first_machine_entry = me;
6072 }
6073
6074 /* Evaluation Boards (MALTA etc): */
6075 me = machine_entry_new("Evaluation boards (evbmips)", ARCH_MIPS,
6076 MACHINE_EVBMIPS, 1, 3);
6077 me->aliases[0] = "evbmips";
6078 me->subtype[0] = machine_entry_subtype_new("Malta",
6079 MACHINE_EVBMIPS_MALTA, 1);
6080 me->subtype[0]->aliases[0] = "malta";
6081 me->subtype[1] = machine_entry_subtype_new("Malta (Big-Endian)",
6082 MACHINE_EVBMIPS_MALTA_BE, 1);
6083 me->subtype[1]->aliases[0] = "maltabe";
6084 me->subtype[2] = machine_entry_subtype_new("PB1000",
6085 MACHINE_EVBMIPS_PB1000, 1);
6086 me->subtype[2]->aliases[0] = "pb1000";
6087 if (cpu_family_ptr_by_number(ARCH_MIPS) != NULL) {
6088 me->next = first_machine_entry; first_machine_entry = me;
6089 }
6090
6091 /* Digital DNARD ("Shark"): */
6092 me = machine_entry_new("Digital DNARD (\"Shark\")", ARCH_ARM,
6093 MACHINE_SHARK, 2, 0);
6094 me->aliases[0] = "shark";
6095 me->aliases[1] = "dnard";
6096 if (cpu_family_ptr_by_number(ARCH_ARM) != NULL) {
6097 me->next = first_machine_entry; first_machine_entry = me;
6098 }
6099
6100 /* DECstation: */
6101 me = machine_entry_new("DECstation/DECsystem",
6102 ARCH_MIPS, MACHINE_DEC, 3, 9);
6103 me->aliases[0] = "decstation";
6104 me->aliases[1] = "decsystem";
6105 me->aliases[2] = "dec";
6106 me->subtype[0] = machine_entry_subtype_new(
6107 "DECstation 3100 (PMAX)", MACHINE_DEC_PMAX_3100, 3);
6108 me->subtype[0]->aliases[0] = "pmax";
6109 me->subtype[0]->aliases[1] = "3100";
6110 me->subtype[0]->aliases[2] = "2100";
6111
6112 me->subtype[1] = machine_entry_subtype_new(
6113 "DECstation 5000/200 (3MAX)", MACHINE_DEC_3MAX_5000, 2);
6114 me->subtype[1]->aliases[0] = "3max";
6115 me->subtype[1]->aliases[1] = "5000/200";
6116
6117 me->subtype[2] = machine_entry_subtype_new(
6118 "DECstation 5000/1xx (3MIN)", MACHINE_DEC_3MIN_5000, 2);
6119 me->subtype[2]->aliases[0] = "3min";
6120 me->subtype[2]->aliases[1] = "5000/1xx";
6121
6122 me->subtype[3] = machine_entry_subtype_new(
6123 "DECstation 5000 (3MAXPLUS)", MACHINE_DEC_3MAXPLUS_5000, 2);
6124 me->subtype[3]->aliases[0] = "3maxplus";
6125 me->subtype[3]->aliases[1] = "3max+";
6126
6127 me->subtype[4] = machine_entry_subtype_new(
6128 "DECsystem 58x0", MACHINE_DEC_5800, 2);
6129 me->subtype[4]->aliases[0] = "5800";
6130 me->subtype[4]->aliases[1] = "58x0";
6131
6132 me->subtype[5] = machine_entry_subtype_new(
6133 "DECsystem 5400", MACHINE_DEC_5400, 1);
6134 me->subtype[5]->aliases[0] = "5400";
6135
6136 me->subtype[6] = machine_entry_subtype_new(
6137 "DECstation Maxine (5000)", MACHINE_DEC_MAXINE_5000, 1);
6138 me->subtype[6]->aliases[0] = "maxine";
6139
6140 me->subtype[7] = machine_entry_subtype_new(
6141 "DECsystem 5500", MACHINE_DEC_5500, 1);
6142 me->subtype[7]->aliases[0] = "5500";
6143
6144 me->subtype[8] = machine_entry_subtype_new(
6145 "DECstation MipsMate (5100)", MACHINE_DEC_MIPSMATE_5100, 2);
6146 me->subtype[8]->aliases[0] = "5100";
6147 me->subtype[8]->aliases[1] = "mipsmate";
6148
6149 if (cpu_family_ptr_by_number(ARCH_MIPS) != NULL) {
6150 me->next = first_machine_entry; first_machine_entry = me;
6151 }
6152
6153 /* DB64360: (for playing with PMON for PPC) */
6154 me = machine_entry_new("DB64360", ARCH_PPC, MACHINE_DB64360, 1, 0);
6155 me->aliases[0] = "db64360";
6156 if (cpu_family_ptr_by_number(ARCH_PPC) != NULL) {
6157 me->next = first_machine_entry; first_machine_entry = me;
6158 }
6159
6160 /* Cobalt: */
6161 me = machine_entry_new("Cobalt", ARCH_MIPS, MACHINE_COBALT, 1, 0);
6162 me->aliases[0] = "cobalt";
6163 if (cpu_family_ptr_by_number(ARCH_MIPS) != NULL) {
6164 me->next = first_machine_entry; first_machine_entry = me;
6165 }
6166
6167 /* CATS (ARM) evaluation board: */
6168 me = machine_entry_new("CATS evaluation board (ARM)", ARCH_ARM,
6169 MACHINE_CATS, 1, 0);
6170 me->aliases[0] = "cats";
6171 if (cpu_family_ptr_by_number(ARCH_ARM) != NULL) {
6172 me->next = first_machine_entry; first_machine_entry = me;
6173 }
6174
6175 /* BeBox: (NetBSD/bebox) */
6176 me = machine_entry_new("BeBox", ARCH_PPC, MACHINE_BEBOX, 1, 0);
6177 me->aliases[0] = "bebox";
6178 if (cpu_family_ptr_by_number(ARCH_PPC) != NULL) {
6179 me->next = first_machine_entry; first_machine_entry = me;
6180 }
6181
6182 /* Artesyn's PM/PPC board: (NetBSD/pmppc) */
6183 me = machine_entry_new("Artesyn's PM/PPC board", ARCH_PPC,
6184 MACHINE_PMPPC, 1, 0);
6185 me->aliases[0] = "pmppc";
6186 if (cpu_family_ptr_by_number(ARCH_PPC) != NULL) {
6187 me->next = first_machine_entry; first_machine_entry = me;
6188 }
6189
6190 /* ARC: */
6191 me = machine_entry_new("ARC", ARCH_MIPS, MACHINE_ARC, 1, 8);
6192 me->aliases[0] = "arc";
6193
6194 me->subtype[0] = machine_entry_subtype_new(
6195 "Acer PICA-61", MACHINE_ARC_JAZZ_PICA, 3);
6196 me->subtype[0]->aliases[0] = "pica-61";
6197 me->subtype[0]->aliases[1] = "acer pica";
6198 me->subtype[0]->aliases[2] = "pica";
6199
6200 me->subtype[1] = machine_entry_subtype_new(
6201 "Deskstation Tyne", MACHINE_ARC_DESKTECH_TYNE, 3);
6202 me->subtype[1]->aliases[0] = "deskstation tyne";
6203 me->subtype[1]->aliases[1] = "desktech";
6204 me->subtype[1]->aliases[2] = "tyne";
6205
6206 me->subtype[2] = machine_entry_subtype_new(
6207 "Jazz Magnum", MACHINE_ARC_JAZZ_MAGNUM, 2);
6208 me->subtype[2]->aliases[0] = "magnum";
6209 me->subtype[2]->aliases[1] = "jazz magnum";
6210
6211 me->subtype[3] = machine_entry_subtype_new(
6212 "NEC-R94", MACHINE_ARC_NEC_R94, 2);
6213 me->subtype[3]->aliases[0] = "nec-r94";
6214 me->subtype[3]->aliases[1] = "r94";
6215
6216 me->subtype[4] = machine_entry_subtype_new(
6217 "NEC-RD94", MACHINE_ARC_NEC_RD94, 2);
6218 me->subtype[4]->aliases[0] = "nec-rd94";
6219 me->subtype[4]->aliases[1] = "rd94";
6220
6221 me->subtype[5] = machine_entry_subtype_new(
6222 "NEC-R96", MACHINE_ARC_NEC_R96, 2);
6223 me->subtype[5]->aliases[0] = "nec-r96";
6224 me->subtype[5]->aliases[1] = "r96";
6225
6226 me->subtype[6] = machine_entry_subtype_new(
6227 "NEC-R98", MACHINE_ARC_NEC_R98, 2);
6228 me->subtype[6]->aliases[0] = "nec-r98";
6229 me->subtype[6]->aliases[1] = "r98";
6230
6231 me->subtype[7] = machine_entry_subtype_new(
6232 "Olivetti M700", MACHINE_ARC_JAZZ_M700, 2);
6233 me->subtype[7]->aliases[0] = "olivetti";
6234 me->subtype[7]->aliases[1] = "m700";
6235
6236 if (cpu_family_ptr_by_number(ARCH_MIPS) != NULL) {
6237 me->next = first_machine_entry; first_machine_entry = me;
6238 }
6239
6240 /* Alpha: */
6241 me = machine_entry_new("Alpha", ARCH_ALPHA, MACHINE_ALPHA, 1, 2);
6242 me->aliases[0] = "alpha";
6243 me->subtype[0] = machine_entry_subtype_new(
6244 "DEC 3000/300", ST_DEC_3000_300, 1);
6245 me->subtype[0]->aliases[0] = "3000/300";
6246 me->subtype[1] = machine_entry_subtype_new(
6247 "EB164", ST_EB164, 1);
6248 me->subtype[1]->aliases[0] = "eb164";
6249 if (cpu_family_ptr_by_number(ARCH_ALPHA) != NULL) {
6250 me->next = first_machine_entry; first_machine_entry = me;
6251 }
6252 }
6253
  ViewVC Help
Powered by ViewVC 1.1.26