自学教程：C++ DEVICE函数代码示例

int qmp_pc_dimm_device_list(Object *obj, void *opaque){    MemoryDeviceInfoList ***prev = opaque;    if (object_dynamic_cast(obj, TYPE_PC_DIMM)) {        DeviceState *dev = DEVICE(obj);        if (dev->realized) {            MemoryDeviceInfoList *elem = g_new0(MemoryDeviceInfoList, 1);            MemoryDeviceInfo *info = g_new0(MemoryDeviceInfo, 1);            PCDIMMDeviceInfo *di = g_new0(PCDIMMDeviceInfo, 1);            DeviceClass *dc = DEVICE_GET_CLASS(obj);            PCDIMMDevice *dimm = PC_DIMM(obj);            if (dev->id) {                di->has_id = true;                di->id = g_strdup(dev->id);            }            di->hotplugged = dev->hotplugged;            di->hotpluggable = dc->hotpluggable;            di->addr = dimm->addr;            di->slot = dimm->slot;            di->node = dimm->node;            di->size = object_property_get_int(OBJECT(dimm), PC_DIMM_SIZE_PROP,                                               NULL);            di->memdev = object_get_canonical_path(OBJECT(dimm->hostmem));            info->u.dimm.data = di;            elem->value = info;            elem->next = NULL;            **prev = elem;            *prev = &elem->next;        }    }    object_child_foreach(obj, qmp_pc_dimm_device_list, opaque);    return 0;}

static void reset(DeviceState *d){    sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(d);    sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);    sPAPRDREntitySense state;    trace_spapr_drc_reset(drck->get_index(drc));    /* immediately upon reset we can safely assume DRCs whose devices     * are pending removal can be safely removed, and that they will     * subsequently be left in an ISOLATED state. move the DRC to this     * state in these cases (which will in turn complete any pending     * device removals)     */    if (drc->awaiting_release) {        drck->set_isolation_state(drc, SPAPR_DR_ISOLATION_STATE_ISOLATED);        /* generally this should also finalize the removal, but if the device         * hasn't yet been configured we normally defer removal under the         * assumption that this transition is taking place as part of device         * configuration. so check if we're still waiting after this, and         * force removal if we are         */        if (drc->awaiting_release) {            drck->detach(drc, DEVICE(drc->dev), drc->detach_cb,                         drc->detach_cb_opaque, NULL);        }        /* non-PCI devices may be awaiting a transition to UNUSABLE */        if (drc->type != SPAPR_DR_CONNECTOR_TYPE_PCI &&            drc->awaiting_release) {            drck->set_allocation_state(drc, SPAPR_DR_ALLOCATION_STATE_UNUSABLE);        }    }    drck->entity_sense(drc, &state);    if (state == SPAPR_DR_ENTITY_SENSE_PRESENT) {        drck->set_signalled(drc);    }}

static void set_vlan(Object *obj, Visitor *v, const char *name, void *opaque,                     Error **errp){    DeviceState *dev = DEVICE(obj);    Property *prop = opaque;    NICPeers *peers_ptr = qdev_get_prop_ptr(dev, prop);    NetClientState **ptr = &peers_ptr->ncs[0];    Error *local_err = NULL;    int32_t id;    NetClientState *hubport;    if (dev->realized) {        qdev_prop_set_after_realize(dev, name, errp);        return;    }    visit_type_int32(v, name, &id, &local_err);    if (local_err) {        error_propagate(errp, local_err);        return;    }    if (id == -1) {        *ptr = NULL;        return;    }    if (*ptr) {        error_set_from_qdev_prop_error(errp, -EINVAL, dev, prop, name);        return;    }    hubport = net_hub_port_find(id);    if (!hubport) {        error_setg(errp, QERR_INVALID_PARAMETER_VALUE,                   name, prop->info->name);        return;    }    *ptr = hubport;}

static void pci_piix_init_ports(PCIIDEState *d) {    static const struct {        int iobase;        int iobase2;        int isairq;    } port_info[] = {        {0x1f0, 0x3f6, 14},        {0x170, 0x376, 15},    };    int i;    for (i = 0; i < 2; i++) {        ide_bus_new(&d->bus[i], sizeof(d->bus[i]), DEVICE(d), i, 2);        ide_init_ioport(&d->bus[i], NULL, port_info[i].iobase,                        port_info[i].iobase2);        ide_init2(&d->bus[i], isa_get_irq(NULL, port_info[i].isairq));        bmdma_init(&d->bus[i], &d->bmdma[i], d);        d->bmdma[i].bus = &d->bus[i];        qemu_add_vm_change_state_handler(d->bus[i].dma->ops->restart_cb,                                         &d->bmdma[i].dma);    }}

