git.maemo.org Git - qemu/blob - 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 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