keep the PID file locked for the lifetime of the process
[qemu.git] / pc-bios / ohw.diff
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 useful 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