DeviceState *qdev_try_create(BusState *bus, const char *type){#if 0    DeviceState *dev;    if (object_class_by_name(NULL, type) == NULL) { // no need to fix. aq        return NULL;    }    dev = DEVICE(object_new(NULL, type));   // no need to fix. aq    if (!dev) {        return NULL;    }    if (!bus) {        bus = sysbus_get_default();    }    qdev_set_parent_bus(dev, bus);    object_unref(OBJECT(dev));    return dev;#endif    return NULL;}

static void pci_ebus_realize(PCIDevice *pci_dev, Error **errp){    EbusState *s = DO_UPCAST(EbusState, pci_dev, pci_dev);    if (!isa_bus_new(DEVICE(pci_dev), get_system_memory(),                     pci_address_space_io(pci_dev), errp)) {        return;    }    pci_dev->config[0x04] = 0x06; // command = bus master, pci mem    pci_dev->config[0x05] = 0x00;    pci_dev->config[0x06] = 0xa0; // status = fast back-to-back, 66MHz, no error    pci_dev->config[0x07] = 0x03; // status = medium devsel    pci_dev->config[0x09] = 0x00; // programming i/f    pci_dev->config[0x0D] = 0x0a; // latency_timer    memory_region_init_alias(&s->bar0, OBJECT(s), "bar0", get_system_io(),                             0, 0x1000000);    pci_register_bar(pci_dev, 0, PCI_BASE_ADDRESS_SPACE_MEMORY, &s->bar0);    memory_region_init_alias(&s->bar1, OBJECT(s), "bar1", get_system_io(),                             0, 0x4000);    pci_register_bar(pci_dev, 1, PCI_BASE_ADDRESS_SPACE_IO, &s->bar1);}

void logfile(const char *format, ...){	if (__debug)	{		if (!debug_file)		{			char logpath[20];			snprintf(logpath, MAX_CHARACTERS(logpath), "%s:/YABDM.log", DEVICE(0));			debug_file = fopen(logpath, "a");			if (!debug_file) return;		}				WiiDiscLight(true);				va_list args;		va_start(args, format);		vfprintf(debug_file, format, args);		fflush(debug_file);		va_end(args);				WiiDiscLight(false);	}}

int pci_piix3_xen_ide_unplug(DeviceState *dev){    PCIIDEState *pci_ide;    DriveInfo *di;    int i = 0;    pci_ide = PCI_IDE(dev);    for (; i < 3; i++) {        di = drive_get_by_index(IF_IDE, i);        if (di != NULL && !di->media_cd) {            DeviceState *ds = bdrv_get_attached_dev(di->bdrv);            if (ds) {                bdrv_detach_dev(di->bdrv, ds);            }            bdrv_close(di->bdrv);            pci_ide->bus[di->bus].ifs[di->unit].bs = NULL;            drive_del(di);        }    }    qdev_reset_all(DEVICE(dev));    return 0;}

PCIESlot *ioh3420_init(PCIBus *bus, int devfn, bool multifunction,                         const char *bus_name, pci_map_irq_fn map_irq,                         uint8_t port, uint8_t chassis, uint16_t slot){    PCIDevice *d;    PCIBridge *br;    DeviceState *qdev;    d = pci_create_multifunction(bus, devfn, multifunction, "ioh3420");    if (!d) {        return NULL;    }    br = PCI_BRIDGE(d);    qdev = DEVICE(d);    pci_bridge_map_irq(br, bus_name, map_irq);    qdev_prop_set_uint8(qdev, "port", port);    qdev_prop_set_uint8(qdev, "chassis", chassis);    qdev_prop_set_uint16(qdev, "slot", slot);    qdev_init_nofail(qdev);    return PCIE_SLOT(d);}

static void set_chr(Object *obj, Visitor *v, const char *name, void *opaque,                    Error **errp){    DeviceState *dev = DEVICE(obj);    Error *local_err = NULL;    Property *prop = opaque;    CharBackend *be = qdev_get_prop_ptr(dev, prop);    CharDriverState *s;    char *str;    if (dev->realized) {        qdev_prop_set_after_realize(dev, name, errp);        return;    }    visit_type_str(v, name, &str, &local_err);    if (local_err) {        error_propagate(errp, local_err);        return;    }    if (!*str) {        g_free(str);        be->chr = NULL;        return;    }    s = qemu_chr_find(str);    if (s == NULL) {        error_setg(errp, "Property '%s.%s' can't find value '%s'",                   object_get_typename(obj), prop->name, str);    } else if (!qemu_chr_fe_init(be, s, errp)) {        error_prepend(errp, "Property '%s.%s' can't take value '%s': ",                      object_get_typename(obj), prop->name, str);    }    g_free(str);}

static int raven_pcihost_init(SysBusDevice *dev){    PCIHostState *h = PCI_HOST_BRIDGE(dev);    PREPPCIState *s = RAVEN_PCI_HOST_BRIDGE(dev);    MemoryRegion *address_space_mem = get_system_memory();    MemoryRegion *address_space_io = get_system_io();    PCIBus *bus;    int i;    for (i = 0; i < 4; i++) {        sysbus_init_irq(dev, &s->irq[i]);    }    bus = pci_register_bus(DEVICE(dev), NULL,                           prep_set_irq, prep_map_irq, s->irq,                           address_space_mem, address_space_io, 0, 4);    h->bus = bus;    memory_region_init_io(&h->conf_mem, &pci_host_conf_be_ops, s,                          "pci-conf-idx", 1);    sysbus_add_io(dev, 0xcf8, &h->conf_mem);    sysbus_init_ioports(&h->busdev, 0xcf8, 1);    memory_region_init_io(&h->data_mem, &pci_host_data_be_ops, s,                          "pci-conf-data", 1);    sysbus_add_io(dev, 0xcfc, &h->data_mem);    sysbus_init_ioports(&h->busdev, 0xcfc, 1);    memory_region_init_io(&h->mmcfg, &PPC_PCIIO_ops, s, "pciio", 0x00400000);    memory_region_add_subregion(address_space_mem, 0x80800000, &h->mmcfg);    memory_region_init_io(&s->intack, &PPC_intack_ops, s, "pci-intack", 1);    memory_region_add_subregion(address_space_mem, 0xbffffff0, &s->intack);    pci_create_simple(bus, 0, "raven");    return 0;}

/* Context: QEMU global mutex held */void virtio_blk_data_plane_stop(VirtIOBlockDataPlane *s){    BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(s->vdev)));    VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);    VirtIOBlock *vblk = VIRTIO_BLK(s->vdev);    if (!vblk->dataplane_started || s->stopping) {        return;    }    /* Better luck next time. */    if (s->disabled) {        s->disabled = false;        vblk->dataplane_started = false;        return;    }    s->stopping = true;    trace_virtio_blk_data_plane_stop(s);    aio_context_acquire(s->ctx);    /* Stop notifications for new requests from guest */    virtio_queue_aio_set_host_notifier_handler(s->vq, s->ctx, false, false);    /* Drain and switch bs back to the QEMU main loop */    blk_set_aio_context(s->conf->conf.blk, qemu_get_aio_context());    aio_context_release(s->ctx);    k->set_host_notifier(qbus->parent, 0, false);    /* Clean up guest notifier (irq) */    k->set_guest_notifiers(qbus->parent, 1, false);    vblk->dataplane_started = false;    s->stopping = false;}

