Statistics
| Branch: | Revision:

root / pc-bios / ohw.diff @ ee4660f9

History | View | Annotate | Download (65 kB)

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", &regs, 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", &regs, 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
+                        &regs, 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
1068
     /* escc is usefull to get MacOS X debug messages */
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", &regs, 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