![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ohw.diff CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / pc-bios|
Return to ohw.diff CVS log | Up to [Qemu by Fabrice Bellard] / qemu / pc-bios |
1.1 root 1: diff -wruN --exclude '*~' --exclude '*.o' --exclude '*.bin' --exclude '*.out' --exclude mkdiff OpenHackWare-release-0.4.org/src/bios.h OpenHackWare-release-0.4/src/bios.h
2: --- OpenHackWare-release-0.4.org/src/bios.h 2005-04-06 23:20:22.000000000 +0200
3: +++ OpenHackWare-release-0.4/src/bios.h 2005-07-07 01:10:20.000000000 +0200
4: @@ -64,6 +64,7 @@
5: ARCH_CHRP,
6: ARCH_MAC99,
7: ARCH_POP,
8: + ARCH_HEATHROW,
9: };
10:
11: /* Hardware definition(s) */
12: @@ -174,6 +175,7 @@
13: int bd_ioctl (bloc_device_t *bd, int func, void *args);
14: uint32_t bd_seclen (bloc_device_t *bd);
15: void bd_close (bloc_device_t *bd);
16: +void bd_reset_all(void);
17: uint32_t bd_seclen (bloc_device_t *bd);
18: uint32_t bd_maxbloc (bloc_device_t *bd);
19: void bd_sect2CHS (bloc_device_t *bd, uint32_t secnum,
20: @@ -183,12 +185,12 @@
21: part_t *bd_probe (int boot_device);
22: bloc_device_t *bd_get (int device);
23: void bd_put (bloc_device_t *bd);
24: -void bd_set_boot_part (bloc_device_t *bd, part_t *partition);
25: +void bd_set_boot_part (bloc_device_t *bd, part_t *partition, int partnum);
26: part_t **_bd_parts (bloc_device_t *bd);
27:
28: void ide_pci_pc_register (uint32_t io_base0, uint32_t io_base1,
29: uint32_t io_base2, uint32_t io_base3,
30: - void *OF_private);
31: + void *OF_private0, void *OF_private1);
32: void ide_pci_pmac_register (uint32_t io_base0, uint32_t io_base1,
33: void *OF_private);
34:
35: @@ -399,17 +401,23 @@
36: uint16_t min_grant, uint16_t max_latency);
37: void OF_finalize_pci_host (void *dev, int first_bus, int nb_busses);
38: void OF_finalize_pci_device (void *dev, uint8_t bus, uint8_t devfn,
39: - uint32_t *regions, uint32_t *sizes);
40: + uint32_t *regions, uint32_t *sizes,
41: + int irq_line);
42: void OF_finalize_pci_macio (void *dev, uint32_t base_address, uint32_t size,
43: void *private_data);
44: +void OF_finalize_pci_ide (void *dev,
45: + uint32_t io_base0, uint32_t io_base1,
46: + uint32_t io_base2, uint32_t io_base3);
47: int OF_register_bus (const unsigned char *name, uint32_t address,
48: const unsigned char *type);
49: int OF_register_serial (const unsigned char *bus, const unsigned char *name,
50: uint32_t io_base, int irq);
51: int OF_register_stdio (const unsigned char *dev_in,
52: const unsigned char *dev_out);
53: -void OF_vga_register (const unsigned char *name, uint32_t address,
54: - int width, int height, int depth);
55: +void OF_vga_register (const unsigned char *name, unused uint32_t address,
56: + int width, int height, int depth,
57: + unsigned long vga_bios_addr,
58: + unsigned long vga_bios_size);
59: void *OF_blockdev_register (void *parent, void *private,
60: const unsigned char *type,
61: const unsigned char *name, int devnum,
62: diff -wruN --exclude '*~' --exclude '*.o' --exclude '*.bin' --exclude '*.out' --exclude mkdiff OpenHackWare-release-0.4.org/src/bloc.c OpenHackWare-release-0.4/src/bloc.c
63: --- OpenHackWare-release-0.4.org/src/bloc.c 2005-04-06 23:21:00.000000000 +0200
64: +++ OpenHackWare-release-0.4/src/bloc.c 2005-07-08 00:28:26.000000000 +0200
65: @@ -55,6 +55,7 @@
66: /* Partitions */
67: part_t *parts, *bparts;
68: part_t *boot_part;
69: + int bpartnum;
70: /* Chain */
71: bloc_device_t *next;
72: };
73: @@ -66,6 +67,7 @@
74:
75: static int ide_initialize (bloc_device_t *bd, int device);
76: static int ide_read_sector (bloc_device_t *bd, void *buffer, int secnum);
77: +static int ide_reset (bloc_device_t *bd);
78:
79: static int mem_initialize (bloc_device_t *bd, int device);
80: static int mem_read_sector (bloc_device_t *bd, void *buffer, int secnum);
81: @@ -212,6 +214,17 @@
82: {
83: }
84:
85: +void bd_reset_all(void)
86: +{
87: + bloc_device_t *bd;
88: + for (bd = bd_list; bd != NULL; bd = bd->next) {
89: + if (bd->init == &ide_initialize) {
90: + /* reset IDE drive because Darwin wants all IDE devices to be reset */
91: + ide_reset(bd);
92: + }
93: + }
94: +}
95: +
96: uint32_t bd_seclen (bloc_device_t *bd)
97: {
98: return bd->seclen;
99: @@ -223,10 +236,12 @@
100: }
101:
102: /* XXX: to be suppressed */
103: -void bd_set_boot_part (bloc_device_t *bd, part_t *partition)
104: +void bd_set_boot_part (bloc_device_t *bd, part_t *partition, int partnum)
105: {
106: + dprintf("%s: part %p (%p) %d\n", __func__, partition, bd->boot_part, partnum);
107: if (bd->boot_part == NULL) {
108: bd->boot_part = partition;
109: + bd->bpartnum = partnum;
110: }
111: }
112:
113: @@ -240,6 +255,13 @@
114: return &bd->bparts;
115: }
116:
117: +void bd_set_boot_device (bloc_device_t *bd)
118: +{
119: +#if defined (USE_OPENFIRMWARE)
120: + OF_blockdev_set_boot_device(bd->OF_private, bd->bpartnum, "\\\\ofwboot");
121: +#endif
122: +}
123: +
124: part_t *bd_probe (int boot_device)
125: {
126: char devices[] = { /*'a', 'b',*/ 'c', 'd', 'e', 'f', 'm', '\0', };
127: @@ -272,9 +294,7 @@
128: tmp = part_probe(bd, force_raw);
129: if (boot_device == bd->device) {
130: boot_part = tmp;
131: -#if defined (USE_OPENFIRMWARE)
132: - OF_blockdev_set_boot_device(bd->OF_private, 2, "\\\\ofwboot");
133: -#endif
134: + bd_set_boot_device(bd);
135: }
136: }
137:
138: @@ -717,34 +737,29 @@
139: /* IDE PCI access for pc */
140: static uint8_t ide_pci_port_read (bloc_device_t *bd, int port)
141: {
142: - eieio();
143: -
144: - return *(uint8_t *)(bd->io_base + port);
145: + uint8_t value;
146: + value = inb(bd->io_base + port);
147: + return value;
148: }
149:
150: static void ide_pci_port_write (bloc_device_t *bd, int port, uint8_t value)
151: {
152: - *(uint8_t *)(bd->io_base + port) = value;
153: - eieio();
154: + outb(bd->io_base + port, value);
155: }
156:
157: static uint32_t ide_pci_data_readl (bloc_device_t *bd)
158: {
159: - eieio();
160: -
161: - return *((uint32_t *)bd->io_base);
162: + return inl(bd->io_base);
163: }
164:
165: static void ide_pci_data_writel (bloc_device_t *bd, uint32_t val)
166: {
167: - *(uint32_t *)(bd->io_base) = val;
168: - eieio();
169: + outl(bd->io_base, val);
170: }
171:
172: static void ide_pci_control_write (bloc_device_t *bd, uint32_t val)
173: {
174: - *((uint8_t *)bd->tmp) = val;
175: - eieio();
176: + outb(bd->tmp + 2, val);
177: }
178:
179: static ide_ops_t ide_pci_pc_ops = {
180: @@ -761,7 +776,7 @@
181:
182: void ide_pci_pc_register (uint32_t io_base0, uint32_t io_base1,
183: uint32_t io_base2, uint32_t io_base3,
184: - unused void *OF_private)
185: + void *OF_private0, void *OF_private1)
186: {
187: if (ide_pci_ops == NULL) {
188: ide_pci_ops = malloc(sizeof(ide_ops_t));
189: @@ -770,19 +785,19 @@
190: memcpy(ide_pci_ops, &ide_pci_pc_ops, sizeof(ide_ops_t));
191: }
192: if ((io_base0 != 0 || io_base1 != 0) &&
193: - ide_pci_ops->base[0] == 0 && ide_pci_ops->base[1] == 0) {
194: + ide_pci_ops->base[0] == 0 && ide_pci_ops->base[2] == 0) {
195: ide_pci_ops->base[0] = io_base0;
196: - ide_pci_ops->base[1] = io_base1;
197: + ide_pci_ops->base[2] = io_base1;
198: #ifdef USE_OPENFIRMWARE
199: - ide_pci_ops->OF_private[0] = OF_private;
200: + ide_pci_ops->OF_private[0] = OF_private0;
201: #endif
202: }
203: if ((io_base2 != 0 || io_base3 != 0) &&
204: - ide_pci_ops->base[2] == 0 && ide_pci_ops->base[3] == 0) {
205: - ide_pci_ops->base[2] = io_base2;
206: + ide_pci_ops->base[1] == 0 && ide_pci_ops->base[3] == 0) {
207: + ide_pci_ops->base[1] = io_base2;
208: ide_pci_ops->base[3] = io_base3;
209: #ifdef USE_OPENFIRMWARE
210: - ide_pci_ops->OF_private[1] = OF_private;
211: + ide_pci_ops->OF_private[1] = OF_private1;
212: #endif
213: }
214: }
215: @@ -935,6 +950,8 @@
216: }
217:
218: static void atapi_pad_req (void *buffer, int len);
219: +static void atapi_make_req (bloc_device_t *bd, uint32_t *buffer,
220: + int maxlen);
221: static int atapi_read_sector (bloc_device_t *bd, void *buffer, int secnum);
222:
223: static int ide_initialize (bloc_device_t *bd, int device)
224: @@ -1035,9 +1052,7 @@
225: DPRINTF("INQUIRY\n");
226: len = spc_inquiry_req(&atapi_buffer, 36);
227: atapi_pad_req(&atapi_buffer, len);
228: - ide_port_write(bd, 0x07, 0xA0);
229: - for (i = 0; i < 3; i++)
230: - ide_data_writel(bd, ldswap32(&atapi_buffer[i]));
231: + atapi_make_req(bd, atapi_buffer, 36);
232: status = ide_port_read(bd, 0x07);
233: if (status != 0x48) {
234: ERROR("ATAPI INQUIRY : status %0x != 0x48\n", status);
235: @@ -1053,9 +1068,7 @@
236: DPRINTF("READ_CAPACITY\n");
237: len = mmc_read_capacity_req(&atapi_buffer);
238: atapi_pad_req(&atapi_buffer, len);
239: - ide_port_write(bd, 0x07, 0xA0);
240: - for (i = 0; i < 3; i++)
241: - ide_data_writel(bd, ldswap32(&atapi_buffer[i]));
242: + atapi_make_req(bd, atapi_buffer, 8);
243: status = ide_port_read(bd, 0x07);
244: if (status != 0x48) {
245: ERROR("ATAPI READ_CAPACITY : status %0x != 0x48\n", status);
246: @@ -1105,6 +1118,22 @@
247: memset(p + len, 0, 12 - len);
248: }
249:
250: +static void atapi_make_req (bloc_device_t *bd, uint32_t *buffer,
251: + int maxlen)
252: +{
253: + int i;
254: + /* select drive */
255: + if (bd->drv == 0)
256: + ide_port_write(bd, 0x06, 0x40);
257: + else
258: + ide_port_write(bd, 0x06, 0x50);
259: + ide_port_write(bd, 0x04, maxlen & 0xff);
260: + ide_port_write(bd, 0x05, (maxlen >> 8) & 0xff);
261: + ide_port_write(bd, 0x07, 0xA0);
262: + for (i = 0; i < 3; i++)
263: + ide_data_writel(bd, ldswap32(&buffer[i]));
264: +}
265: +
266: static int atapi_read_sector (bloc_device_t *bd, void *buffer, int secnum)
267: {
268: uint32_t atapi_buffer[4];
269: @@ -1112,16 +1141,9 @@
270: uint32_t status, value;
271: int i, len;
272:
273: - /* select drive */
274: - if (bd->drv == 0)
275: - ide_port_write(bd, 0x06, 0x40);
276: - else
277: - ide_port_write(bd, 0x06, 0x50);
278: len = mmc_read12_req(atapi_buffer, secnum, 1);
279: atapi_pad_req(&atapi_buffer, len);
280: - ide_port_write(bd, 0x07, 0xA0);
281: - for (i = 0; i < 3; i++)
282: - ide_data_writel(bd, ldswap32(&atapi_buffer[i]));
283: + atapi_make_req(bd, atapi_buffer, bd->seclen);
284: status = ide_port_read(bd, 0x07);
285: if (status != 0x48) {
286: ERROR("ATAPI READ12 : status %0x != 0x48\n", status);
287: diff -wruN --exclude '*~' --exclude '*.o' --exclude '*.bin' --exclude '*.out' --exclude mkdiff OpenHackWare-release-0.4.org/src/libpart/apple.c OpenHackWare-release-0.4/src/libpart/apple.c
288: --- OpenHackWare-release-0.4.org/src/libpart/apple.c 2005-03-31 09:23:33.000000000 +0200
289: +++ OpenHackWare-release-0.4/src/libpart/apple.c 2005-07-03 16:17:41.000000000 +0200
290: @@ -199,14 +199,18 @@
291: if (len == 0) {
292: /* Place holder. Skip it */
293: DPRINTF("%s placeholder part\t%d\n", __func__, i);
294: + part->flags = PART_TYPE_APPLE | PART_FLAG_DUMMY;
295: + part_register(bd, part, name, i);
296: } else if (strncmp("Apple_Void", type, 32) == 0) {
297: /* Void partition. Skip it */
298: DPRINTF("%s Void part\t%d [%s]\n", __func__, i, type);
299: + part->flags = PART_TYPE_APPLE | PART_FLAG_DUMMY;
300: + part_register(bd, part, name, i);
301: } else if (strncmp("Apple_Free", type, 32) == 0) {
302: /* Free space. Skip it */
303: DPRINTF("%s Free part (%d)\n", __func__, i);
304: part->flags = PART_TYPE_APPLE | PART_FLAG_DUMMY;
305: - part_register(bd, part, name);
306: + part_register(bd, part, name, i);
307: } else if (strncmp("Apple_partition_map", type, 32) == 0 ||
308: strncmp("Apple_Partition_Map", type, 32) == 0
309: #if 0 // Is this really used or is it just a mistake ?
310: @@ -226,7 +230,7 @@
311: */
312: }
313: part->flags = PART_TYPE_APPLE | PART_FLAG_DUMMY;
314: - part_register(bd, part, name);
315: + part_register(bd, part, name, i);
316: } else if (strncmp("Apple_Driver", type, 32) == 0 ||
317: strncmp("Apple_Driver43", type, 32) == 0 ||
318: strncmp("Apple_Driver43_CD", type, 32) == 0 ||
319: @@ -236,8 +240,12 @@
320: strncmp("Apple_Driver_IOKit", type, 32) == 0) {
321: /* Drivers. don't care for now */
322: DPRINTF("%s Drivers part\t%d [%s]\n", __func__, i, type);
323: + part->flags = PART_TYPE_APPLE | PART_FLAG_DRIVER;
324: + part_register(bd, part, name, i);
325: } else if (strncmp("Apple_Patches", type, 32) == 0) {
326: /* Patches: don't care for now */
327: + part->flags = PART_TYPE_APPLE | PART_FLAG_PATCH;
328: + part_register(bd, part, name, i);
329: DPRINTF("%s Patches part\t%d [%s]\n", __func__, i, type);
330: } else if (strncmp("Apple_HFS", type, 32) == 0 ||
331: strncmp("Apple_MFS", type, 32) == 0 ||
332: @@ -256,9 +264,8 @@
333: count = partmap->bloc_cnt * HFS_BLOCSIZE;
334: if (partmap->boot_size == 0 || partmap->boot_load == 0) {
335: printf("Not a bootable partition %d %d (%p %p)\n",
336: - partmap->boot_size, partmap->boot_load,boot_part, part);
337: - if (boot_part == NULL)
338: - boot_part = part;
339: + partmap->boot_size, partmap->boot_load,
340: + boot_part, part);
341: part->flags = PART_TYPE_APPLE | PART_FLAG_FS;
342: } else {
343: part->boot_start.bloc = partmap->boot_start;
344: @@ -278,8 +285,8 @@
345: boot_part = part;
346: part->flags = PART_TYPE_APPLE | PART_FLAG_FS | PART_FLAG_BOOT;
347: }
348: - printf("Partition: %d %s st %0x size %0x",
349: - i, name, partmap->start_bloc, partmap->bloc_cnt);
350: + printf("Partition: %d '%s' '%s' st %0x size %0x",
351: + i, name, type, partmap->start_bloc, partmap->bloc_cnt);
352: #ifndef DEBUG
353: printf("\n");
354: #endif
355: @@ -290,11 +297,13 @@
356: part->boot_load, part->boot_entry);
357: DPRINTF(" load %0x entry %0x %0x\n",
358: partmap->boot_load2, partmap->boot_entry2, HFS_BLOCSIZE);
359: - part_register(bd, part, name);
360: + part_register(bd, part, name, i);
361: } else {
362: memcpy(tmp, type, 32);
363: tmp[32] = '\0';
364: ERROR("Unknown partition type [%s]\n", tmp);
365: + part->flags = PART_TYPE_APPLE | PART_FLAG_DUMMY;
366: + part_register(bd, part, name, i);
367: }
368: }
369: error:
370: diff -wruN --exclude '*~' --exclude '*.o' --exclude '*.bin' --exclude '*.out' --exclude mkdiff OpenHackWare-release-0.4.org/src/libpart/core.c OpenHackWare-release-0.4/src/libpart/core.c
371: --- OpenHackWare-release-0.4.org/src/libpart/core.c 2005-03-31 09:23:33.000000000 +0200
372: +++ OpenHackWare-release-0.4/src/libpart/core.c 2005-07-03 16:17:41.000000000 +0200
373: @@ -126,7 +126,7 @@
374: }
375:
376: int part_register (bloc_device_t *bd, part_t *partition,
377: - const unsigned char *name)
378: + const unsigned char *name, int partnum)
379: {
380: part_t **cur;
381:
382: @@ -134,6 +134,7 @@
383: partition->bd = bd;
384: partition->next = NULL;
385: partition->name = strdup(name);
386: + partition->partnum = partnum;
387: for (cur = _bd_parts(bd); *cur != NULL; cur = &(*cur)->next)
388: continue;
389: *cur = partition;
390: @@ -141,29 +142,15 @@
391: return 0;
392: }
393:
394: -static inline int set_boot_part (bloc_device_t *bd, int partnum)
395: -{
396: - part_t *cur;
397: -
398: - cur = part_get(bd, partnum);
399: - if (cur == NULL)
400: - return -1;
401: - bd_set_boot_part(bd, cur);
402: -
403: - return 0;
404: -}
405: -
406: part_t *part_get (bloc_device_t *bd, int partnum)
407: {
408: part_t **listp, *cur;
409: - int i;
410:
411: listp = _bd_parts(bd);
412: - cur = *listp;
413: - for (i = 0; i != partnum; i++) {
414: - if (cur == NULL)
415: +
416: + for (cur = *listp; cur != NULL; cur = cur->next) {
417: + if (cur->partnum == partnum)
418: break;
419: - cur = cur->next;
420: }
421:
422: return cur;
423: @@ -192,17 +179,20 @@
424: part_set_blocsize(bd, part, 512);
425: part->bd = bd;
426: part->flags = PART_TYPE_RAW | PART_FLAG_BOOT;
427: - part_register(bd, part, "Raw");
428: + part_register(bd, part, "Raw", 0);
429:
430: return part;
431: }
432:
433: +bloc_device_t *part_get_bd (part_t *part)
434: +{
435: + return part->bd;
436: +}
437: +
438: part_t *part_probe (bloc_device_t *bd, int set_raw)
439: {
440: - part_t *part0, *boot_part, **cur;
441: + part_t *part0 = NULL, *boot_part, **cur;
442:
443: - /* Register the 0 partition: raw partition containing the whole disk */
444: - part0 = part_get_raw(bd);
445: /* Try to find a valid boot partition */
446: boot_part = Apple_probe_partitions(bd);
447: if (boot_part == NULL) {
448: @@ -210,10 +200,13 @@
449: if (boot_part == NULL && arch == ARCH_PREP)
450: boot_part = PREP_find_partition(bd);
451: if (boot_part == NULL && set_raw != 0) {
452: - boot_part = part0;
453: - set_boot_part(bd, 0);
454: + dprintf("Use bloc device as raw partition\n");
455: }
456: }
457: + if (_bd_parts(bd) == NULL) {
458: + /* Register the 0 partition: raw partition containing the whole disk */
459: + part0 = part_get_raw(bd);
460: + }
461: /* Probe filesystem on each found partition */
462: for (cur = _bd_parts(bd); *cur != NULL; cur = &(*cur)->next) {
463: const unsigned char *map, *type;
464: @@ -248,23 +241,28 @@
465: type = "unknown";
466: break;
467: }
468: - DPRINTF("Probe filesystem on %s %s partition '%s' %s\n",
469: + dprintf("Probe filesystem on %s %s partition '%s' %s %p\n",
470: type, map, (*cur)->name,
471: - ((*cur)->flags) & PART_FLAG_BOOT ? "(bootable)" : "");
472: + ((*cur)->flags) & PART_FLAG_BOOT ? "(bootable)" : "", *cur);
473: if (((*cur)->flags) & PART_FLAG_FS) {
474: if (((*cur)->flags) & PART_FLAG_BOOT)
475: (*cur)->fs = fs_probe(*cur, 1);
476: else
477: (*cur)->fs = fs_probe(*cur, 0);
478: + } else if (((*cur)->flags) & PART_TYPE_RAW) {
479: + (*cur)->fs = fs_probe(*cur, 2);
480: } else {
481: (*cur)->fs = fs_probe(*cur, 2);
482: }
483: - if (((*cur)->flags) & PART_FLAG_BOOT) {
484: - bd_set_boot_part(bd, *cur);
485: fs_get_bootfile((*cur)->fs);
486: + if (((*cur)->flags) & PART_FLAG_BOOT) {
487: + dprintf("Partition is bootable (%d)\n", (*cur)->partnum);
488: + bd_set_boot_part(bd, *cur, (*cur)->partnum);
489: + if (boot_part == NULL)
490: + boot_part = *cur;
491: }
492: }
493: - DPRINTF("Boot partition: %p %p %p %p\n", boot_part, boot_part->fs,
494: + dprintf("Boot partition: %p %p %p %p\n", boot_part, boot_part->fs,
495: part_fs(boot_part), part0);
496:
497: return boot_part;
498: @@ -279,6 +277,7 @@
499: part->boot_size.offset = 0;
500: part->boot_load = 0;
501: part->boot_entry = 0;
502: + part->flags |= PART_FLAG_BOOT;
503:
504: return 0;
505: }
506: diff -wruN --exclude '*~' --exclude '*.o' --exclude '*.bin' --exclude '*.out' --exclude mkdiff OpenHackWare-release-0.4.org/src/libpart/isofs.c OpenHackWare-release-0.4/src/libpart/isofs.c
507: --- OpenHackWare-release-0.4.org/src/libpart/isofs.c 2005-03-31 09:23:33.000000000 +0200
508: +++ OpenHackWare-release-0.4/src/libpart/isofs.c 2005-07-03 16:17:41.000000000 +0200
509: @@ -242,7 +242,7 @@
510: part->boot_start.bloc, part->boot_size.bloc,
511: part->boot_load, part->boot_entry);
512: part->flags = PART_TYPE_ISO9660 | PART_FLAG_BOOT;
513: - part_register(bd, part, name);
514: + part_register(bd, part, name, i + 1);
515: fs_raw_set_bootfile(part, part->boot_start.bloc,
516: part->boot_start.offset,
517: part->boot_size.bloc,
518: diff -wruN --exclude '*~' --exclude '*.o' --exclude '*.bin' --exclude '*.out' --exclude mkdiff OpenHackWare-release-0.4.org/src/libpart/libpart.h OpenHackWare-release-0.4/src/libpart/libpart.h
519: --- OpenHackWare-release-0.4.org/src/libpart/libpart.h 2005-03-31 09:23:33.000000000 +0200
520: +++ OpenHackWare-release-0.4/src/libpart/libpart.h 2005-07-03 16:17:41.000000000 +0200
521: @@ -30,6 +30,7 @@
522:
523: struct part_t {
524: bloc_device_t *bd;
525: + int partnum;
526: uint32_t start; /* Partition first bloc */
527: uint32_t size; /* Partition size, in blocs */
528: uint32_t spb;
529: @@ -54,7 +55,7 @@
530: };
531:
532: int part_register (bloc_device_t *bd, part_t *partition,
533: - const unsigned char *name);
534: + const unsigned char *name, int partnum);
535: void part_set_blocsize (bloc_device_t *bd, part_t *part, uint32_t blocsize);
536: void part_private_set (part_t *part, void *private);
537: void *part_private_get (part_t *part);
538: diff -wruN --exclude '*~' --exclude '*.o' --exclude '*.bin' --exclude '*.out' --exclude mkdiff OpenHackWare-release-0.4.org/src/libpart/prep.c OpenHackWare-release-0.4/src/libpart/prep.c
539: --- OpenHackWare-release-0.4.org/src/libpart/prep.c 2005-03-31 09:23:33.000000000 +0200
540: +++ OpenHackWare-release-0.4/src/libpart/prep.c 2005-07-03 16:17:41.000000000 +0200
541: @@ -164,7 +164,7 @@
542: part->boot_load = 0;
543: part->boot_entry = boot_offset - part->bloc_size;
544: part->flags = PART_TYPE_PREP | PART_FLAG_BOOT;
545: - part_register(bd, part, "PREP boot");
546: + part_register(bd, part, "PREP boot", i);
547: fs_raw_set_bootfile(part, part->boot_start.bloc,
548: part->boot_start.offset,
549: part->boot_size.bloc,
550: diff -wruN --exclude '*~' --exclude '*.o' --exclude '*.bin' --exclude '*.out' --exclude mkdiff OpenHackWare-release-0.4.org/src/main.c OpenHackWare-release-0.4/src/main.c
551: --- OpenHackWare-release-0.4.org/src/main.c 2005-03-31 09:23:33.000000000 +0200
552: +++ OpenHackWare-release-0.4/src/main.c 2005-06-07 23:48:39.000000000 +0200
553: @@ -364,20 +364,24 @@
554: void *load_base, *load_entry, *last_alloc, *load_end;
555: uint32_t memsize, boot_image_size, cmdline_size, ramdisk_size;
556: uint32_t boot_base, boot_nb;
557: - int boot_device;
558: + int boot_device, i;
559: + static const uint32_t isa_base_tab[3] = {
560: + 0x80000000, /* PREP */
561: + 0xFE000000, /* Grackle (Heathrow) */
562: + 0xF2000000, /* UniNorth (Mac99) */
563: + };
564:
565: /* Retrieve NVRAM configuration */
566: - nvram_retry:
567: + for(i = 0; i < 3; i++) {
568: + isa_io_base = isa_base_tab[i];
569: nvram = NVRAM_get_config(&memsize, &boot_device,
570: &boot_image, &boot_image_size,
571: &cmdline, &cmdline_size,
572: &ramdisk, &ramdisk_size);
573: - if (nvram == NULL) {
574: - /* Retry with another isa_io_base */
575: - if (isa_io_base == 0x80000000) {
576: - isa_io_base = 0xF2000000;
577: - goto nvram_retry;
578: + if (nvram)
579: + break;
580: }
581: + if (i == 3) {
582: ERROR("Unable to load configuration from NVRAM. Aborting...\n");
583: return -1;
584: }
585: @@ -402,7 +406,7 @@
586: cpu_name = CPU_get_name(pvr);
587: OF_register_cpu(cpu_name, 0, pvr,
588: 200 * 1000 * 1000, 200 * 1000 * 1000,
589: - 100 * 1000 * 1000, 10 * 1000 * 1000,
590: + 100 * 1000 * 1000, 100 * 1000 * 1000,
591: 0x0092);
592: }
593: OF_register_memory(memsize, 512 * 1024 /* TOFIX */);
594: @@ -433,9 +437,12 @@
595: vga_puts(copyright);
596: vga_puts("\n");
597:
598: +#if 0
599: /* QEMU is quite incoherent: d is cdrom, not second drive */
600: + /* XXX: should probe CD-ROM position */
601: if (boot_device == 'd')
602: boot_device = 'e';
603: +#endif
604: /* Open boot device */
605: boot_part = bd_probe(boot_device);
606: if (boot_device == 'm') {
607: diff -wruN --exclude '*~' --exclude '*.o' --exclude '*.bin' --exclude '*.out' --exclude mkdiff OpenHackWare-release-0.4.org/src/nvram.c OpenHackWare-release-0.4/src/nvram.c
608: --- OpenHackWare-release-0.4.org/src/nvram.c 2005-03-31 09:23:33.000000000 +0200
609: +++ OpenHackWare-release-0.4/src/nvram.c 2005-06-04 23:44:03.000000000 +0200
610: @@ -334,6 +334,7 @@
611: ret = NVRAM_chrp_format(nvram);
612: break;
613: case ARCH_MAC99:
614: + case ARCH_HEATHROW: /* XXX: may be incorrect */
615: ret = NVRAM_mac99_format(nvram);
616: break;
617: case ARCH_POP:
618: @@ -409,13 +410,12 @@
619: arch = ARCH_MAC99;
620: } else if (strcmp(sign, "POP") == 0) {
621: arch = ARCH_POP;
622: + } else if (strcmp(sign, "HEATHROW") == 0) {
623: + arch = ARCH_HEATHROW;
624: } else {
625: ERROR("Unknown PPC architecture: '%s'\n", sign);
626: return NULL;
627: }
628: - /* HACK */
629: - if (arch == ARCH_CHRP)
630: - arch = ARCH_MAC99;
631: lword = NVRAM_get_lword(nvram, 0x30);
632: *RAM_size = lword;
633: byte = NVRAM_get_byte(nvram, 0x34);
634: diff -wruN --exclude '*~' --exclude '*.o' --exclude '*.bin' --exclude '*.out' --exclude mkdiff OpenHackWare-release-0.4.org/src/of.c OpenHackWare-release-0.4/src/of.c
635: --- OpenHackWare-release-0.4.org/src/of.c 2005-04-06 23:17:26.000000000 +0200
636: +++ OpenHackWare-release-0.4/src/of.c 2005-07-07 23:30:08.000000000 +0200
637: @@ -489,7 +489,7 @@
638: ERROR("%s can't alloc new node '%s' name\n", __func__, name);
639: return NULL;
640: }
641: - new->prop_address = OF_prop_int_new(env, new, "address", address);
642: + new->prop_address = OF_prop_int_new(env, new, "unit-address", address);
643: if (new->prop_address == NULL) {
644: free(new->prop_name->value);
645: free(new->prop_name);
646: @@ -1017,6 +1017,33 @@
647: string, strlen(string) + 1);
648: }
649:
650: +/* convert '\1' char to '\0' */
651: +static OF_prop_t *OF_prop_string_new1 (OF_env_t *env, OF_node_t *node,
652: + const unsigned char *name,
653: + const unsigned char *string)
654: +{
655: + int len, i;
656: + OF_prop_t *ret;
657: + unsigned char *str;
658: +
659: + if (strchr(string, '\1') == NULL) {
660: + return OF_prop_string_new(env, node, name, string);
661: + } else {
662: + len = strlen(string) + 1;
663: + str = malloc(len);
664: + if (!str)
665: + return NULL;
666: + memcpy(str, string, len);
667: + for(i = 0; i < len; i++)
668: + if (str[i] == '\1')
669: + str[i] = '\0';
670: + ret = OF_property_new(env, node, name,
671: + str, len);
672: + free(str);
673: + return ret;
674: + }
675: +}
676: +
677: __attribute__ (( section (".OpenFirmware") ))
678: static OF_prop_t *OF_prop_int_new (OF_env_t *env, OF_node_t *node,
679: const unsigned char *name, uint32_t value)
680: @@ -1421,15 +1448,12 @@
681: __attribute__ (( section (".OpenFirmware") ))
682: int OF_init (void)
683: {
684: - const unsigned char compat_str[] =
685: #if 0
686: "PowerMac3,1\0MacRISC\0Power Macintosh\0";
687: "PowerMac1,2\0MacRISC\0Power Macintosh\0";
688: "AAPL,PowerMac G3\0PowerMac G3\0MacRISC\0Power Macintosh\0";
689: "AAPL,PowerMac3,0\0MacRISC\0Power Macintosh\0";
690: "AAPL,Gossamer\0MacRISC\0Power Macintosh\0";
691: -#else
692: - "AAPL,PowerMac G3\0PowerMac G3\0MacRISC\0Power Macintosh\0";
693: #endif
694: OF_env_t *OF_env;
695: OF_node_t *als, *opt, *chs, *pks;
696: @@ -1455,15 +1479,21 @@
697: return -1;
698: }
699: OF_prop_string_new(OF_env, OF_node_root, "device_type", "bootrom");
700: -#if 0
701: - OF_prop_string_new(OF_env, OF_node_root,
702: - "model", "PPC Open Hack'Ware " BIOS_VERSION);
703: -#else
704: + if (arch == ARCH_HEATHROW) {
705: + const unsigned char compat_str[] =
706: + "PowerMac1,1\0MacRISC\0Power Macintosh";
707: + OF_property_new(OF_env, OF_node_root, "compatible",
708: + compat_str, sizeof(compat_str));
709: OF_prop_string_new(OF_env, OF_node_root,
710: - "model", compat_str);
711: -#endif
712: + "model", "Power Macintosh");
713: + } else {
714: + const unsigned char compat_str[] =
715: + "PowerMac3,1\0MacRISC\0Power Macintosh";
716: OF_property_new(OF_env, OF_node_root, "compatible",
717: compat_str, sizeof(compat_str));
718: + OF_prop_string_new(OF_env, OF_node_root,
719: + "model", "PowerMac3,1");
720: + }
721: #if 0
722: OF_prop_string_new(OF_env, OF_node_root, "copyright", copyright);
723: #else
724: @@ -1561,14 +1591,15 @@
725: range.size = 0x00800000;
726: OF_property_new(OF_env, rom, "ranges", &range, sizeof(OF_range_t));
727: OF_prop_int_new(OF_env, rom, "#address-cells", 1);
728: +
729: /* "/rom/boot-rom@fff00000" node */
730: - brom = OF_node_new(OF_env, OF_node_root, "boot-rom", 0xfff00000);
731: + brom = OF_node_new(OF_env, rom, "boot-rom", 0xfff00000);
732: if (brom == NULL) {
733: ERROR("Cannot create 'boot-rom'\n");
734: return -1;
735: }
736: regs.address = 0xFFF00000;
737: - regs.size = 0x00010000;
738: + regs.size = 0x00100000;
739: OF_property_new(OF_env, brom, "reg", ®s, sizeof(OF_regprop_t));
740: OF_prop_string_new(OF_env, brom, "write-characteristic", "flash");
741: OF_prop_string_new(OF_env, brom, "BootROM-build-date",
742: @@ -1577,7 +1608,7 @@
743: OF_prop_string_new(OF_env, brom, "copyright", copyright);
744: OF_prop_string_new(OF_env, brom, "model", BIOS_str);
745: OF_prop_int_new(OF_env, brom, "result", 0);
746: -#if 0
747: +#if 1
748: {
749: /* Hack taken 'as-is' from PearPC */
750: unsigned char info[] = {
751: @@ -1596,7 +1627,9 @@
752: OF_node_put(OF_env, brom);
753: OF_node_put(OF_env, rom);
754: }
755: +#if 0
756: /* From here, hardcoded hacks to get a Mac-like machine */
757: + /* XXX: Core99 does not seem to like this NVRAM tree */
758: /* "/nvram@fff04000" node */
759: {
760: OF_regprop_t regs;
761: @@ -1617,6 +1650,7 @@
762: OF_prop_int_new(OF_env, chs, "nvram", OF_pack_handle(OF_env, nvr));
763: OF_node_put(OF_env, nvr);
764: }
765: +#endif
766: /* "/pseudo-hid" : hid emulation as Apple does */
767: {
768: OF_node_t *hid;
769: @@ -1663,7 +1697,27 @@
770: }
771: OF_node_put(OF_env, hid);
772: }
773: + if (arch == ARCH_MAC99) {
774: + OF_node_t *unin;
775: + OF_regprop_t regs;
776:
777: + unin = OF_node_new(OF_env, OF_node_root,
778: + "uni-n", 0xf8000000);
779: + if (unin == NULL) {
780: + ERROR("Cannot create 'uni-n'\n");
781: + return -1;
782: + }
783: + OF_prop_string_new(OF_env, unin, "device-type", "memory-controller");
784: + OF_prop_string_new(OF_env, unin, "model", "AAPL,UniNorth");
785: + OF_prop_string_new(OF_env, unin, "compatible", "uni-north");
786: + regs.address = 0xf8000000;
787: + regs.size = 0x01000000;
788: + OF_property_new(OF_env, unin, "reg", ®s, sizeof(regs));
789: + OF_prop_int_new(OF_env, unin, "#address-cells", 1);
790: + OF_prop_int_new(OF_env, unin, "#size-cells", 1);
791: + OF_prop_int_new(OF_env, unin, "device-rev", 3);
792: + OF_node_put(OF_env, unin);
793: + }
794:
795: #if 1 /* This is mandatory for claim to work
796: * but I don't know where it should really be (in cpu ?)
797: @@ -1693,7 +1747,9 @@
798:
799: /* "/options/boot-args" node */
800: {
801: - const unsigned char *args = "-v rootdev cdrom";
802: + // const unsigned char *args = "-v rootdev cdrom";
803: + //const unsigned char *args = "-v io=0xffffffff";
804: + const unsigned char *args = "-v";
805: /* Ask MacOS X to print debug messages */
806: // OF_prop_string_new(OF_env, chs, "machargs", args);
807: // OF_prop_string_new(OF_env, opt, "boot-command", args);
808: @@ -2013,17 +2069,17 @@
809: OF_prop_int_new(OF_env, node, "min-grant", min_grant);
810: OF_prop_int_new(OF_env, node, "max-latency", max_latency);
811: if (dev->type != NULL)
812: - OF_prop_string_new(OF_env, node, "device_type", dev->type);
813: + OF_prop_string_new1(OF_env, node, "device_type", dev->type);
814: if (dev->compat != NULL)
815: - OF_prop_string_new(OF_env, node, "compatible", dev->compat);
816: + OF_prop_string_new1(OF_env, node, "compatible", dev->compat);
817: if (dev->model != NULL)
818: - OF_prop_string_new(OF_env, node, "model", dev->model);
819: + OF_prop_string_new1(OF_env, node, "model", dev->model);
820: if (dev->acells != 0)
821: OF_prop_int_new(OF_env, node, "#address-cells", dev->acells);
822: if (dev->scells != 0)
823: - OF_prop_int_new(OF_env, node, "#interrupt-cells", dev->acells);
824: + OF_prop_int_new(OF_env, node, "#size-cells", dev->scells);
825: if (dev->icells != 0)
826: - OF_prop_int_new(OF_env, node, "#size-cells", dev->acells);
827: + OF_prop_int_new(OF_env, node, "#interrupt-cells", dev->icells);
828: dprintf("Done %p %p\n", parent, node);
829:
830: return node;
831: @@ -2040,8 +2096,9 @@
832: OF_env_t *OF_env;
833: pci_range_t ranges[3];
834: OF_regprop_t regs[1];
835: - OF_node_t *pci_host;
836: + OF_node_t *pci_host, *als;
837: int nranges;
838: + unsigned char buffer[OF_NAMELEN_MAX];
839:
840: OF_env = OF_env_main;
841: dprintf("register PCI host '%s' '%s' '%s' '%s'\n",
842: @@ -2052,6 +2109,17 @@
843: ERROR("Cannot create pci host\n");
844: return NULL;
845: }
846: +
847: + als = OF_node_get(OF_env, "aliases");
848: + if (als == NULL) {
849: + ERROR("Cannot get 'aliases'\n");
850: + return NULL;
851: + }
852: + sprintf(buffer, "/%s", dev->name);
853: + OF_prop_string_set(OF_env, als, "pci", buffer);
854: + OF_node_put(OF_env, als);
855: +
856: +
857: regs[0].address = cfg_base;
858: regs[0].size = cfg_len;
859: OF_property_new(OF_env, pci_host, "reg", regs, sizeof(OF_regprop_t));
860: @@ -2136,6 +2204,11 @@
861: return pci_dev;
862: }
863:
864: +/* XXX: suppress that, used for interrupt map init */
865: +OF_node_t *pci_host_node;
866: +uint32_t pci_host_interrupt_map[7 * 32];
867: +int pci_host_interrupt_map_len = 0;
868: +
869: void OF_finalize_pci_host (void *dev, int first_bus, int nb_busses)
870: {
871: OF_env_t *OF_env;
872: @@ -2145,10 +2218,12 @@
873: regs[0].address = first_bus;
874: regs[0].size = nb_busses;
875: OF_property_new(OF_env, dev, "bus-range", regs, sizeof(OF_regprop_t));
876: + pci_host_node = dev;
877: }
878:
879: void OF_finalize_pci_device (void *dev, uint8_t bus, uint8_t devfn,
880: - uint32_t *regions, uint32_t *sizes)
881: + uint32_t *regions, uint32_t *sizes,
882: + int irq_line)
883: {
884: OF_env_t *OF_env;
885: pci_reg_prop_t pregs[6], rregs[6];
886: @@ -2156,6 +2231,7 @@
887: int i, j, k;
888:
889: OF_env = OF_env_main;
890: + /* XXX: only useful for VGA card in fact */
891: if (regions[0] != 0x00000000)
892: OF_prop_int_set(OF_env, dev, "address", regions[0] & ~0x0000000F);
893: for (i = 0, j = 0, k = 0; i < 6; i++) {
894: @@ -2222,7 +2298,22 @@
895: } else {
896: OF_property_new(OF_env, dev, "assigned-addresses", NULL, 0);
897: }
898: -#if 0
899: + if (irq_line >= 0) {
900: + int i;
901: + OF_prop_int_new(OF_env, dev, "interrupts", 1);
902: + i = pci_host_interrupt_map_len;
903: + pci_host_interrupt_map[i++] = (devfn << 8) & 0xf800;
904: + pci_host_interrupt_map[i++] = 0;
905: + pci_host_interrupt_map[i++] = 0;
906: + pci_host_interrupt_map[i++] = 0;
907: + pci_host_interrupt_map[i++] = 0; /* pic handle will be patched later */
908: + pci_host_interrupt_map[i++] = irq_line;
909: + if (arch != ARCH_HEATHROW) {
910: + pci_host_interrupt_map[i++] = 1;
911: + }
912: + pci_host_interrupt_map_len = i;
913: + }
914: +#if 1
915: {
916: OF_prop_t *prop_name = ((OF_node_t *)dev)->prop_name;
917:
918: @@ -2390,6 +2481,54 @@
919: return 0;
920: }
921:
922: +static void keylargo_ata(OF_node_t *mio, uint32_t base_address,
923: + uint32_t base, int irq1, int irq2,
924: + uint16_t pic_phandle)
925: +{
926: + OF_env_t *OF_env = OF_env_main;
927: + OF_node_t *ata;
928: + OF_regprop_t regs[2];
929: +
930: + ata = OF_node_new(OF_env, mio, "ata-4", base);
931: + if (ata == NULL) {
932: + ERROR("Cannot create 'ata-4'\n");
933: + return;
934: + }
935: + OF_prop_string_new(OF_env, ata, "device_type", "ata");
936: +#if 1
937: + OF_prop_string_new(OF_env, ata, "compatible", "key2largo-ata");
938: + OF_prop_string_new(OF_env, ata, "model", "ata-4");
939: + OF_prop_string_new(OF_env, ata, "cable-type", "80-conductor");
940: +#else
941: + OF_prop_string_new(OF_env, ata, "compatible", "cmd646-ata");
942: + OF_prop_string_new(OF_env, ata, "model", "ata-4");
943: +#endif
944: + OF_prop_int_new(OF_env, ata, "#address-cells", 1);
945: + OF_prop_int_new(OF_env, ata, "#size-cells", 0);
946: + regs[0].address = base;
947: + regs[0].size = 0x00001000;
948: +#if 0 // HACK: Don't set up DMA registers
949: + regs[1].address = 0x00008A00;
950: + regs[1].size = 0x00001000;
951: + OF_property_new(OF_env, ata, "reg",
952: + regs, 2 * sizeof(OF_regprop_t));
953: +#else
954: + OF_property_new(OF_env, ata, "reg",
955: + regs, sizeof(OF_regprop_t));
956: +#endif
957: + OF_prop_int_new(OF_env, ata, "interrupt-parent", pic_phandle);
958: + regs[0].address = irq1;
959: + regs[0].size = 0x00000001;
960: + regs[1].address = irq2;
961: + regs[1].size = 0x00000000;
962: + OF_property_new(OF_env, ata, "interrupts",
963: + regs, 2 * sizeof(OF_regprop_t));
964: + if (base == 0x1f000)
965: + ide_pci_pmac_register(base_address + base, 0x00000000, ata);
966: + else
967: + ide_pci_pmac_register(0x00000000, base_address + base, ata);
968: +}
969: +
970: void OF_finalize_pci_macio (void *dev, uint32_t base_address, uint32_t size,
971: void *private_data)
972: {
973: @@ -2398,6 +2537,8 @@
974: pci_reg_prop_t pregs[2];
975: OF_node_t *mio, *chs, *als;
976: uint16_t pic_phandle;
977: + int rec_len;
978: + OF_prop_t *mio_reg;
979:
980: OF_DPRINTF("mac-io: %p\n", dev);
981: OF_env = OF_env_main;
982: @@ -2416,10 +2557,14 @@
983: mio = dev;
984: mio->private_data = private_data;
985: pregs[0].addr.hi = 0x00000000;
986: - pregs[0].addr.mid = 0x82013810;
987: + pregs[0].addr.mid = 0x00000000;
988: pregs[0].addr.lo = 0x00000000;
989: pregs[0].size_hi = base_address;
990: pregs[0].size_lo = size;
991: + mio_reg = OF_property_get(OF_env, mio, "reg");
992: + if (mio_reg && mio_reg->vlen >= 5 * 4) {
993: + pregs[0].addr.mid = ((pci_reg_prop_t *)mio_reg->value)->addr.hi;
994: + }
995: OF_property_new(OF_env, mio, "ranges",
996: &pregs, sizeof(pci_reg_prop_t));
997: #if 0
998: @@ -2431,8 +2576,32 @@
999: OF_property_new(OF_env, mio, "assigned-addresses",
1000: &pregs, sizeof(pci_reg_prop_t));
1001: #endif
1002: +
1003: + if (arch == ARCH_HEATHROW) {
1004: + /* Heathrow PIC */
1005: + OF_regprop_t regs;
1006: + OF_node_t *mpic;
1007: + const char compat_str[] = "heathrow\0mac-risc";
1008: +
1009: + mpic = OF_node_new(OF_env, mio, "interrupt-controller", 0x10);
1010: + if (mpic == NULL) {
1011: + ERROR("Cannot create 'mpic'\n");
1012: + goto out;
1013: + }
1014: + OF_prop_string_new(OF_env, mpic, "device_type", "interrupt-controller");
1015: + OF_property_new(OF_env, mpic, "compatible", compat_str, sizeof(compat_str));
1016: + OF_prop_int_new(OF_env, mpic, "#interrupt-cells", 1);
1017: + regs.address = 0x10;
1018: + regs.size = 0x20;
1019: + OF_property_new(OF_env, mpic, "reg",
1020: + ®s, sizeof(regs));
1021: + OF_property_new(OF_env, mpic, "interrupt-controller", NULL, 0);
1022: + pic_phandle = OF_pack_handle(OF_env, mpic);
1023: + OF_prop_int_new(OF_env, chs, "interrupt-controller", pic_phandle);
1024: + OF_node_put(OF_env, mpic);
1025: + rec_len = 6;
1026: + } else {
1027: /* OpenPIC */
1028: - {
1029: OF_regprop_t regs[4];
1030: OF_node_t *mpic;
1031: mpic = OF_node_new(OF_env, mio, "interrupt-controller", 0x40000);
1032: @@ -2455,8 +2624,37 @@
1033: pic_phandle = OF_pack_handle(OF_env, mpic);
1034: OF_prop_int_new(OF_env, chs, "interrupt-controller", pic_phandle);
1035: OF_node_put(OF_env, mpic);
1036: + rec_len = 7;
1037: }
1038: -#if 1
1039: +
1040: + /* patch pci host table */
1041: + /* XXX: do it after the PCI init */
1042: + {
1043: + int i;
1044: + uint32_t tab[4];
1045: +
1046: + for(i = 0; i < pci_host_interrupt_map_len; i += rec_len)
1047: + pci_host_interrupt_map[i + 4] = pic_phandle;
1048: +#if 0
1049: + dprintf("interrupt-map:\n");
1050: + for(i = 0; i < pci_host_interrupt_map_len; i++) {
1051: + dprintf(" %08x", pci_host_interrupt_map[i]);
1052: + if ((i % rec_len) == (rec_len - 1))
1053: + dprintf("\n");
1054: + }
1055: + dprintf("\n");
1056: +#endif
1057: + OF_property_new(OF_env, pci_host_node, "interrupt-map",
1058: + pci_host_interrupt_map,
1059: + pci_host_interrupt_map_len * sizeof(uint32_t));
1060: + tab[0] = 0xf800;
1061: + tab[1] = 0;
1062: + tab[2] = 0;
1063: + tab[3] = 0;
1064: + OF_property_new(OF_env, pci_host_node, "interrupt-map-mask",
1065: + tab, 4 * sizeof(uint32_t));
1066: + }
1067: +#if 0
1.1.1.2 ! root 1068: /* escc is useful to get MacOS X debug messages */
1.1 root 1069: {
1070: OF_regprop_t regs[8];
1071: @@ -2645,85 +2843,12 @@
1072: OF_node_put(OF_env, scc);
1073: }
1074: #endif
1075: - /* IDE controller */
1076: - {
1077: - OF_node_t *ata;
1078: - OF_regprop_t regs[2];
1079: - ata = OF_node_new(OF_env, mio, "ata-4", 0x1f000);
1080: - if (ata == NULL) {
1081: - ERROR("Cannot create 'ata-4'\n");
1082: - goto out;
1083: - }
1084: - OF_prop_string_new(OF_env, ata, "device_type", "ata");
1085: -#if 1
1086: - OF_prop_string_new(OF_env, ata, "compatible", "keylargo-ata");
1087: - OF_prop_string_new(OF_env, ata, "model", "ata-4");
1088: -#else
1089: - OF_prop_string_new(OF_env, ata, "compatible", "cmd646-ata");
1090: - OF_prop_string_new(OF_env, ata, "model", "ata-4");
1091: -#endif
1092: - OF_prop_int_new(OF_env, ata, "#address-cells", 1);
1093: - OF_prop_int_new(OF_env, ata, "#size-cells", 0);
1094: - regs[0].address = 0x0001F000;
1095: - regs[0].size = 0x00001000;
1096: -#if 0 // HACK: Don't set up DMA registers
1097: - regs[1].address = 0x00008A00;
1098: - regs[1].size = 0x00001000;
1099: - OF_property_new(OF_env, ata, "reg",
1100: - regs, 2 * sizeof(OF_regprop_t));
1101: -#else
1102: - OF_property_new(OF_env, ata, "reg",
1103: - regs, sizeof(OF_regprop_t));
1104: -#endif
1105: - OF_prop_int_new(OF_env, ata, "interrupt-parent", pic_phandle);
1106: - regs[0].address = 0x00000013;
1107: - regs[0].size = 0x00000001;
1108: - regs[1].address = 0x0000000B;
1109: - regs[1].size = 0x00000000;
1110: - OF_property_new(OF_env, ata, "interrupts",
1111: - regs, 2 * sizeof(OF_regprop_t));
1112: - ide_pci_pmac_register(base_address + 0x1f000, 0x00000000, ata);
1113: -
1114: - }
1115: - {
1116: - OF_node_t *ata;
1117: - OF_regprop_t regs[2];
1118: - ata = OF_node_new(OF_env, mio, "ata-4", 0x20000);
1119: - if (ata == NULL) {
1120: - ERROR("Cannot create 'ata-4'\n");
1121: - goto out;
1122: - }
1123: - OF_prop_string_new(OF_env, ata, "device_type", "ata");
1124: -#if 1
1125: - OF_prop_string_new(OF_env, ata, "compatible", "keylargo-ata");
1126: - OF_prop_string_new(OF_env, ata, "model", "ata-4");
1127: -#else
1128: - OF_prop_string_new(OF_env, ata, "compatible", "cmd646-ata");
1129: - OF_prop_string_new(OF_env, ata, "model", "ata-4");
1130: -#endif
1131: - OF_prop_int_new(OF_env, ata, "#address-cells", 1);
1132: - OF_prop_int_new(OF_env, ata, "#size-cells", 0);
1133: - regs[0].address = 0x00020000;
1134: - regs[0].size = 0x00001000;
1135: -#if 0 // HACK: Don't set up DMA registers
1136: - regs[1].address = 0x00008A00;
1137: - regs[1].size = 0x00001000;
1138: - OF_property_new(OF_env, ata, "reg",
1139: - regs, 2 * sizeof(OF_regprop_t));
1140: -#else
1141: - OF_property_new(OF_env, ata, "reg",
1142: - regs, sizeof(OF_regprop_t));
1143: -#endif
1144: - OF_prop_int_new(OF_env, ata, "interrupt-parent", pic_phandle);
1145: - regs[0].address = 0x00000014;
1146: - regs[0].size = 0x00000001;
1147: - regs[1].address = 0x0000000B;
1148: - regs[1].size = 0x00000000;
1149: - OF_property_new(OF_env, ata, "interrupts",
1150: - regs, 2 * sizeof(OF_regprop_t));
1151: - ide_pci_pmac_register(0x00000000, base_address + 0x20000, ata);
1152: -
1153: + /* Keylargo IDE controller: need some work (DMA problem ?) */
1154: + if (arch == ARCH_MAC99) {
1155: + keylargo_ata(mio, base_address, 0x1f000, 0x13, 0xb, pic_phandle);
1156: + keylargo_ata(mio, base_address, 0x20000, 0x14, 0xb, pic_phandle);
1157: }
1158: +#if 0
1159: /* Timer */
1160: {
1161: OF_node_t *tmr;
1162: @@ -2746,10 +2871,11 @@
1163: regs, sizeof(OF_regprop_t));
1164: OF_node_put(OF_env, tmr);
1165: }
1166: +#endif
1167: /* VIA-PMU */
1168: {
1169: /* Controls adb, RTC and power-mgt (forget it !) */
1170: - OF_node_t *via, *adb, *rtc;
1171: + OF_node_t *via, *adb;
1172: OF_regprop_t regs[1];
1173: #if 0 // THIS IS A HACK AND IS COMPLETELY ABSURD !
1174: // (but needed has Qemu doesn't emulate via-pmu).
1175: @@ -2773,14 +2899,21 @@
1176: regs[0].size = 0x00002000;
1177: OF_property_new(OF_env, via, "reg", regs, sizeof(OF_regprop_t));
1178: OF_prop_int_new(OF_env, via, "interrupt-parent", pic_phandle);
1179: + if (arch == ARCH_HEATHROW) {
1180: + OF_prop_int_new(OF_env, via, "interrupts", 0x12);
1181: + } else {
1182: regs[0].address = 0x00000019;
1183: regs[0].size = 0x00000001;
1184: OF_property_new(OF_env, via, "interrupts",
1185: regs, sizeof(OF_regprop_t));
1186: + }
1187: + /* force usage of OF bus speeds */
1188: + OF_prop_int_new(OF_env, via, "BusSpeedCorrect", 1);
1189: #if 0
1190: OF_prop_int_new(OF_env, via, "pmu-version", 0x00D0740C);
1191: #endif
1192: -#if 1
1193: + {
1194: + OF_node_t *kbd, *mouse;
1195: /* ADB pseudo-device */
1196: adb = OF_node_new(OF_env, via, "adb", OF_ADDRESS_NONE);
1197: if (adb == NULL) {
1198: @@ -2797,9 +2930,26 @@
1199: OF_prop_int_new(OF_env, adb, "#size-cells", 0);
1200: OF_pack_get_path(OF_env, tmp, 512, adb);
1201: OF_prop_string_new(OF_env, als, "adb", tmp);
1202: - /* XXX: add "keyboard@2" and "mouse@3" */
1203: - OF_node_put(OF_env, adb);
1204: -#endif
1205: +
1206: + kbd = OF_node_new(OF_env, adb, "keyboard", 2);
1207: + if (kbd == NULL) {
1208: + ERROR("Cannot create 'kbd'\n");
1209: + goto out;
1210: + }
1211: + OF_prop_string_new(OF_env, kbd, "device_type", "keyboard");
1212: + OF_prop_int_new(OF_env, kbd, "reg", 2);
1213: +
1214: + mouse = OF_node_new(OF_env, adb, "mouse", 3);
1215: + if (mouse == NULL) {
1216: + ERROR("Cannot create 'mouse'\n");
1217: + goto out;
1218: + }
1219: + OF_prop_string_new(OF_env, mouse, "device_type", "mouse");
1220: + OF_prop_int_new(OF_env, mouse, "reg", 3);
1221: + OF_prop_int_new(OF_env, mouse, "#buttons", 3);
1222: + }
1223: + {
1224: + OF_node_t *rtc;
1225:
1226: rtc = OF_node_new(OF_env, via, "rtc", OF_ADDRESS_NONE);
1227: if (rtc == NULL) {
1228: @@ -2813,14 +2963,68 @@
1229: OF_prop_string_new(OF_env, rtc, "compatible", "rtc");
1230: #endif
1231: OF_node_put(OF_env, rtc);
1232: - OF_node_put(OF_env, via);
1233: }
1234: + // OF_node_put(OF_env, via);
1235: + }
1236: + {
1237: + OF_node_t *pmgt;
1238: + pmgt = OF_node_new(OF_env, mio, "power-mgt", OF_ADDRESS_NONE);
1239: + OF_prop_string_new(OF_env, pmgt, "device_type", "power-mgt");
1240: + OF_prop_string_new(OF_env, pmgt, "compatible", "cuda");
1241: + OF_prop_string_new(OF_env, pmgt, "mgt-kind", "min-consumption-pwm-led");
1242: + OF_node_put(OF_env, pmgt);
1243: + }
1244: +
1245: + if (arch == ARCH_HEATHROW) {
1246: + /* NVRAM */
1247: + OF_node_t *nvr;
1248: + OF_regprop_t regs;
1249: + nvr = OF_node_new(OF_env, mio, "nvram", 0x60000);
1250: + OF_prop_string_new(OF_env, nvr, "device_type", "nvram");
1251: + regs.address = 0x60000;
1252: + regs.size = 0x00020000;
1253: + OF_property_new(OF_env, nvr, "reg", ®s, sizeof(regs));
1254: + OF_prop_int_new(OF_env, nvr, "#bytes", 0x2000);
1255: + OF_node_put(OF_env, nvr);
1256: + }
1257: +
1258: out:
1259: // OF_node_put(OF_env, mio);
1260: OF_node_put(OF_env, chs);
1261: OF_node_put(OF_env, als);
1262: }
1263:
1264: +void OF_finalize_pci_ide (void *dev,
1265: + uint32_t io_base0, uint32_t io_base1,
1266: + uint32_t io_base2, uint32_t io_base3)
1267: +{
1268: + OF_env_t *OF_env = OF_env_main;
1269: + OF_node_t *pci_ata = dev;
1270: + OF_node_t *ata, *atas[2];
1271: + int i;
1272: +
1273: + OF_prop_int_new(OF_env, pci_ata, "#address-cells", 1);
1274: + OF_prop_int_new(OF_env, pci_ata, "#size-cells", 0);
1275: +
1276: + /* XXX: Darwin handles only one device */
1277: + for(i = 0; i < 1; i++) {
1278: + ata = OF_node_new(OF_env, pci_ata, "ata-4", i);
1279: + if (ata == NULL) {
1280: + ERROR("Cannot create 'ata-4'\n");
1281: + return;
1282: + }
1283: + OF_prop_string_new(OF_env, ata, "device_type", "ata");
1284: + OF_prop_string_new(OF_env, ata, "compatible", "cmd646-ata");
1285: + OF_prop_string_new(OF_env, ata, "model", "ata-4");
1286: + OF_prop_int_new(OF_env, ata, "#address-cells", 1);
1287: + OF_prop_int_new(OF_env, ata, "#size-cells", 0);
1288: + OF_prop_int_new(OF_env, ata, "reg", i);
1289: + atas[i] = ata;
1290: + }
1291: + ide_pci_pc_register(io_base0, io_base1, io_base2, io_base3,
1292: + atas[0], atas[1]);
1293: +}
1294: +
1295: /*****************************************************************************/
1296: /* Fake package */
1297: static void OF_method_fake (OF_env_t *OF_env)
1298: @@ -2862,11 +3066,11 @@
1299: /* As we get a 1:1 mapping, do nothing */
1300: ihandle = popd(OF_env);
1301: args = (void *)popd(OF_env);
1302: - address = popd(OF_env);
1303: - virt = popd(OF_env);
1304: - size = popd(OF_env);
1305: popd(OF_env);
1306: - OF_DPRINTF("Translate address %0x %0x %0x %0x\n", ihandle, address,
1307: + size = popd(OF_env);
1308: + virt = popd(OF_env);
1309: + address = popd(OF_env);
1310: + OF_DPRINTF("Map %0x %0x %0x %0x\n", ihandle, address,
1311: virt, size);
1312: pushd(OF_env, 0);
1313: }
1314: @@ -3270,7 +3474,7 @@
1315: OF_prop_string_new(OF_env, dsk, "device_type", "block");
1316: OF_prop_string_new(OF_env, dsk, "category", type);
1317: OF_prop_int_new(OF_env, dsk, "device_id", devnum);
1318: - OF_prop_int_new(OF_env, dsk, "reg", 0);
1319: + OF_prop_int_new(OF_env, dsk, "reg", devnum);
1320: OF_method_new(OF_env, dsk, "open", &OF_blockdev_open);
1321: OF_method_new(OF_env, dsk, "seek", &OF_blockdev_seek);
1322: OF_method_new(OF_env, dsk, "read", &OF_blockdev_read);
1323: @@ -3432,7 +3636,8 @@
1324: }
1325:
1326: void OF_vga_register (const unsigned char *name, unused uint32_t address,
1327: - int width, int height, int depth)
1328: + int width, int height, int depth,
1329: + unsigned long vga_bios_addr, unsigned long vga_bios_size)
1330: {
1331: OF_env_t *OF_env;
1332: unsigned char tmp[OF_NAMELEN_MAX];
1333: @@ -3504,6 +3709,18 @@
1334: OF_prop_string_new(OF_env, als, "display", tmp);
1335: OF_node_put(OF_env, als);
1336: /* XXX: may also need read-rectangle */
1337: +
1338: + if (vga_bios_size >= 8) {
1339: + const uint8_t *p;
1340: + int size;
1341: + /* check the QEMU VGA BIOS header */
1342: + p = (const uint8_t *)vga_bios_addr;
1343: + if (p[0] == 'N' && p[1] == 'D' && p[2] == 'R' && p[3] == 'V') {
1344: + size = *(uint32_t *)(p + 4);
1345: + OF_property_new(OF_env, disp, "driver,AAPL,MacOS,PowerPC",
1346: + p + 8, size);
1347: + }
1348: + }
1349: out:
1350: OF_node_put(OF_env, disp);
1351: }
1352: @@ -4451,7 +4668,10 @@
1353: break;
1354: case 0x233441d3: /* MacOS X 10.2 and OpenDarwin 1.41 */
1355: /* Create "memory-map" pseudo device */
1356: - popd(OF_env);
1357: + {
1358: + OF_node_t *map;
1359: + uint32_t phandle;
1360: +
1361: /* Find "/packages" */
1362: chs = OF_pack_find_by_name(OF_env, OF_node_root, "/chosen");
1363: if (chs == NULL) {
1364: @@ -4459,10 +4679,6 @@
1365: ERROR("Cannot get '/chosen'\n");
1366: break;
1367: }
1368: - {
1369: -#if 1
1370: - OF_node_t *map;
1371: - uint32_t phandle;
1372: map = OF_node_new(OF_env, chs, "memory-map", OF_ADDRESS_NONE);
1373: if (map == NULL) {
1374: pushd(OF_env, -1);
1375: @@ -4473,11 +4689,8 @@
1376: OF_node_put(OF_env, map);
1377: OF_node_put(OF_env, chs);
1378: pushd(OF_env, phandle);
1379: - }
1380: -#else
1381: - pushd(OF_env, 0);
1382: -#endif
1383: pushd(OF_env, 0);
1384: + }
1385: break;
1386: case 0x32a2d18e: /* MacOS X 10.2 and OpenDarwin 6.02 */
1387: /* Return screen ihandle */
1388: @@ -4540,9 +4753,10 @@
1389: case 0x4ad41f2d:
1390: /* Yaboot: wait 10 ms: sure ! */
1391: break;
1392: +
1393: default:
1394: /* ERROR */
1395: - printf("Script:\n%s\n", FString);
1396: + printf("Script: len=%d\n%s\n", (int)strlen(FString), FString);
1397: printf("Call %0x NOT IMPLEMENTED !\n", crc);
1398: bug();
1399: break;
1400: @@ -4581,6 +4795,7 @@
1401: {
1402: OF_CHECK_NBARGS(OF_env, 0);
1403: /* Should free all OF resources */
1404: + bd_reset_all();
1405: #if defined (DEBUG_BIOS)
1406: {
1407: uint16_t loglevel = 0x02 | 0x10 | 0x80;
1408: diff -wruN --exclude '*~' --exclude '*.o' --exclude '*.bin' --exclude '*.out' --exclude mkdiff OpenHackWare-release-0.4.org/src/pci.c OpenHackWare-release-0.4/src/pci.c
1409: --- OpenHackWare-release-0.4.org/src/pci.c 2005-03-31 09:23:33.000000000 +0200
1410: +++ OpenHackWare-release-0.4/src/pci.c 2005-07-07 23:27:37.000000000 +0200
1411: @@ -99,8 +99,8 @@
1412: uint16_t min_grant;
1413: uint16_t max_latency;
1414: uint8_t irq_line;
1415: - uint32_t regions[6];
1416: - uint32_t sizes[6];
1417: + uint32_t regions[7]; /* the region 6 is the PCI ROM */
1418: + uint32_t sizes[7];
1419: pci_device_t *next;
1420: };
1421:
1422: @@ -158,6 +158,7 @@
1423:
1424: /* IRQ numbers assigned to PCI IRQs */
1425: static uint8_t prep_pci_irqs[4] = { 9, 11, 9, 11 };
1426: +static uint8_t heathrow_pci_irqs[4] = { 0x15, 0x16, 0x17, 0x18 };
1427: static uint8_t pmac_pci_irqs[4] = { 8, 9, 10, 11 };
1428:
1429: /* PREP PCI host */
1430: @@ -399,6 +400,79 @@
1431: &uninorth_config_readl, &uninorth_config_writel,
1432: };
1433:
1434: +/* Grackle PCI host */
1435: +
1436: +static uint32_t grackle_cfg_address (pci_bridge_t *bridge,
1437: + uint8_t bus, uint8_t devfn,
1438: + uint8_t offset)
1439: +{
1440: + uint32_t addr;
1441: + addr = 0x80000000 | (bus << 16) | (devfn << 8) | (offset & 0xfc);
1442: + stswap32((uint32_t *)bridge->cfg_addr, addr);
1443: + return bridge->cfg_data + (offset & 3);
1444: +}
1445: +
1446: +static uint8_t grackle_config_readb (pci_bridge_t *bridge,
1447: + uint8_t bus, uint8_t devfn,
1448: + uint8_t offset)
1449: +{
1450: + uint32_t addr;
1451: + addr = grackle_cfg_address(bridge, bus, devfn, offset);
1452: + return *((uint8_t *)addr);
1453: +}
1454: +
1455: +static void grackle_config_writeb (pci_bridge_t *bridge,
1456: + uint8_t bus, uint8_t devfn,
1457: + uint8_t offset, uint8_t val)
1458: +{
1459: + uint32_t addr;
1460: + addr = grackle_cfg_address(bridge, bus, devfn, offset);
1461: + *((uint8_t *)addr) = val;
1462: +}
1463: +
1464: +static uint16_t grackle_config_readw (pci_bridge_t *bridge,
1465: + uint8_t bus, uint8_t devfn,
1466: + uint8_t offset)
1467: +{
1468: + uint32_t addr;
1469: + addr = grackle_cfg_address(bridge, bus, devfn, offset);
1470: + return ldswap16((uint16_t *)addr);
1471: +}
1472: +
1473: +static void grackle_config_writew (pci_bridge_t *bridge,
1474: + uint8_t bus, uint8_t devfn,
1475: + uint8_t offset, uint16_t val)
1476: +{
1477: + uint32_t addr;
1478: + addr = grackle_cfg_address(bridge, bus, devfn, offset);
1479: + stswap16((uint16_t *)addr, val);
1480: +}
1481: +
1482: +static uint32_t grackle_config_readl (pci_bridge_t *bridge,
1483: + uint8_t bus, uint8_t devfn,
1484: + uint8_t offset)
1485: +{
1486: + uint32_t addr;
1487: + addr = grackle_cfg_address(bridge, bus, devfn, offset);
1488: + return ldswap32((uint32_t *)addr);
1489: +}
1490: +
1491: +static void grackle_config_writel (pci_bridge_t *bridge,
1492: + uint8_t bus, uint8_t devfn,
1493: + uint8_t offset, uint32_t val)
1494: +{
1495: + uint32_t addr;
1496: +
1497: + addr = grackle_cfg_address(bridge, bus, devfn, offset);
1498: + stswap32((uint32_t *)addr, val);
1499: +}
1500: +
1501: +static pci_ops_t grackle_pci_ops = {
1502: + &grackle_config_readb, &grackle_config_writeb,
1503: + &grackle_config_readw, &grackle_config_writew,
1504: + &grackle_config_readl, &grackle_config_writel,
1505: +};
1506: +
1507: static inline uint8_t pci_config_readb (pci_bridge_t *bridge,
1508: uint8_t bus, uint8_t devfn,
1509: uint8_t offset)
1510: @@ -466,12 +540,22 @@
1511: },
1512: };
1513:
1514: +static int ide_config_cb2 (pci_device_t *device)
1515: +{
1516: + OF_finalize_pci_ide(device->common.OF_private,
1517: + device->regions[0] & ~0x0000000F,
1518: + device->regions[1] & ~0x0000000F,
1519: + device->regions[2] & ~0x0000000F,
1520: + device->regions[3] & ~0x0000000F);
1521: + return 0;
1522: +}
1523: +
1524: static pci_dev_t ide_devices[] = {
1525: {
1526: - 0x8086, 0x0100,
1527: - NULL, "Qemu IDE", "Qemu IDE", "ide",
1528: + 0x1095, 0x0646, /* CMD646 IDE controller */
1529: + "pci-ide", "pci-ata", NULL, NULL,
1530: 0, 0, 0,
1531: - NULL, NULL,
1532: + ide_config_cb2, NULL,
1533: },
1534: {
1535: 0xFFFF, 0xFFFF,
1536: @@ -481,7 +565,9 @@
1537: },
1538: };
1539:
1540: -static int ide_config_cb (pci_device_t *device)
1541: +#if 0
1542: +/* should base it on PCI ID, not on arch */
1543: +static int ide_config_cb (unused pci_device_t *device)
1544: {
1545: printf("Register IDE controller\n");
1546: switch (arch) {
1547: @@ -491,14 +577,8 @@
1548: device->common.OF_private);
1549: break;
1550: default:
1551: - ide_pci_pc_register(device->regions[0] & ~0x0000000F,
1552: - device->regions[1] & ~0x0000000F,
1553: - device->regions[2] & ~0x0000000F,
1554: - device->regions[3] & ~0x0000000F,
1555: - device->common.OF_private);
1556: break;
1557: }
1558: -
1559: return 0;
1560: }
1561:
1562: @@ -512,16 +592,12 @@
1563: device->common.OF_private);
1564: break;
1565: default:
1566: - ide_pci_pc_register(device->regions[0] & ~0x0000000F,
1567: - device->regions[1] & ~0x0000000F,
1568: - device->regions[2] & ~0x0000000F,
1569: - device->regions[3] & ~0x0000000F,
1570: - device->common.OF_private);
1571: break;
1572: }
1573:
1574: return 0;
1575: }
1576: +#endif
1577:
1578: static pci_subclass_t mass_subclass[] = {
1579: {
1580: @@ -530,7 +606,7 @@
1581: },
1582: {
1583: 0x01, "IDE controller", "ide", ide_devices, NULL,
1584: - &ide_config_cb, NULL,
1585: + NULL, NULL,
1586: },
1587: {
1588: 0x02, "Floppy disk controller", NULL, NULL, NULL,
1589: @@ -546,7 +622,7 @@
1590: },
1591: {
1592: 0x05, "ATA controller", "ata", NULL, NULL,
1593: - &ata_config_cb, NULL,
1594: + NULL, NULL,
1595: },
1596: {
1597: 0x80, "misc mass-storage controller", NULL, NULL, NULL,
1598: @@ -646,7 +722,9 @@
1599: /* VGA 640x480x16 */
1600: OF_vga_register(device->common.device->name,
1601: device->regions[0] & ~0x0000000F,
1602: - vga_width, vga_height, vga_depth);
1603: + vga_width, vga_height, vga_depth,
1604: + device->regions[6] & ~0x0000000F,
1605: + device->sizes[6]);
1606: }
1607: vga_console_register();
1608:
1609: @@ -750,6 +828,13 @@
1610: NULL, &PREP_pci_ops,
1611: };
1612:
1613: +pci_dev_t grackle_fake_bridge = {
1614: + 0xFFFF, 0xFFFF,
1615: + "pci", "pci-bridge", "DEC,21154", "DEC,21154.pci-bridge",
1616: + -1, -1, -1,
1617: + NULL, &grackle_pci_ops,
1618: +};
1619: +
1620: static pci_dev_t hbrg_devices[] = {
1621: {
1622: 0x106B, 0x0020, NULL,
1623: @@ -758,8 +843,8 @@
1624: NULL, &uninorth_agp_fake_bridge,
1625: },
1626: {
1627: - 0x106B, 0x001F,
1628: - NULL, "pci", "AAPL,UniNorth", "uni-north",
1629: + 0x106B, 0x001F, NULL,
1630: + "pci", "AAPL,UniNorth", "uni-north",
1631: 3, 2, 1,
1632: NULL, &uninorth_fake_bridge,
1633: },
1634: @@ -770,10 +855,10 @@
1635: NULL, &uninorth_fake_bridge,
1636: },
1637: {
1638: - 0x1011, 0x0026, NULL,
1639: - "pci-bridge", NULL, NULL,
1640: + 0x1057, 0x0002, "pci",
1641: + "pci", "MOT,MPC106", "grackle",
1642: 3, 2, 1,
1643: - NULL, &PREP_pci_ops,
1644: + NULL, &grackle_fake_bridge,
1645: },
1646: {
1647: 0x1057, 0x4801, NULL,
1648: @@ -1443,7 +1528,14 @@
1649: }
1650:
1651: static const pci_dev_t misc_pci[] = {
1652: - /* Apple Mac-io controller */
1653: + /* Paddington Mac I/O */
1654: + {
1655: + 0x106B, 0x0017,
1656: + "mac-io", "mac-io", "AAPL,343S1211", "paddington\1heathrow",
1657: + 1, 1, 1,
1658: + &macio_config_cb, NULL,
1659: + },
1660: + /* KeyLargo Mac I/O */
1661: {
1662: 0x106B, 0x0022,
1663: "mac-io", "mac-io", "AAPL,Keylargo", "Keylargo",
1664: @@ -1599,7 +1691,7 @@
1665: uint8_t min_grant, uint8_t max_latency,
1666: int irq_line)
1667: {
1668: - uint32_t cmd;
1669: + uint32_t cmd, addr;
1670: int i;
1671:
1672: device->min_grant = min_grant;
1673: @@ -1611,22 +1703,28 @@
1674: printf("MAP PCI device %d:%d to IRQ %d\n",
1675: device->bus, device->devfn, irq_line);
1676: }
1677: - for (i = 0; i < 6; i++) {
1678: + for (i = 0; i < 7; i++) {
1679: if ((device->regions[i] & ~0xF) != 0x00000000 &&
1680: (device->regions[i] & ~0xF) != 0xFFFFFFF0) {
1681: printf("Map PCI device %d:%d %d to %0x %0x (%s)\n",
1682: device->bus, device->devfn, i,
1683: device->regions[i], device->sizes[i],
1684: - device->regions[i] & 0x00000001 ? "I/O" : "memory");
1685: + (device->regions[i] & 0x00000001) && i != 6 ? "I/O" :
1686: + "memory");
1687: + if (i != 6) {
1688: cmd = pci_config_readl(bridge, device->bus, device->devfn, 0x04);
1689: if (device->regions[i] & 0x00000001)
1690: cmd |= 0x00000001;
1691: else
1692: cmd |= 0x00000002;
1693: pci_config_writel(bridge, device->bus, device->devfn, 0x04, cmd);
1694: + }
1695: + if (i == 6)
1696: + addr = 0x30; /* PCI ROM */
1697: + else
1698: + addr = 0x10 + (i * sizeof(uint32_t));
1699: pci_config_writel(bridge, device->bus, device->devfn,
1700: - 0x10 + (i * sizeof(uint32_t)),
1701: - device->regions[i]);
1702: + addr, device->regions[i]);
1703: }
1704: }
1705: }
1706: @@ -1900,7 +1998,7 @@
1707: goto out;
1708: }
1709: ret = (pci_u_t *)newd;
1710: - max_areas = 6;
1711: + max_areas = 7;
1712: /* register PCI device in OF tree */
1713: if (bridge->dev.common.type == PCI_FAKE_BRIDGE) {
1714: newd->common.OF_private =
1715: @@ -1927,6 +2025,9 @@
1716: /* Handle 64 bits memory mapping */
1717: continue;
1718: }
1719: + if (i == 6)
1720: + addr = 0x30; /* PCI ROM */
1721: + else
1722: addr = 0x10 + (i * sizeof(uint32_t));
1723: /* Get region size
1724: * Note: we assume it's always a power of 2
1725: @@ -1935,7 +2036,7 @@
1726: smask = pci_config_readl(bridge, bus, devfn, addr);
1727: if (smask == 0x00000000 || smask == 0xFFFFFFFF)
1728: continue;
1729: - if (smask & 0x00000001) {
1730: + if ((smask & 0x00000001) != 0 && i != 6) {
1731: /* I/O space */
1732: base = io_base;
1733: /* Align to a minimum of 256 bytes (arbitrary) */
1734: @@ -1947,6 +2048,8 @@
1735: /* Align to a minimum of 64 kB (arbitrary) */
1736: min_align = 1 << 16;
1737: amask = 0x0000000F;
1738: + if (i == 6)
1739: + smask |= 1; /* PCI ROM enable */
1740: }
1741: omask = smask & amask;
1742: smask &= ~amask;
1743: @@ -1980,7 +2083,10 @@
1744: if (irq_pin > 0) {
1745: /* assign the IRQ */
1746: irq_pin = ((devfn >> 3) + irq_pin - 1) & 3;
1747: - if (arch == ARCH_PREP) {
1748: + /* XXX: should base it on the PCI bridge type, not the arch */
1749: + switch(arch) {
1750: + case ARCH_PREP:
1751: + {
1752: int elcr_port, val;
1753: irq_line = prep_pci_irqs[irq_pin];
1754: /* set the IRQ to level-sensitive */
1755: @@ -1988,14 +2094,22 @@
1756: val = inb(elcr_port);
1757: val |= 1 << (irq_line & 7);
1758: outb(elcr_port, val);
1759: - } else {
1760: + }
1761: + break;
1762: + case ARCH_MAC99:
1763: irq_line = pmac_pci_irqs[irq_pin];
1764: + break;
1765: + case ARCH_HEATHROW:
1766: + irq_line = heathrow_pci_irqs[irq_pin];
1767: + break;
1768: + default:
1769: + break;
1770: }
1771: }
1772: update_device:
1773: pci_update_device(bridge, newd, min_grant, max_latency, irq_line);
1774: OF_finalize_pci_device(newd->common.OF_private, bus, devfn,
1775: - newd->regions, newd->sizes);
1776: + newd->regions, newd->sizes, irq_line);
1777: /* Call special inits if needed */
1778: if (dev->config_cb != NULL)
1779: (*dev->config_cb)(newd);
1780: @@ -2049,6 +2163,32 @@
1781: case ARCH_CHRP:
1782: /* TODO */
1783: break;
1784: + case ARCH_HEATHROW:
1785: + dev = pci_find_device(0x06, 0x00, 0xFF, checkv, checkp);
1786: + if (dev == NULL)
1787: + return -1;
1788: + fake_host = pci_add_host(hostp, dev,
1789: + (0x06 << 24) | (0x00 << 16) | (0xFF << 8));
1790: + if (fake_host == NULL)
1791: + return -1;
1792: + fake_host->dev.common.type = PCI_FAKE_HOST;
1793: + dev = &grackle_fake_bridge;
1794: + if (dev == NULL)
1795: + goto free_fake_host;
1796: + fake_bridge = pci_add_bridge(fake_host, 0, 0, dev,
1797: + (0x06 << 24) | (0x04 << 16) | (0xFF << 8),
1798: + cfg_base, cfg_len,
1799: + cfg_base + 0x7ec00000,
1800: + cfg_base + 0x7ee00000,
1801: + mem_base, mem_len,
1802: + io_base, io_len,
1803: + rbase, rlen,
1804: + 0,
1805: + &grackle_pci_ops);
1806: + if (fake_bridge == NULL)
1807: + goto free_fake_host;
1808: + fake_bridge->dev.common.type = PCI_FAKE_BRIDGE;
1809: + break;
1810: case ARCH_MAC99:
1811: dev = pci_find_device(0x06, 0x00, 0xFF, checkv, checkp);
1812: if (dev == NULL)
1813: @@ -2167,6 +2307,30 @@
1814: case ARCH_CHRP:
1815: /* TODO */
1816: break;
1817: + case ARCH_HEATHROW:
1818: + cfg_base = 0x80000000;
1819: + cfg_len = 0x7f000000;
1820: + mem_base = 0x80000000;
1821: + mem_len = 0x01000000;
1822: + io_base = 0xfe000000;
1823: + io_len = 0x00800000;
1824: +#if 1
1825: + rbase = 0xfd000000;
1826: + rlen = 0x01000000;
1827: +#else
1828: + rbase = 0x00000000;
1829: + rlen = 0x01000000;
1830: +#endif
1831: + if (pci_check_host(&pci_main, cfg_base, cfg_len,
1832: + mem_base, mem_len, io_base, io_len, rbase, rlen,
1833: + 0x1057, 0x0002) == 0) {
1834: + isa_io_base = io_base;
1835: + busnum++;
1836: + }
1837: + for (curh = pci_main; curh->next != NULL; curh = curh->next)
1838: + continue;
1839: + pci_check_devices(curh);
1840: + break;
1841: case ARCH_MAC99:
1842: /* We are supposed to have 3 host bridges:
1843: * - the uninorth AGP bridge at 0xF0000000
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.