/* Context: QEMU global mutex held */void virtio_scsi_dataplane_stop(VirtIOSCSI *s){    BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(s)));    VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);    VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(s);    int i;    if (!s->dataplane_started || s->dataplane_stopping) {        return;    }    /* Better luck next time. */    if (s->dataplane_fenced) {        s->dataplane_fenced = false;        s->dataplane_started = false;        return;    }    s->dataplane_stopping = true;    assert(s->ctx == iothread_get_aio_context(vs->conf.iothread));    aio_context_acquire(s->ctx);    virtio_scsi_clear_aio(s);    blk_drain_all(); /* ensure there are no in-flight requests */    aio_context_release(s->ctx);    for (i = 0; i < vs->conf.num_queues + 2; i++) {        k->set_host_notifier(qbus->parent, i, false);    }    /* Clean up guest notifier (irq) */    k->set_guest_notifiers(qbus->parent, vs->conf.num_queues + 2, false);    s->dataplane_stopping = false;    s->dataplane_started = false;}

/*--------------------------------------------------------------------------- *  Find device object by handle * *  /param dev Device handle * *  /return Matching device object or NULL *----------------------------------------------------------------------------*/OWF_API_CALL WFC_DEVICE*WFC_Device_FindByHandle(WFCDevice dev){    WFCint i = 0, length = 0;    WFC_DEVICE* pDevice = NULL;        if (dev == WFC_INVALID_HANDLE)    {        return NULL;    }        WFC_Devices_Initialize();        length = gPhyDevice.iDeviceInstanceArray.length;    for (i = 0; i < length; ++i)        {        pDevice = DEVICE(OWF_Array_GetItemAt(&(gPhyDevice.iDeviceInstanceArray), i));        if (pDevice->handle == dev)            {            return pDevice;            }        }    return NULL;}

static int virtio_balloon_device_init(VirtIODevice *vdev){    DeviceState *qdev = DEVICE(vdev);    VirtIOBalloon *s = VIRTIO_BALLOON(vdev);    int ret;    virtio_init(vdev, "virtio-balloon", VIRTIO_ID_BALLOON, 8);    vdev->get_config = virtio_balloon_get_config;    vdev->set_config = virtio_balloon_set_config;    vdev->get_features = virtio_balloon_get_features;    ret = qemu_add_balloon_handler(virtio_balloon_to_target,                                   virtio_balloon_stat, s);    if (ret < 0) {        virtio_common_cleanup(VIRTIO_DEVICE(s));        return -1;    }    s->ivq = virtio_add_queue(vdev, 128, virtio_balloon_handle_output);    s->dvq = virtio_add_queue(vdev, 128, virtio_balloon_handle_output);    s->svq = virtio_add_queue(vdev, 128, virtio_balloon_receive_stats);    register_savevm(qdev, "virtio-balloon", -1, 1,                    virtio_balloon_save, virtio_balloon_load, s);    object_property_add(OBJECT(qdev), "guest-stats", "guest statistics",                        balloon_stats_get_all, NULL, NULL, s, NULL);    object_property_add(OBJECT(qdev), "guest-stats-polling-interval", "int",                        balloon_stats_get_poll_interval,                        balloon_stats_set_poll_interval,                        NULL, s, NULL);    return 0;}

