Archipelago » qemu

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

--- OpenHackWare-release-0.4.org/src/bios.h	2005-04-06 23:20:22.000000000 +0200

@@ -64,6 +64,7 @@

     ARCH_CHRP,

     ARCH_MAC99,

 };

 /* Hardware definition(s) */

 part_t *bd_probe (int boot_device);

 bloc_device_t *bd_get (int device);

 void bd_put (bloc_device_t *bd);

 void ide_pci_pmac_register (uint32_t io_base0, uint32_t io_base1,

                             void *OF_private);

                               uint16_t min_grant, uint16_t max_latency);

 void OF_finalize_pci_host (void *dev, int first_bus, int nb_busses);

 void OF_finalize_pci_device (void *dev, uint8_t bus, uint8_t devfn,

                             const unsigned char *name, int devnum,

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

--- OpenHackWare-release-0.4.org/src/bloc.c	2005-04-06 23:21:00.000000000 +0200

@@ -55,6 +55,7 @@

     /* Partitions */

     part_t *parts, *bparts;

     /* Chain */

     bloc_device_t *next;

 };

 }

 /* XXX: to be suppressed */

     }

 }

     return &bd->bparts;

 }

 part_t *bd_probe (int boot_device)

 {

     char devices[] = { /*'a', 'b',*/ 'c', 'd', 'e', 'f', 'm', '\0', };

         tmp = part_probe(bd, force_raw);

         if (boot_device == bd->device) {

             boot_part = tmp;

         }

     }

 /* IDE PCI access for pc */

 static uint8_t ide_pci_port_read (bloc_device_t *bd, int port)

 {

 }

 static ide_ops_t ide_pci_pc_ops = {

 void ide_pci_pc_register (uint32_t io_base0, uint32_t io_base1,

                           uint32_t io_base2, uint32_t io_base3,

 {

     if (ide_pci_ops == NULL) {

         ide_pci_ops = malloc(sizeof(ide_ops_t));

         memcpy(ide_pci_ops, &ide_pci_pc_ops, sizeof(ide_ops_t));

     }

     if ((io_base0 != 0 || io_base1 != 0) &&

 #endif

     }

 }

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

--- OpenHackWare-release-0.4.org/src/libpart/apple.c	2005-03-31 09:23:33.000000000 +0200

+++ OpenHackWare-release-0.4/src/libpart/apple.c	2005-07-03 16:17:41.000000000 +0200

     byte = NVRAM_get_byte(nvram, 0x34);

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

--- OpenHackWare-release-0.4.org/src/of.c	2005-04-06 23:17:26.000000000 +0200

@@ -489,7 +489,7 @@

         ERROR("%s can't alloc new node '%s' name\n", __func__, name);

         return NULL;

     if (new->prop_address == NULL) {

         free(new->prop_name->value);

         free(new->prop_name);

 __attribute__ (( section (".OpenFirmware") ))

 int OF_init (void)

 {

 #endif

     OF_env_t *OF_env;

     OF_node_t *als, *opt, *chs, *pks;

         return -1;

     }

     OF_prop_string_new(OF_env, OF_node_root, "device_type", "bootrom");

 #if 0

     OF_prop_string_new(OF_env, OF_node_root, "copyright", copyright);

 #else

         range.size = 0x00800000;

         OF_property_new(OF_env, rom, "ranges", &range, sizeof(OF_range_t));

         OF_prop_int_new(OF_env, rom, "#address-cells", 1);

         OF_property_new(OF_env, brom, "reg", &regs, sizeof(OF_regprop_t));

         OF_prop_string_new(OF_env, brom, "write-characteristic", "flash");

         OF_prop_string_new(OF_env, brom, "BootROM-build-date",

         OF_prop_string_new(OF_env, brom, "copyright", copyright);

         OF_prop_string_new(OF_env, brom, "model", BIOS_str);

         OF_prop_int_new(OF_env, brom, "result", 0);

         {

             /* Hack taken 'as-is' from PearPC */

             unsigned char info[] = {

         OF_node_put(OF_env, brom);

         OF_node_put(OF_env, rom);

     }

     /* "/nvram@fff04000" node */

     {

         OF_regprop_t regs;

         OF_prop_int_new(OF_env, chs, "nvram", OF_pack_handle(OF_env, nvr));

         OF_node_put(OF_env, nvr);

     }

     /* "/pseudo-hid" : hid emulation as Apple does */

     {

         OF_node_t *hid;

         }

         OF_node_put(OF_env, hid);

     }

 #if 1 /* This is mandatory for claim to work

        * but I don't know where it should really be (in cpu ?)

     /* "/options/boot-args" node */

     {

         /* Ask MacOS X to print debug messages */

         //        OF_prop_string_new(OF_env, chs, "machargs", args);

         //        OF_prop_string_new(OF_env, opt, "boot-command", args);

     if (dev->acells != 0)

         OF_prop_int_new(OF_env, node, "#address-cells", dev->acells);

     if (dev->scells != 0)

     dprintf("Done %p %p\n", parent, node);

     return node;

     OF_env_t *OF_env;

     pci_range_t ranges[3];

     OF_regprop_t regs[1];

     OF_env = OF_env_main;

     dprintf("register PCI host '%s' '%s' '%s' '%s'\n",

         ERROR("Cannot create pci host\n");

         return NULL;

     }

     regs[0].address = cfg_base;

     regs[0].size = cfg_len;

     OF_property_new(OF_env, pci_host, "reg", regs, sizeof(OF_regprop_t));

     return pci_dev;

 }

 void OF_finalize_pci_host (void *dev, int first_bus, int nb_busses)

 {

     OF_env_t *OF_env;

     regs[0].address = first_bus;

     regs[0].size = nb_busses;

     OF_property_new(OF_env, dev, "bus-range", regs, sizeof(OF_regprop_t));

 {

     OF_env_t *OF_env;

     pci_reg_prop_t pregs[6], rregs[6];

     int i, j, k;

     OF_env = OF_env_main;

     if (regions[0] != 0x00000000)

         OF_prop_int_set(OF_env, dev, "address", regions[0] & ~0x0000000F);

     for (i = 0, j = 0, k = 0; i < 6; i++) {

     } else {

         OF_property_new(OF_env, dev, "assigned-addresses", NULL, 0);

     }

     {

         OF_prop_t *prop_name = ((OF_node_t *)dev)->prop_name;

     return 0;

 }

 void OF_finalize_pci_macio (void *dev, uint32_t base_address, uint32_t size,

                             void *private_data)

 {

     pci_reg_prop_t pregs[2];

     OF_node_t *mio, *chs, *als;

     uint16_t pic_phandle;

     OF_DPRINTF("mac-io: %p\n", dev);

     OF_env = OF_env_main;

     mio = dev;

     mio->private_data = private_data;

     pregs[0].addr.hi = 0x00000000;

     OF_property_new(OF_env, mio, "ranges",

                     &pregs, sizeof(pci_reg_prop_t));

 #if 0

     OF_property_new(OF_env, mio, "assigned-addresses",

                     &pregs, sizeof(pci_reg_prop_t));

 #endif

+

+    if (arch == ARCH_HEATHROW) {

+        /* Heathrow PIC */

+        OF_node_put(OF_env, mpic);

+        rec_len = 6;

+    } else {

         OF_regprop_t regs[4];

         OF_node_t *mpic;

         mpic = OF_node_new(OF_env, mio, "interrupt-controller", 0x40000);

         pic_phandle = OF_pack_handle(OF_env, mpic);

         OF_prop_int_new(OF_env, chs, "interrupt-controller", pic_phandle);

         OF_node_put(OF_env, mpic);

     /* escc is usefull to get MacOS X debug messages */

     {

         OF_regprop_t regs[8];

         OF_node_put(OF_env, scc);

     }

 #endif

     /* Timer */

     {

         OF_node_t *tmr;

                         regs, sizeof(OF_regprop_t));

         OF_node_put(OF_env, tmr);

     }

         OF_regprop_t regs[1];

 #if 0 // THIS IS A HACK AND IS COMPLETELY ABSURD !

       // (but needed has Qemu doesn't emulate via-pmu).

         regs[0].size = 0x00002000;

         OF_property_new(OF_env, via, "reg", regs, sizeof(OF_regprop_t));

         OF_prop_int_new(OF_env, via, "interrupt-parent", pic_phandle);

         /* ADB pseudo-device */

         adb = OF_node_new(OF_env, via, "adb", OF_ADDRESS_NONE);

         if (adb == NULL) {

         OF_prop_int_new(OF_env, adb, "#size-cells", 0);

         OF_pack_get_path(OF_env, tmp, 512, adb);

         OF_prop_string_new(OF_env, als, "adb", tmp);

         rtc = OF_node_new(OF_env, via, "rtc", OF_ADDRESS_NONE);

         if (rtc == NULL) {

         OF_prop_string_new(OF_env, rtc, "compatible", "rtc");

 #endif

         OF_node_put(OF_env, rtc);

+        OF_node_put(OF_env, pmgt);

+    }

+

  out:

     //    OF_node_put(OF_env, mio);

     OF_node_put(OF_env, chs);

 /*****************************************************************************/

 /* Fake package */

 static void OF_method_fake (OF_env_t *OF_env)

     /* As we get a 1:1 mapping, do nothing */

     ihandle = popd(OF_env);

     args = (void *)popd(OF_env);

+    size = popd(OF_env);

+    virt = popd(OF_env);

+    address = popd(OF_env);

                virt, size);

     pushd(OF_env, 0);

 }

     OF_prop_string_new(OF_env, dsk, "device_type", "block");

     OF_prop_string_new(OF_env, dsk, "category", type);

     OF_prop_int_new(OF_env, dsk, "device_id", devnum);

     OF_method_new(OF_env, dsk, "open", &OF_blockdev_open);

     OF_method_new(OF_env, dsk, "seek", &OF_blockdev_seek);

     OF_method_new(OF_env, dsk, "read", &OF_blockdev_read);

 }

 void OF_vga_register (const unsigned char *name, unused uint32_t address,

 {

     OF_env_t *OF_env;

     unsigned char tmp[OF_NAMELEN_MAX];

     OF_prop_string_new(OF_env, als, "display", tmp);

     OF_node_put(OF_env, als);

     /* XXX: may also need read-rectangle */

  out:

     OF_node_put(OF_env, disp);

 }

         break;

     case 0x233441d3: /* MacOS X 10.2 and OpenDarwin 1.41 */

         /* Create "memory-map" pseudo device */

         /* Find "/packages" */

         chs = OF_pack_find_by_name(OF_env, OF_node_root, "/chosen");

         if (chs == NULL) {

             ERROR("Cannot get '/chosen'\n");

             break;

         }

             map = OF_node_new(OF_env, chs, "memory-map", OF_ADDRESS_NONE);

             if (map == NULL) {

                 pushd(OF_env, -1);

             OF_node_put(OF_env, map);

             OF_node_put(OF_env, chs);

             pushd(OF_env, phandle);

         break;

     case 0x32a2d18e: /* MacOS X 10.2 and OpenDarwin 6.02 */

         /* Return screen ihandle */

     case 0x4ad41f2d:

         /* Yaboot: wait 10 ms: sure ! */

         break;

         printf("Call %0x NOT IMPLEMENTED !\n", crc);

         bug();

         break;

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

--- OpenHackWare-release-0.4.org/src/pci.c	2005-03-31 09:23:33.000000000 +0200

@@ -99,8 +99,8 @@

     uint16_t min_grant;

     uint16_t max_latency;

     },

     {

         0x1057, 0x4801, NULL,

     { 

         0x106B, 0x0022,

                                       uint8_t min_grant, uint8_t max_latency,

                                       int irq_line)

 {

     int i;

     device->min_grant = min_grant;

         printf("MAP PCI device %d:%d to IRQ %d\n",

                device->bus, device->devfn, irq_line);

     }

         }

     }

 }

         goto out;

     }

     ret = (pci_u_t *)newd;

     /* register PCI device in OF tree */

     if (bridge->dev.common.type == PCI_FAKE_BRIDGE) {

         newd->common.OF_private =

             /* Handle 64 bits memory mapping */

             continue;

         }

         addr = 0x10 + (i * sizeof(uint32_t));

         /* Get region size

          * Note: we assume it's always a power of 2

         smask = pci_config_readl(bridge, bus, devfn, addr);

         if (smask == 0x00000000 || smask == 0xFFFFFFFF)

             continue;

             /* I/O space */

             base = io_base;

             /* Align to a minimum of 256 bytes (arbitrary) */

             /* Align to a minimum of 64 kB (arbitrary) */

             min_align = 1 << 16;

             amask = 0x0000000F;

         }

         omask = smask & amask;

         smask &= ~amask;

     if (irq_pin > 0) {

         /* assign the IRQ */

         irq_pin = ((devfn >> 3) + irq_pin - 1) & 3;

             int elcr_port, val;

             irq_line = prep_pci_irqs[irq_pin];

             /* set the IRQ to level-sensitive */

             val = inb(elcr_port);

             val |= 1 << (irq_line & 7);

             outb(elcr_port, val);

     /* Call special inits if needed */

     if (dev->config_cb != NULL)

         (*dev->config_cb)(newd);

     case ARCH_CHRP:

         /* TODO */

         break;

     case ARCH_MAC99:

         dev = pci_find_device(0x06, 0x00, 0xFF, checkv, checkp);

         if (dev == NULL)

     case ARCH_CHRP:

         /* TODO */

         break;