Archipelago » qemu

    s->pci0_hotplug_enable = ~0;

    QTAILQ_FOREACH_SAFE(qdev, &bus->children, sibling, next) {

        PCIDevice *pdev = DO_UPCAST(PCIDevice, qdev, qdev);

        int slot = PCI_SLOT(pdev->devfn);

    QTAILQ_FOREACH_SAFE(qdev, &bus->children, sibling, next) {

        dev = DO_UPCAST(PCIDevice, qdev, qdev);

        if (PCI_SLOT(dev->devfn) == slot && !info->no_hotplug) {

            qdev_free(qdev);

        }

    trace_cpu_set_apic_base(val);

    if (s) {

        info->set_base(s, val);

    }

}

    APICCommonInfo *info;

    if (s) {

        info->set_tpr(s, val);

    }

}

    APICCommonState *s = DO_UPCAST(APICCommonState, busdev.qdev, d);

    APICCommonInfo *info;

    info->external_nmi(s);

}

    }

    s->idx = apic_no++;

    info->init(s);

    sysbus_init_mmio(&s->busdev, &s->io_memory);

{

    APICCommonState *s = opaque;

    APICCommonInfo *info =

    if (info->post_load) {

        info->post_load(s);

{

     PCICirrusVGAState *d = DO_UPCAST(PCICirrusVGAState, dev, dev);

     CirrusVGAState *s = &d->cirrus_vga;

     int16_t device_id = info->device_id;

     /* setup VGA */

    d->eeprom_data[EEPROM_CHECKSUM_REG] = checksum;

    d->nic = qemu_new_nic(&net_e1000_info, &d->conf,

    qemu_format_nic_info_str(&d->nic->nc, macaddr);

{

    EEPRO100State *s = DO_UPCAST(EEPRO100State, dev, pci_dev);

    E100PCIDeviceInfo *e100_device = DO_UPCAST(E100PCIDeviceInfo, pci.qdev,

    TRACE(OTHER, logout("\n"));

    nic_reset(s);

    s->nic = qemu_new_nic(&net_eepro100_info, &s->conf,

    qemu_format_nic_info_str(&s->nic->nc, s->conf.macaddr.a);

    TRACE(OTHER, logout("%s\n", s->nic->nc.info_str));

    uint32_t i, type;

    a->desc = desc;

    dprint(a, 1, "%s: cad %d\n", __FUNCTION__, a->hda.cad);

    AUD_register_card("hda", &a->card);

{

    PICCommonState *s = opaque;

    PICCommonInfo *info =

    if (info->pre_save) {

        info->pre_save(s);

{

    PICCommonState *s = opaque;

    PICCommonInfo *info =

    if (info->post_load) {

        info->post_load(s);

{

    PICCommonState *s = DO_UPCAST(PICCommonState, dev, dev);

    PICCommonInfo *info =

    info->init(s);

    PCIDevice *dev;

    dev = pci_create_simple(bus, devfn, "piix3-ide-xen");

    pci_ide_create_devs(dev, hd_table);

    return dev;

}

        .qdev.name    = "piix3-ide-xen",

        .qdev.size    = sizeof(PCIIDEState),

        .qdev.no_user = 1,

        .init         = pci_piix_ide_initfn,

        .vendor_id    = PCI_VENDOR_ID_INTEL,

        .device_id    = PCI_DEVICE_ID_INTEL_82371SB_1,

    /* reset codecs */

    QTAILQ_FOREACH(qdev, &d->codecs.qbus.children, sibling) {

        cdev = DO_UPCAST(HDACodecDevice, qdev, qdev);

        }

        d->state_sts |= (1 << cdev->cad);

    }

    IntelHDAState *d = DO_UPCAST(IntelHDAState, pci, pci);

    uint8_t *conf = d->pci.config;

    pci_config_set_interrupt_pin(conf, 1);

{

    IOAPICCommonState *s = opaque;

    IOAPICCommonInfo *info =

    if (info->pre_save) {

        info->pre_save(s);

{

    IOAPICCommonState *s = opaque;

    IOAPICCommonInfo *info =

    if (info->post_load) {

        info->post_load(s);

        return -1;

    }

    info->init(s, ioapic_no);

    sysbus_init_mmio(&s->busdev, &s->io_memory);

    qemu_macaddr_default_if_unset(&s->conf.macaddr);

    s->nic = qemu_new_nic(&net_lan9118_info, &s->conf,

    qemu_format_nic_info_str(&s->nic->nc, s->conf.macaddr.a);

    s->eeprom[0] = 0xa5;

    for (i = 0; i < 6; i++) {

                DeviceState *dev;

                QTAILQ_FOREACH(dev, &s->bus.qbus.children, sibling) {

                }

                s->sstat0 |= LSI_SSTAT0_RST;

                lsi_script_scsi_interrupt(s, LSI_SIST0_RST, 0);

    sysbus_init_irq(dev, &s->irq);

    s->nic = qemu_new_nic(&net_mipsnet_info, &s->conf,

    qemu_format_nic_info_str(&s->nic->nc, s->conf.macaddr.a);

    return 0;

    ne2000_reset(s);

    s->nic = qemu_new_nic(&net_ne2000_isa_info, &s->c,

    qemu_format_nic_info_str(&s->nic->nc, s->c.macaddr.a);

    return 0;

    ne2000_reset(s);

    s->nic = qemu_new_nic(&net_ne2000_info, &s->c,

    qemu_format_nic_info_str(&s->nic->nc, s->c.macaddr.a);

    if (!pci_dev->qdev.hotplugged) {

    sysbus_init_irq(dev, &s->irq);

    s->nic = qemu_new_nic(&net_open_eth_info, &s->conf,

    return 0;

}

static int pci_unregister_device(DeviceState *dev)

{

    PCIDevice *pci_dev = DO_UPCAST(PCIDevice, qdev, dev);

    int ret = 0;

    if (info->exit)

static int pci_unplug_device(DeviceState *qdev)

{

    PCIDevice *dev = DO_UPCAST(PCIDevice, qdev, qdev);

    if (info->no_hotplug) {

        qerror_report(QERR_DEVICE_NO_HOTPLUG, info->qdev.name);

void pci_qdev_register(PCIDeviceInfo *info)

{

    info->qdev.init = pci_qdev_init;

    info->qdev.exit = pci_unregister_device;

    info->qdev.bus_info = &pci_bus_info;

    qdev_register(&info->qdev);

        size = 1 << qemu_fls(size);

    }

    else

    pdev->has_rom = true;

    memory_region_init_ram(&pdev->rom, name, size);

    vmstate_register_ram(&pdev->rom, &pdev->qdev);

    }

    /* roughly check if given qdev is pci device */

        qdev->parent_bus->info == &pci_bus_info) {

        *pdev = DO_UPCAST(PCIDevice, qdev, qdev);

        return 0;

    s->poll_timer = qemu_new_timer_ns(vm_clock, pcnet_poll_timer, s);

    qemu_macaddr_default_if_unset(&s->conf.macaddr);

    qemu_format_nic_info_str(&s->nic->nc, s->conf.macaddr.a);

    add_boot_device_path(s->conf.bootindex, dev, "/ethernet-phy@0");

    Property *prop;

    /* device properties */

    if (prop)

        return prop;

    switch (ret) {

    case -EEXIST:

        error_set(errp, QERR_PROPERTY_VALUE_IN_USE,

        break;

    default:

    case -EINVAL:

        error_set(errp, QERR_PROPERTY_VALUE_BAD,

        break;

    case -ENOENT:

        error_set(errp, QERR_PROPERTY_VALUE_NOT_FOUND,

        break;

    case 0:

        break;

     * removed along with it.

     */

    if (!prop || !prop->info->parse) {

        return -1;

    }

    ret = prop->info->parse(dev, prop, value);

    prop = qdev_prop_find(dev, name);

    if (!prop) {

        fprintf(stderr, "%s: property \"%s.%s\" not found\n",

        abort();

    }

    if (prop->info->type != type) {

        fprintf(stderr, "%s: property \"%s.%s\" type mismatch\n",

        abort();

    }

    qdev_prop_cpy(dev, prop, src);

    if (res < 0) {

        error_report("Can't attach drive %s to %s.%s: %s",

                     bdrv_get_device_name(value),

                     name, strerror(-res));

        return -1;

    }

    GlobalProperty *prop;

    QTAILQ_FOREACH(prop, &global_props, next) {

            continue;

        }

        if (qdev_prop_parse(dev, prop->property, prop->value) != 0) {

static BusState *qbus_find(const char *path);

/* Register a new device type.  */

void qdev_register(DeviceInfo *info)

{

    TypeInfo type_info = {};

    type_info.name = info->name;

    type_info.parent = TYPE_DEVICE;

    type_info.instance_size = info->size;

    type_register_static(&type_info);

    assert(bus->info == info->bus_info);

    dev = DEVICE(object_new(info->name));

    dev->parent_bus = bus;

    qdev_prop_set_defaults(dev, dev->parent_bus->info->props);

    qdev_prop_set_globals(dev);

    QTAILQ_INSERT_HEAD(&bus->children, dev, sibling);

    QTAILQ_INIT(&dev->properties);

    dev->state = DEV_STATE_CREATED;

        qdev_property_add_legacy(dev, prop, NULL);

        qdev_property_add_static(dev, prop, NULL);

    }

        qdev_property_add_legacy(dev, prop, NULL);

        qdev_property_add_static(dev, prop, NULL);

    }

    int rc;

    assert(dev->state == DEV_STATE_CREATED);

    if (rc < 0) {

        qdev_free(dev);

        return rc;

    }

                                       dev->instance_id_alias,

                                       dev->alias_required_for_version);

    }

    dev->state = DEV_STATE_INITIALIZED;

    }

    return 0;

}

        qerror_report(QERR_BUS_NO_HOTPLUG, dev->parent_bus->name);

        return -1;

    }

    qdev_hot_removed = true;

}

static int qdev_reset_one(DeviceState *dev, void *opaque)

{

    }

    return 0;

   way is somewhat unclean, and best avoided.  */

void qdev_init_nofail(DeviceState *dev)

{

    if (qdev_init(dev) < 0) {

        error_report("Initialization of device %s failed", info->name);

            bus = QLIST_FIRST(&dev->child_bus);

            qbus_free(bus);

        }

        if (dev->opts)

            qemu_opts_del(dev->opts);

    }

    QTAILQ_REMOVE(&dev->parent_bus->children, dev, sibling);

        if (prop->info->free) {

            prop->info->free(dev, prop);

        }

    const char *sep = " ";

    error_printf("child busses at \"%s\":",

    QLIST_FOREACH(child, &dev->child_bus, sibling) {

        error_printf("%s\"%s\"", sep, child->name);

        sep = ", ";

    error_printf("devices at \"%s\":", bus->name);

    QTAILQ_FOREACH(dev, &bus->children, sibling) {

        if (dev->id)

            error_printf("/\"%s\"", dev->id);

        sep = ", ";

        }

    }

    QTAILQ_FOREACH(dev, &bus->children, sibling) {

            return dev;

        }

    }

    QTAILQ_FOREACH(dev, &bus->children, sibling) {

            return dev;

        }

    }

static void qdev_print(Monitor *mon, DeviceState *dev, int indent)

{

    BusState *child;

                dev->id ? dev->id : "");

    indent += 2;

    if (dev->num_gpio_in) {

    if (dev->num_gpio_out) {

        qdev_printf("gpio-out %d\n", dev->num_gpio_out);

    }

    qdev_print_props(mon, dev, dev->parent_bus->info->props, "bus", indent);

    if (dev->parent_bus->info->print_dev)

        dev->parent_bus->info->print_dev(mon, dev, indent);

            l += snprintf(p + l, size - l, "%s", d);

            g_free(d);

        } else {

        }

    }

    l += snprintf(p + l , size - l, "/");

char *qdev_get_type(DeviceState *dev, Error **errp)

{

}

void qdev_ref(DeviceState *dev)

{

    gchar *type;

    qdev_property_add(dev, name, type, qdev_get_child_property,

                      NULL, qdev_release_child_property,

        if (target) {

            gchar *target_type;

            if (strcmp(target_type, type) == 0) {

                *child = target;

                qdev_ref(target);

#define TYPE_DEVICE "device"

#define DEVICE(obj) OBJECT_CHECK(DeviceState, (obj), TYPE_DEVICE)

typedef struct DeviceClass {

    ObjectClass parent_class;

} DeviceClass;

/* This structure should not be accessed directly.  We declare it here

    enum DevState state;

    QemuOpts *opts;

    int hotplugged;

    BusState *parent_bus;

    int num_gpio_out;

    qemu_irq *gpio_out;

void error_set_from_qdev_prop_error(Error **errp, int ret, DeviceState *dev,

                                    Property *prop, const char *value);

static inline const char *qdev_fw_name(DeviceState *dev)

{

}

char *qdev_get_fw_dev_path(DeviceState *dev);

    s->eeprom.contents[9] = s->conf.macaddr.a[4] | s->conf.macaddr.a[5] << 8;

    s->nic = qemu_new_nic(&net_rtl8139_info, &s->conf,

    qemu_format_nic_info_str(&s->nic->nc, s->conf.macaddr.a);

    s->cplus_txbuffer = NULL;

    sysbus_init_irq(dev, &s->irq);

    qemu_macaddr_default_if_unset(&s->conf.macaddr);

    s->nic = qemu_new_nic(&net_smc91c111_info, &s->conf,

    qemu_format_nic_info_str(&s->nic->nc, s->conf.macaddr.a);

    /* ??? Save/restore.  */

    return 0;

static char *vio_format_dev_name(VIOsPAPRDevice *dev)

{

    char *name;

    /* Device tree style name device@reg */

static int vio_make_devnode(VIOsPAPRDevice *dev,

                            void *fdt)

{

    int vdevice_off, node_off, ret;

    char *dt_name;

        return H_PARAMETER;

    }

    if (mode & ~info->signal_mask) {

        return H_PARAMETER;

    selected = NULL;

    QTAILQ_FOREACH(iter, &bus->bus.children, sibling) {

        /* Only look at VTY devices */

            continue;

        }

            return -1;

        }

    } else {

            /* Create a new hub and chain it on */

            usb_create_simple(bus, "usb-hub");

        }

{

    int ret = 0;

    CCIDCardState *card = DO_UPCAST(CCIDCardState, qdev, qdev);

    USBCCIDState *s =

        DO_UPCAST(USBCCIDState, dev.qdev, card->qdev.parent_bus->parent);

    qemu_macaddr_default_if_unset(&s->conf.macaddr);

    s->nic = qemu_new_nic(&net_usbnet_info, &s->conf,

    qemu_format_nic_info_str(&s->nic->nc, s->conf.macaddr.a);

    snprintf(s->usbstring_mac, sizeof(s->usbstring_mac),

             "%02x%02x%02x%02x%02x%02x",

    memory_region_init_io(&ohci->mem, &ohci_mem_ops, ohci, "ohci", 256);

    ohci->localmem_base = localmem_base;

    usb_packet_init(&ohci->usb_packet);

    ohci->async_td = 0;

{

    VirtConsole *vcon = DO_UPCAST(VirtConsole, port, port);

    VirtIOSerialPortInfo *info = DO_UPCAST(VirtIOSerialPortInfo, qdev,

    if (port->id == 0 && !info->is_console) {

        error_report("Port number 0 on virtio-serial devices reserved for virtconsole devices for backward compatibility.");

    memcpy(&n->mac[0], &conf->macaddr, sizeof(n->mac));

    n->status = VIRTIO_NET_S_LINK_UP;

    qemu_format_nic_info_str(&n->nic->nc, conf->macaddr.a);

    assert(port);

    assert(virtio_queue_ready(vq));

    while (!port->throttled) {

        unsigned int i;

    trace_virtio_serial_handle_control_message_port(port->id);

    switch(cpkt.event) {

    case VIRTIO_CONSOLE_PORT_READY:

{

    VirtIOSerialPort *port = DO_UPCAST(VirtIOSerialPort, dev, qdev);

    VirtIOSerialPortInfo *info = DO_UPCAST(VirtIOSerialPortInfo, qdev,

    VirtIOSerial *vser = port->vser;

    qemu_bh_delete(port->bh);

    qemu_macaddr_default_if_unset(&s->conf.macaddr);

    s->nic = qemu_new_nic(&net_xgmac_enet_info, &s->conf,

    qemu_format_nic_info_str(&s->nic->nc, s->conf.macaddr.a);

    s->regs[XGMAC_ADDR_HIGH(0)] = (s->conf.macaddr.a[5] << 8) |