static void ipi_realize(DeviceState *dev, Error **errp){    IPI *s = XILINX_IPI(dev);    const char *prefix = object_get_canonical_path(OBJECT(dev));    unsigned int i;    for (i = 0; i < ARRAY_SIZE(ipi_regs_info); ++i) {        DepRegisterInfo *r = &s->regs_info[ipi_regs_info[i].decode.addr/4];        *r = (DepRegisterInfo) {            .data = (uint8_t *)&s->regs[                    ipi_regs_info[i].decode.addr/4],            .data_size = sizeof(uint32_t),            .access = &ipi_regs_info[i],            .debug = XILINX_IPI_ERR_DEBUG,            .prefix = prefix,            .opaque = s,        };        dep_register_init(r);        qdev_pass_all_gpios(DEVICE(r), dev);    }    qdev_init_gpio_in_named(dev, ipi_handler, "IPI_INPUTS", 32);    qdev_init_gpio_in_named(dev, obs_handler, "OBS_INPUTS", 32);}static void ipi_init(Object *obj){    IPI *s = XILINX_IPI(obj);    SysBusDevice *sbd = SYS_BUS_DEVICE(obj);    memory_region_init_io(&s->iomem, obj, &ipi_ops, s,                          TYPE_XILINX_IPI, R_MAX * 4);    sysbus_init_mmio(sbd, &s->iomem);    sysbus_init_irq(sbd, &s->irq);}

/* * This function switches from/to the generic ioeventfd handler. * assign==false means 'use generic ioeventfd handler'. */int virtio_bus_set_host_notifier(VirtioBusState *bus, int n, bool assign){    VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(bus);    DeviceState *proxy = DEVICE(BUS(bus)->parent);    if (!k->ioeventfd_started) {        return -ENOSYS;    }    k->ioeventfd_set_disabled(proxy, assign);    if (assign) {        /*         * Stop using the generic ioeventfd, we are doing eventfd handling         * ourselves below         *         * FIXME: We should just switch the handler and not deassign the         * ioeventfd.         * Otherwise, there's a window where we don't have an         * ioeventfd and we may end up with a notification where         * we don't expect one.         */        virtio_bus_stop_ioeventfd(bus);    }    return set_host_notifier_internal(proxy, bus, n, assign, false);}

static void set_string(Object *obj, Visitor *v, void *opaque,                       const char *name, Error **errp){    DeviceState *dev = DEVICE(obj);    Property *prop = opaque;    char **ptr = qdev_get_prop_ptr(dev, prop);    Error *local_err = NULL;    char *str;    if (dev->state != DEV_STATE_CREATED) {        error_set(errp, QERR_PERMISSION_DENIED);        return;    }    visit_type_str(v, &str, name, &local_err);    if (local_err) {        error_propagate(errp, local_err);        return;    }    if (*ptr) {        g_free(*ptr);    }    *ptr = str;}

static void set_string(Object *obj, Visitor *v, void *opaque,                       const char *name, Error **errp){    DeviceState *dev = DEVICE(obj);    Property *prop = opaque;    char **ptr = qdev_get_prop_ptr(dev, prop);    Error *local_err = NULL;    char *str;    if (dev->realized) {        qdev_prop_set_after_realize(dev, name, errp);        return;    }    visit_type_str(v, &str, name, &local_err);    if (local_err) {        error_propagate(errp, local_err);        return;    }    if (*ptr) {        g_free(*ptr);    }    *ptr = str;}

static int goldfish_fb_init(SysBusDevice *sbdev){    DeviceState *dev = DEVICE(sbdev);    struct goldfish_fb_state *s = GOLDFISH_FB(dev);    dev->id = g_strdup(TYPE_GOLDFISH_FB);    sysbus_init_irq(sbdev, &s->irq);    s->con = graphic_console_init(dev, 0, &goldfish_fb_ops, s);    s->dpi = 165;  /* TODO: Find better way to get actual value ! */    s->format = HAL_PIXEL_FORMAT_RGB_565;    memory_region_init_io(&s->iomem, OBJECT(s), &goldfish_fb_iomem_ops, s,            "goldfish_fb", 0x100);    sysbus_init_mmio(sbdev, &s->iomem);    register_savevm(dev, "goldfish_fb", 0, GOLDFISH_FB_SAVE_VERSION,                     goldfish_fb_save, goldfish_fb_load, s);    return 0;}

static void witherspoon_bmc_i2c_init(AspeedBoardState *bmc){    AspeedSoCState *soc = &bmc->soc;    uint8_t *eeprom_buf = g_malloc0(8 * 1024);    i2c_create_slave(aspeed_i2c_get_bus(DEVICE(&soc->i2c), 3), TYPE_PCA9552,                     0x60);    i2c_create_slave(aspeed_i2c_get_bus(DEVICE(&soc->i2c), 4), "tmp423", 0x4c);    i2c_create_slave(aspeed_i2c_get_bus(DEVICE(&soc->i2c), 5), "tmp423", 0x4c);    /* The Witherspoon expects a TMP275 but a TMP105 is compatible */    i2c_create_slave(aspeed_i2c_get_bus(DEVICE(&soc->i2c), 9), TYPE_TMP105,                     0x4a);    /* The witherspoon board expects Epson RX8900 I2C RTC but a ds1338 is     * good enough */    i2c_create_slave(aspeed_i2c_get_bus(DEVICE(&soc->i2c), 11), "ds1338", 0x32);    smbus_eeprom_init_one(aspeed_i2c_get_bus(DEVICE(&soc->i2c), 11), 0x51,                          eeprom_buf);    i2c_create_slave(aspeed_i2c_get_bus(DEVICE(&soc->i2c), 11), TYPE_PCA9552,                     0x60);}

static void ast2400_init(Object *obj){    AST2400State *s = AST2400(obj);    s->cpu = cpu_arm_init("arm926");    object_initialize(&s->vic, sizeof(s->vic), TYPE_ASPEED_VIC);    object_property_add_child(obj, "vic", OBJECT(&s->vic), NULL);    qdev_set_parent_bus(DEVICE(&s->vic), sysbus_get_default());    object_initialize(&s->timerctrl, sizeof(s->timerctrl), TYPE_ASPEED_TIMER);    object_property_add_child(obj, "timerctrl", OBJECT(&s->timerctrl), NULL);    qdev_set_parent_bus(DEVICE(&s->timerctrl), sysbus_get_default());    object_initialize(&s->i2c, sizeof(s->i2c), TYPE_ASPEED_I2C);    object_property_add_child(obj, "i2c", OBJECT(&s->i2c), NULL);    qdev_set_parent_bus(DEVICE(&s->i2c), sysbus_get_default());    object_initialize(&s->scu, sizeof(s->scu), TYPE_ASPEED_SCU);    object_property_add_child(obj, "scu", OBJECT(&s->scu), NULL);    qdev_set_parent_bus(DEVICE(&s->scu), sysbus_get_default());    qdev_prop_set_uint32(DEVICE(&s->scu), "silicon-rev",                         AST2400_A0_SILICON_REV);    object_property_add_alias(obj, "hw-strap1", OBJECT(&s->scu),                              "hw-strap1", &error_abort);    object_property_add_alias(obj, "hw-strap2", OBJECT(&s->scu),                              "hw-strap2", &error_abort);    object_initialize(&s->smc, sizeof(s->smc), "aspeed.smc.fmc");    object_property_add_child(obj, "smc", OBJECT(&s->smc), NULL);    qdev_set_parent_bus(DEVICE(&s->smc), sysbus_get_default());    object_initialize(&s->spi, sizeof(s->spi), "aspeed.smc.spi");    object_property_add_child(obj, "spi", OBJECT(&s->spi), NULL);    qdev_set_parent_bus(DEVICE(&s->spi), sysbus_get_default());}

static void fsl_imx31_init(Object *obj){    FslIMX31State *s = FSL_IMX31(obj);    int i;    object_initialize(&s->cpu, sizeof(s->cpu), "arm1136-" TYPE_ARM_CPU);    object_initialize(&s->avic, sizeof(s->avic), TYPE_IMX_AVIC);    qdev_set_parent_bus(DEVICE(&s->avic), sysbus_get_default());    object_initialize(&s->ccm, sizeof(s->ccm), TYPE_IMX31_CCM);    qdev_set_parent_bus(DEVICE(&s->ccm), sysbus_get_default());    for (i = 0; i < FSL_IMX31_NUM_UARTS; i++) {        object_initialize(&s->uart[i], sizeof(s->uart[i]), TYPE_IMX_SERIAL);        qdev_set_parent_bus(DEVICE(&s->uart[i]), sysbus_get_default());    }    object_initialize(&s->gpt, sizeof(s->gpt), TYPE_IMX31_GPT);    qdev_set_parent_bus(DEVICE(&s->gpt), sysbus_get_default());    for (i = 0; i < FSL_IMX31_NUM_EPITS; i++) {        object_initialize(&s->epit[i], sizeof(s->epit[i]), TYPE_IMX_EPIT);        qdev_set_parent_bus(DEVICE(&s->epit[i]), sysbus_get_default());    }    for (i = 0; i < FSL_IMX31_NUM_I2CS; i++) {        object_initialize(&s->i2c[i], sizeof(s->i2c[i]), TYPE_IMX_I2C);        qdev_set_parent_bus(DEVICE(&s->i2c[i]), sysbus_get_default());    }    for (i = 0; i < FSL_IMX31_NUM_GPIOS; i++) {        object_initialize(&s->gpio[i], sizeof(s->gpio[i]), TYPE_IMX_GPIO);        qdev_set_parent_bus(DEVICE(&s->gpio[i]), sysbus_get_default());    }}

static int vhost_scsi_start(VHostSCSI *s){    int ret, abi_version, i;    VirtIODevice *vdev = VIRTIO_DEVICE(s);    BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(vdev)));    VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);    if (!k->set_guest_notifiers) {        error_report("binding does not support guest notifiers");        return -ENOSYS;    }    ret = ioctl(s->dev.control, VHOST_SCSI_GET_ABI_VERSION, &abi_version);    if (ret < 0) {        return -errno;    }    if (abi_version > VHOST_SCSI_ABI_VERSION) {        error_report("vhost-scsi: The running tcm_vhost kernel abi_version:"                     " %d is greater than vhost_scsi userspace supports: %d, please"                     " upgrade your version of QEMU/n", abi_version,                     VHOST_SCSI_ABI_VERSION);        return -ENOSYS;    }    ret = vhost_dev_enable_notifiers(&s->dev, vdev);    if (ret < 0) {        return ret;    }    s->dev.acked_features = vdev->guest_features;    ret = vhost_dev_start(&s->dev, vdev);    if (ret < 0) {        error_report("Error start vhost dev");        goto err_notifiers;    }    ret = vhost_scsi_set_endpoint(s);    if (ret < 0) {        error_report("Error set vhost-scsi endpoint");        goto err_vhost_stop;    }    ret = k->set_guest_notifiers(qbus->parent, s->dev.nvqs, true);    if (ret < 0) {        error_report("Error binding guest notifier");        goto err_endpoint;    }    /* guest_notifier_mask/pending not used yet, so just unmask     * everything here.  virtio-pci will do the right thing by     * enabling/disabling irqfd.     */    for (i = 0; i < s->dev.nvqs; i++) {        vhost_virtqueue_mask(&s->dev, vdev, i, false);    }    return ret;err_endpoint:    vhost_scsi_clear_endpoint(s);err_vhost_stop:    vhost_dev_stop(&s->dev, vdev);err_notifiers:    vhost_dev_disable_notifiers(&s->dev, vdev);    return ret;}

/* PC hardware initialisation */static void pc_q35_init(QEMUMachineInitArgs *args){    ram_addr_t ram_size = args->ram_size;    const char *cpu_model = args->cpu_model;    const char *kernel_filename = args->kernel_filename;    const char *kernel_cmdline = args->kernel_cmdline;    const char *initrd_filename = args->initrd_filename;    const char *boot_device = args->boot_device;    ram_addr_t below_4g_mem_size, above_4g_mem_size;    Q35PCIHost *q35_host;    PCIBus *host_bus;    PCIDevice *lpc;    BusState *idebus[MAX_SATA_PORTS];    ISADevice *rtc_state;    ISADevice *floppy;    MemoryRegion *pci_memory;    MemoryRegion *rom_memory;    MemoryRegion *ram_memory;    GSIState *gsi_state;    ISABus *isa_bus;    int pci_enabled = 1;    qemu_irq *cpu_irq;    qemu_irq *gsi;    qemu_irq *i8259;    int i;    ICH9LPCState *ich9_lpc;    PCIDevice *ahci;    qemu_irq *cmos_s3;    pc_cpus_init(cpu_model);    pc_acpi_init("q35-acpi-dsdt.aml");    kvmclock_create();    if (ram_size >= 0xb0000000) {        above_4g_mem_size = ram_size - 0xb0000000;        below_4g_mem_size = 0xb0000000;    } else {        above_4g_mem_size = 0;        below_4g_mem_size = ram_size;    }    /* pci enabled */    if (pci_enabled) {        pci_memory = g_new(MemoryRegion, 1);        memory_region_init(pci_memory, "pci", INT64_MAX);        rom_memory = pci_memory;    } else {        pci_memory = NULL;        rom_memory = get_system_memory();    }    /* allocate ram and load rom/bios */    if (!xen_enabled()) {        pc_memory_init(get_system_memory(), kernel_filename, kernel_cmdline,                       initrd_filename, below_4g_mem_size, above_4g_mem_size,                       rom_memory, &ram_memory);    }    /* irq lines */    gsi_state = g_malloc0(sizeof(*gsi_state));    if (kvm_irqchip_in_kernel()) {        kvm_pc_setup_irq_routing(pci_enabled);        gsi = qemu_allocate_irqs(kvm_pc_gsi_handler, gsi_state,                                 GSI_NUM_PINS);    } else {        gsi = qemu_allocate_irqs(gsi_handler, gsi_state, GSI_NUM_PINS);    }    /* create pci host bus */    q35_host = Q35_HOST_DEVICE(qdev_create(NULL, TYPE_Q35_HOST_DEVICE));    q35_host->mch.ram_memory = ram_memory;    q35_host->mch.pci_address_space = pci_memory;    q35_host->mch.system_memory = get_system_memory();    q35_host->mch.address_space_io = get_system_io();;    q35_host->mch.below_4g_mem_size = below_4g_mem_size;    q35_host->mch.above_4g_mem_size = above_4g_mem_size;    /* pci */    qdev_init_nofail(DEVICE(q35_host));    host_bus = q35_host->host.pci.bus;    /* create ISA bus */    lpc = pci_create_simple_multifunction(host_bus, PCI_DEVFN(ICH9_LPC_DEV,                                          ICH9_LPC_FUNC), true,                                          TYPE_ICH9_LPC_DEVICE);    ich9_lpc = ICH9_LPC_DEVICE(lpc);    ich9_lpc->pic = gsi;    ich9_lpc->ioapic = gsi_state->ioapic_irq;    pci_bus_irqs(host_bus, ich9_lpc_set_irq, ich9_lpc_map_irq, ich9_lpc,                 ICH9_LPC_NB_PIRQS);    isa_bus = ich9_lpc->isa_bus;    /*end early*/    isa_bus_irqs(isa_bus, gsi);    if (kvm_irqchip_in_kernel()) {        i8259 = kvm_i8259_init(isa_bus);    } else if (xen_enabled()) {        i8259 = xen_interrupt_controller_init();//.........这里部分代码省略.........

//.........这里部分代码省略.........            /* Not connected ? */            openpic_irqs[i][OPENPIC_OUTPUT_DEBUG] = NULL;            /* Check this */            openpic_irqs[i][OPENPIC_OUTPUT_RESET] =                ((qemu_irq *)env->irq_inputs)[PPC6xx_INPUT_HRESET];            break;#if defined(TARGET_PPC64)        case PPC_FLAGS_INPUT_970:            openpic_irqs[i] = openpic_irqs[0] + (i * OPENPIC_OUTPUT_NB);            openpic_irqs[i][OPENPIC_OUTPUT_INT] =                ((qemu_irq *)env->irq_inputs)[PPC970_INPUT_INT];            openpic_irqs[i][OPENPIC_OUTPUT_CINT] =                ((qemu_irq *)env->irq_inputs)[PPC970_INPUT_INT];            openpic_irqs[i][OPENPIC_OUTPUT_MCK] =                ((qemu_irq *)env->irq_inputs)[PPC970_INPUT_MCP];            /* Not connected ? */            openpic_irqs[i][OPENPIC_OUTPUT_DEBUG] = NULL;            /* Check this */            openpic_irqs[i][OPENPIC_OUTPUT_RESET] =                ((qemu_irq *)env->irq_inputs)[PPC970_INPUT_HRESET];            break;#endif /* defined(TARGET_PPC64) */        default:            error_report("Bus model not supported on mac99 machine");            exit(1);        }    }    pic = g_new0(qemu_irq, 64);    dev = qdev_create(NULL, TYPE_OPENPIC);    qdev_prop_set_uint32(dev, "model", OPENPIC_MODEL_RAVEN);    qdev_init_nofail(dev);    s = SYS_BUS_DEVICE(dev);    pic_mem = s->mmio[0].memory;    k = 0;    for (i = 0; i < smp_cpus; i++) {        for (j = 0; j < OPENPIC_OUTPUT_NB; j++) {            sysbus_connect_irq(s, k++, openpic_irqs[i][j]);        }    }    for (i = 0; i < 64; i++) {        pic[i] = qdev_get_gpio_in(dev, i);    }    if (PPC_INPUT(env) == PPC_FLAGS_INPUT_970) {        /* 970 gets a U3 bus */        pci_bus = pci_pmac_u3_init(pic, get_system_memory(), get_system_io());        machine_arch = ARCH_MAC99_U3;    } else {        pci_bus = pci_pmac_init(pic, get_system_memory(), get_system_io());        machine_arch = ARCH_MAC99;    }    machine->usb |= defaults_enabled() && !machine->usb_disabled;    /* Timebase Frequency */    if (kvm_enabled()) {        tbfreq = kvmppc_get_tbfreq();    } else {        tbfreq = TBFREQ;    }    /* init basic PC hardware */    escc_mem = escc_init(0, pic[0x25], pic[0x24],

static void aw_a10_realize(DeviceState *dev, Error **errp){    AwA10State *s = AW_A10(dev);    SysBusDevice *sysbusdev;    uint8_t i;    qemu_irq fiq, irq;    Error *err = NULL;    object_property_set_bool(OBJECT(&s->cpu), true, "realized", &err);    if (err != NULL) {        error_propagate(errp, err);        return;    }    irq = qdev_get_gpio_in(DEVICE(&s->cpu), ARM_CPU_IRQ);    fiq = qdev_get_gpio_in(DEVICE(&s->cpu), ARM_CPU_FIQ);    object_property_set_bool(OBJECT(&s->intc), true, "realized", &err);    if (err != NULL) {        error_propagate(errp, err);        return;    }    sysbusdev = SYS_BUS_DEVICE(&s->intc);    sysbus_mmio_map(sysbusdev, 0, AW_A10_PIC_REG_BASE);    sysbus_connect_irq(sysbusdev, 0, irq);    sysbus_connect_irq(sysbusdev, 1, fiq);    for (i = 0; i < AW_A10_PIC_INT_NR; i++) {        s->irq[i] = qdev_get_gpio_in(DEVICE(&s->intc), i);    }    object_property_set_bool(OBJECT(&s->timer), true, "realized", &err);    if (err != NULL) {        error_propagate(errp, err);        return;    }    sysbusdev = SYS_BUS_DEVICE(&s->timer);    sysbus_mmio_map(sysbusdev, 0, AW_A10_PIT_REG_BASE);    sysbus_connect_irq(sysbusdev, 0, s->irq[22]);    sysbus_connect_irq(sysbusdev, 1, s->irq[23]);    sysbus_connect_irq(sysbusdev, 2, s->irq[24]);    sysbus_connect_irq(sysbusdev, 3, s->irq[25]);    sysbus_connect_irq(sysbusdev, 4, s->irq[67]);    sysbus_connect_irq(sysbusdev, 5, s->irq[68]);    memory_region_init_ram(&s->sram_a, OBJECT(dev), "sram A", 48 * KiB,                           &error_fatal);    memory_region_add_subregion(get_system_memory(), 0x00000000, &s->sram_a);    create_unimplemented_device("a10-sram-ctrl", 0x01c00000, 4 * KiB);    /* FIXME use qdev NIC properties instead of nd_table[] */    if (nd_table[0].used) {        qemu_check_nic_model(&nd_table[0], TYPE_AW_EMAC);        qdev_set_nic_properties(DEVICE(&s->emac), &nd_table[0]);    }    object_property_set_bool(OBJECT(&s->emac), true, "realized", &err);    if (err != NULL) {        error_propagate(errp, err);        return;    }    sysbusdev = SYS_BUS_DEVICE(&s->emac);    sysbus_mmio_map(sysbusdev, 0, AW_A10_EMAC_BASE);    sysbus_connect_irq(sysbusdev, 0, s->irq[55]);    object_property_set_bool(OBJECT(&s->sata), true, "realized", &err);    if (err) {        error_propagate(errp, err);        return;    }    sysbus_mmio_map(SYS_BUS_DEVICE(&s->sata), 0, AW_A10_SATA_BASE);    sysbus_connect_irq(SYS_BUS_DEVICE(&s->sata), 0, s->irq[56]);    /* FIXME use a qdev chardev prop instead of serial_hd() */    serial_mm_init(get_system_memory(), AW_A10_UART0_REG_BASE, 2, s->irq[1],                   115200, serial_hd(0), DEVICE_NATIVE_ENDIAN);}

static void set_netdev(Object *obj, Visitor *v, const char *name,                       void *opaque, Error **errp){    DeviceState *dev = DEVICE(obj);    Property *prop = opaque;    NICPeers *peers_ptr = qdev_get_prop_ptr(dev, prop);    NetClientState **ncs = peers_ptr->ncs;    NetClientState *peers[MAX_QUEUE_NUM];    Error *local_err = NULL;    int queues, err = 0, i = 0;    char *str;    if (dev->realized) {        qdev_prop_set_after_realize(dev, name, errp);        return;    }    visit_type_str(v, name, &str, &local_err);    if (local_err) {        error_propagate(errp, local_err);        return;    }    queues = qemu_find_net_clients_except(str, peers,                                          NET_CLIENT_DRIVER_NIC,                                          MAX_QUEUE_NUM);    if (queues == 0) {        err = -ENOENT;        goto out;    }    if (queues > MAX_QUEUE_NUM) {        error_setg(errp, "queues of backend '%s'(%d) exceeds QEMU limitation(%d)",                   str, queues, MAX_QUEUE_NUM);        goto out;    }    for (i = 0; i < queues; i++) {        if (peers[i] == NULL) {            err = -ENOENT;            goto out;        }        if (peers[i]->peer) {            err = -EEXIST;            goto out;        }        if (ncs[i]) {            err = -EINVAL;            goto out;        }        ncs[i] = peers[i];        ncs[i]->queue_index = i;    }    peers_ptr->queues = queues;out:    error_set_from_qdev_prop_error(errp, err, dev, prop, str);    g_free(str);}

static void stm32f205_soc_realize(DeviceState *dev_soc, Error **errp){    STM32F205State *s = STM32F205_SOC(dev_soc);    DeviceState *syscfgdev, *usartdev, *timerdev, *nvic;    SysBusDevice *syscfgbusdev, *usartbusdev, *timerbusdev;    Error *err = NULL;    int i;    MemoryRegion *system_memory = get_system_memory();    MemoryRegion *sram = g_new(MemoryRegion, 1);    MemoryRegion *flash = g_new(MemoryRegion, 1);    MemoryRegion *flash_alias = g_new(MemoryRegion, 1);    memory_region_init_ram(flash, NULL, "STM32F205.flash", FLASH_SIZE,                           &error_fatal);    memory_region_init_alias(flash_alias, NULL, "STM32F205.flash.alias",                             flash, 0, FLASH_SIZE);    vmstate_register_ram_global(flash);    memory_region_set_readonly(flash, true);    memory_region_set_readonly(flash_alias, true);    memory_region_add_subregion(system_memory, FLASH_BASE_ADDRESS, flash);    memory_region_add_subregion(system_memory, 0, flash_alias);    memory_region_init_ram(sram, NULL, "STM32F205.sram", SRAM_SIZE,                           &error_fatal);    vmstate_register_ram_global(sram);    memory_region_add_subregion(system_memory, SRAM_BASE_ADDRESS, sram);    nvic = armv7m_init(get_system_memory(), FLASH_SIZE, 96,                       s->kernel_filename, s->cpu_model);    /* System configuration controller */    syscfgdev = DEVICE(&s->syscfg);    object_property_set_bool(OBJECT(&s->syscfg), true, "realized", &err);    if (err != NULL) {        error_propagate(errp, err);        return;    }    syscfgbusdev = SYS_BUS_DEVICE(syscfgdev);    sysbus_mmio_map(syscfgbusdev, 0, 0x40013800);    sysbus_connect_irq(syscfgbusdev, 0, qdev_get_gpio_in(nvic, 71));    /* Attach UART (uses USART registers) and USART controllers */    for (i = 0; i < STM_NUM_USARTS; i++) {        usartdev = DEVICE(&(s->usart[i]));        object_property_set_bool(OBJECT(&s->usart[i]), true, "realized", &err);        if (err != NULL) {            error_propagate(errp, err);            return;        }        usartbusdev = SYS_BUS_DEVICE(usartdev);        sysbus_mmio_map(usartbusdev, 0, usart_addr[i]);        sysbus_connect_irq(usartbusdev, 0,                           qdev_get_gpio_in(nvic, usart_irq[i]));    }    /* Timer 2 to 5 */    for (i = 0; i < STM_NUM_TIMERS; i++) {        timerdev = DEVICE(&(s->timer[i]));        qdev_prop_set_uint64(timerdev, "clock-frequency", 1000000000);        object_property_set_bool(OBJECT(&s->timer[i]), true, "realized", &err);        if (err != NULL) {            error_propagate(errp, err);            return;        }        timerbusdev = SYS_BUS_DEVICE(timerdev);        sysbus_mmio_map(timerbusdev, 0, timer_addr[i]);        sysbus_connect_irq(timerbusdev, 0,                           qdev_get_gpio_in(nvic, timer_irq[i]));    }}