static char *sysbus_get_fw_dev_path(DeviceState *dev) { SysBusDevice *s = SYS_BUS_DEVICE(dev); char path[40]; int off; off = snprintf(path, sizeof(path), "%s", qdev_fw_name(dev)); if (s->num_mmio) { snprintf(path + off, sizeof(path) - off, "@"TARGET_FMT_plx, s->mmio[0].addr); } else if (s->num_pio) { snprintf(path + off, sizeof(path) - off, "@i%04x", s->pio[0]); } return g_strdup(path); }
static void openrisc_sim_ompic_init(hwaddr base, int num_cpus, qemu_irq **cpu_irqs, int irq_pin) { DeviceState *dev; SysBusDevice *s; int i; dev = qdev_create(NULL, "or1k-ompic"); qdev_prop_set_uint32(dev, "num-cpus", num_cpus); qdev_init_nofail(dev); s = SYS_BUS_DEVICE(dev); for (i = 0; i < num_cpus; i++) { sysbus_connect_irq(s, i, cpu_irqs[i][irq_pin]); } sysbus_mmio_map(s, 0, base); }
static void lan9215_init(uint32_t base, qemu_irq irq) { DeviceState *dev; SysBusDevice *s; /* This should be a 9215 but the 9118 is close enough */ if (nd_table[0].used) { qemu_check_nic_model(&nd_table[0], "lan9118"); dev = qdev_create(NULL, "lan9118"); qdev_set_nic_properties(dev, &nd_table[0]); qdev_prop_set_uint32(dev, "mode_16bit", 1); qdev_init_nofail(dev); s = SYS_BUS_DEVICE(dev); sysbus_mmio_map(s, 0, base); sysbus_connect_irq(s, 0, irq); } }
static MemoryRegion *make_unimp_dev(MPS2TZMachineState *mms, void *opaque, const char *name, hwaddr size) { /* Initialize, configure and realize a TYPE_UNIMPLEMENTED_DEVICE, * and return a pointer to its MemoryRegion. */ UnimplementedDeviceState *uds = opaque; sysbus_init_child_obj(OBJECT(mms), name, uds, sizeof(UnimplementedDeviceState), TYPE_UNIMPLEMENTED_DEVICE); qdev_prop_set_string(DEVICE(uds), "name", name); qdev_prop_set_uint64(DEVICE(uds), "size", size); object_property_set_bool(OBJECT(uds), true, "realized", &error_fatal); return sysbus_mmio_get_region(SYS_BUS_DEVICE(uds), 0); }
static void *sparc32_dma_init(hwaddr daddr, qemu_irq parent_irq, void *iommu, qemu_irq *dev_irq, int is_ledma) { DeviceState *dev; SysBusDevice *s; dev = qdev_create(NULL, "sparc32_dma"); qdev_prop_set_ptr(dev, "iommu_opaque", iommu); qdev_prop_set_uint32(dev, "is_ledma", is_ledma); qdev_init_nofail(dev); s = SYS_BUS_DEVICE(dev); sysbus_connect_irq(s, 0, parent_irq); *dev_irq = qdev_get_gpio_in(dev, 0); sysbus_mmio_map(s, 0, daddr); return s; }
static void imx_epit_realize(DeviceState *dev, Error **errp) { IMXEPITState *s = IMX_EPIT(dev); SysBusDevice *sbd = SYS_BUS_DEVICE(dev); QEMUBH *bh; DPRINTF("\n"); sysbus_init_irq(sbd, &s->irq); memory_region_init_io(&s->iomem, OBJECT(s), &imx_epit_ops, s, TYPE_IMX_EPIT, 0x00001000); sysbus_init_mmio(sbd, &s->iomem); s->timer_reload = ptimer_init(NULL); bh = qemu_bh_new(imx_epit_cmp, s); s->timer_cmp = ptimer_init(bh); }
static MemoryRegion *make_eth_dev(MPS2TZMachineState *mms, void *opaque, const char *name, hwaddr size) { SysBusDevice *s; NICInfo *nd = &nd_table[0]; /* In hardware this is a LAN9220; the LAN9118 is software compatible * except that it doesn't support the checksum-offload feature. */ qemu_check_nic_model(nd, "lan9118"); mms->lan9118 = qdev_create(NULL, "lan9118"); qdev_set_nic_properties(mms->lan9118, nd); qdev_init_nofail(mms->lan9118); s = SYS_BUS_DEVICE(mms->lan9118); sysbus_connect_irq(s, 0, get_sse_irq_in(mms, 16)); return sysbus_mmio_get_region(s, 0); }
void empty_slot_init(hwaddr addr, uint64_t slot_size) { if (slot_size > 0) { /* Only empty slots larger than 0 byte need handling. */ DeviceState *dev; SysBusDevice *s; EmptySlot *e; dev = qdev_create(NULL, "empty_slot"); s = SYS_BUS_DEVICE(dev); e = FROM_SYSBUS(EmptySlot, s); e->size = slot_size; qdev_init_nofail(dev); sysbus_mmio_map(s, 0, addr); } }
static void arm_sysctl_reset(DeviceState *d) { arm_sysctl_state *s = FROM_SYSBUS(arm_sysctl_state, SYS_BUS_DEVICE(d)); s->leds = 0; s->lockval = 0; s->cfgdata1 = 0; s->cfgdata2 = 0; s->flags = 0; s->resetlevel = 0; if (board_id(s) == BOARD_ID_VEXPRESS) { /* On VExpress this register will RAZ/WI */ s->sys_clcd = 0; } else { /* All others: CLCDID 0x1f, indicating VGA */ s->sys_clcd = 0x1f00; } }
static void q35_host_realize(DeviceState *dev, Error **errp) { PCIHostState *pci = PCI_HOST_BRIDGE(dev); Q35PCIHost *s = Q35_HOST_DEVICE(dev); SysBusDevice *sbd = SYS_BUS_DEVICE(dev); sysbus_add_io(sbd, MCH_HOST_BRIDGE_CONFIG_ADDR, &pci->conf_mem); sysbus_init_ioports(sbd, MCH_HOST_BRIDGE_CONFIG_ADDR, 4); sysbus_add_io(sbd, MCH_HOST_BRIDGE_CONFIG_DATA, &pci->data_mem); sysbus_init_ioports(sbd, MCH_HOST_BRIDGE_CONFIG_DATA, 4); pci->bus = pci_bus_new(DEVICE(s), "pcie.0", s->mch.pci_address_space, s->mch.address_space_io, 0, TYPE_PCIE_BUS); qdev_set_parent_bus(DEVICE(&s->mch), BUS(pci->bus)); qdev_init_nofail(DEVICE(&s->mch)); }
static void unimp_realize(DeviceState *dev, Error **errp) { UnimplementedDeviceState *s = UNIMPLEMENTED_DEVICE(dev); if (s->size == 0) { error_setg(errp, "property 'size' not specified or zero"); return; } if (s->name == NULL) { error_setg(errp, "property 'name' not specified"); return; } memory_region_init_io(&s->iomem, OBJECT(s), &unimp_ops, s, s->name, s->size); sysbus_init_mmio(SYS_BUS_DEVICE(s), &s->iomem); }
static void ftgmac100_realize(DeviceState *dev, Error **errp) { Ftgmac100State *s = FTGMAC100(dev); SysBusDevice *sbd = SYS_BUS_DEVICE(dev); memory_region_init_io(&s->iomem, OBJECT(dev), &ftgmac100_ops, s, TYPE_FTGMAC100, 0x2000); sysbus_init_mmio(sbd, &s->iomem); sysbus_init_irq(sbd, &s->irq); qemu_macaddr_default_if_unset(&s->conf.macaddr); s->conf.peers.ncs[0] = nd_table[0].netdev; s->nic = qemu_new_nic(&net_ftgmac100_info, &s->conf, object_get_typename(OBJECT(dev)), DEVICE(dev)->id, s); qemu_format_nic_info_str(qemu_get_queue(s->nic), s->conf.macaddr.a); }
static void openrisc_sim_net_init(hwaddr base, hwaddr descriptors, int num_cpus, qemu_irq **cpu_irqs, int irq_pin, NICInfo *nd) { DeviceState *dev; SysBusDevice *s; int i; dev = qdev_create(NULL, "open_eth"); qdev_set_nic_properties(dev, nd); qdev_init_nofail(dev); s = SYS_BUS_DEVICE(dev); for (i = 0; i < num_cpus; i++) { sysbus_connect_irq(s, 0, cpu_irqs[i][irq_pin]); } sysbus_mmio_map(s, 0, base); sysbus_mmio_map(s, 1, descriptors); }
static void a15mp_priv_initfn(Object *obj) { SysBusDevice *sbd = SYS_BUS_DEVICE(obj); A15MPPrivState *s = A15MPCORE_PRIV(obj); DeviceState *gicdev; const char *gictype = "arm_gic"; if (kvm_irqchip_in_kernel()) { gictype = "kvm-arm-gic"; } memory_region_init(&s->container, obj, "a15mp-priv-container", 0x8000); sysbus_init_mmio(sbd, &s->container); object_initialize(&s->gic, sizeof(s->gic), gictype); gicdev = DEVICE(&s->gic); qdev_set_parent_bus(gicdev, sysbus_get_default()); qdev_prop_set_uint32(gicdev, "revision", 2); }
static void lance_init(NICInfo *nd, hwaddr leaddr, void *dma_opaque, qemu_irq irq) { DeviceState *dev; SysBusDevice *s; qemu_irq reset; qemu_check_nic_model(&nd_table[0], "lance"); dev = qdev_create(NULL, "lance"); qdev_set_nic_properties(dev, nd); qdev_prop_set_ptr(dev, "dma", dma_opaque); qdev_init_nofail(dev); s = SYS_BUS_DEVICE(dev); sysbus_mmio_map(s, 0, leaddr); sysbus_connect_irq(s, 0, irq); reset = qdev_get_gpio_in(dev, 0); qdev_connect_gpio_out(dma_opaque, 0, reset); }
static void slavio_timer_init_all(hwaddr addr, qemu_irq master_irq, qemu_irq *cpu_irqs, unsigned int num_cpus) { DeviceState *dev; SysBusDevice *s; unsigned int i; dev = qdev_create(NULL, "slavio_timer"); qdev_prop_set_uint32(dev, "num_cpus", num_cpus); qdev_init_nofail(dev); s = SYS_BUS_DEVICE(dev); sysbus_connect_irq(s, 0, master_irq); sysbus_mmio_map(s, 0, addr + SYS_TIMER_OFFSET); for (i = 0; i < MAX_CPUS; i++) { sysbus_mmio_map(s, i + 1, addr + (hwaddr)CPU_TIMER_OFFSET(i)); sysbus_connect_irq(s, i + 1, cpu_irqs[i]); } }
static void openrisc_sim_net_init(MemoryRegion *address_space, hwaddr base, hwaddr descriptors, qemu_irq irq, NICInfo *nd) { DeviceState *dev; SysBusDevice *s; dev = qdev_create(NULL, "open_eth"); qdev_set_nic_properties(dev, nd); qdev_init_nofail(dev); s = SYS_BUS_DEVICE(dev); sysbus_connect_irq(s, 0, irq); memory_region_add_subregion(address_space, base, sysbus_mmio_get_region(s, 0)); memory_region_add_subregion(address_space, descriptors, sysbus_mmio_get_region(s, 1)); }
static void macio_newworld_realize(PCIDevice *d, Error **errp) { MacIOState *s = MACIO(d); NewWorldMacIOState *ns = NEWWORLD_MACIO(d); Error *err = NULL; SysBusDevice *sysbus_dev; MemoryRegion *timer_memory = NULL; int i; int cur_irq = 0; macio_common_realize(d, &err); if (err) { error_propagate(errp, err); return; } sysbus_dev = SYS_BUS_DEVICE(&s->cuda); sysbus_connect_irq(sysbus_dev, 0, ns->irqs[cur_irq++]); if (s->pic_mem) { /* OpenPIC */ memory_region_add_subregion(&s->bar, 0x40000, s->pic_mem); } /* IDE buses */ for (i = 0; i < ARRAY_SIZE(ns->ide); i++) { qemu_irq irq0 = ns->irqs[cur_irq++]; qemu_irq irq1 = ns->irqs[cur_irq++]; macio_realize_ide(s, &ns->ide[i], irq0, irq1, 0x16 + (i * 4), &err); if (err) { error_propagate(errp, err); return; } } /* Timer */ timer_memory = g_new(MemoryRegion, 1); memory_region_init_io(timer_memory, OBJECT(s), &timer_ops, NULL, "timer", 0x1000); memory_region_add_subregion(&s->bar, 0x15000, timer_memory); }
static qemu_irq *ppce500_init_mpic(PPCE500Params *params, MemoryRegion *ccsr, qemu_irq **irqs) { qemu_irq *mpic; DeviceState *dev = NULL; SysBusDevice *s; int i; mpic = g_new(qemu_irq, 256); if (kvm_enabled()) { QemuOpts *machine_opts = qemu_get_machine_opts(); bool irqchip_allowed = qemu_opt_get_bool(machine_opts, "kernel_irqchip", true); bool irqchip_required = qemu_opt_get_bool(machine_opts, "kernel_irqchip", false); if (irqchip_allowed) { dev = ppce500_init_mpic_kvm(params, irqs); } if (irqchip_required && !dev) { fprintf(stderr, "%s: irqchip requested but unavailable\n", __func__); abort(); } } if (!dev) { dev = ppce500_init_mpic_qemu(params, irqs); } for (i = 0; i < 256; i++) { mpic[i] = qdev_get_gpio_in(dev, i); } s = SYS_BUS_DEVICE(dev); memory_region_add_subregion(ccsr, MPC8544_MPIC_REGS_OFFSET, s->mmio[0].memory); return mpic; }
PXA2xxPCMCIAState *pxa2xx_pcmcia_init(MemoryRegion *sysmem, hwaddr base) { DeviceState *dev; PXA2xxPCMCIAState *s; dev = qdev_create(NULL, TYPE_PXA2XX_PCMCIA); sysbus_mmio_map(SYS_BUS_DEVICE(dev), 0, base); s = PXA2XX_PCMCIA(dev); if (base == 0x30000000) { s->slot.slot_string = "PXA PC Card Socket 1"; } else { s->slot.slot_string = "PXA PC Card Socket 0"; } qdev_init_nofail(dev); return s; }
static void pmc_anlg_init(Object *obj) { PmcAnalog *s = PMC_ANALOG(obj); SysBusDevice *sbd = SYS_BUS_DEVICE(obj); RegisterInfoArray *reg_array; memory_region_init(&s->iomem, obj, TYPE_PMC_ANALOG, PMC_ANLG_R_MAX * 4); reg_array = register_init_block32(DEVICE(obj), pmc_anlg_regs_info, ARRAY_SIZE(pmc_anlg_regs_info), s->regs_info, s->regs, &pmc_anlg_ops, PMC_ANALOG_ERR_DEBUG, PMC_ANLG_R_MAX * 4); memory_region_add_subregion(&s->iomem, 0x0, ®_array->mem); sysbus_init_mmio(sbd, &s->iomem); sysbus_init_irq(sbd, &s->irq_pmc_anlg_imr); }
static void xpio_dci_component_init(Object *obj) { XPIO_DCI_COMPONENT *s = XILINX_XPIO_DCI_COMPONENT(obj); SysBusDevice *sbd = SYS_BUS_DEVICE(obj); RegisterInfoArray *reg_array; memory_region_init(&s->iomem, obj, TYPE_XILINX_XPIO_DCI_COMPONENT, XPIO_DCI_COMPONENT_R_MAX * 4); reg_array = register_init_block32(DEVICE(obj), xpio_dci_component_regs_info, ARRAY_SIZE(xpio_dci_component_regs_info), s->regs_info, s->regs, &xpio_dci_component_ops, XILINX_XPIO_DCI_COMPONENT_ERR_DEBUG, XPIO_DCI_COMPONENT_R_MAX * 4); memory_region_add_subregion(&s->iomem, 0x0, ®_array->mem); sysbus_init_mmio(sbd, &s->iomem); }
static void smc91c111_reset(DeviceState *dev) { smc91c111_state *s = FROM_SYSBUS(smc91c111_state, SYS_BUS_DEVICE(dev)); s->bank = 0; s->tx_fifo_len = 0; s->tx_fifo_done_len = 0; s->rx_fifo_len = 0; s->allocated = 0; s->packet_num = 0; s->tx_alloc = 0; s->tcr = 0; s->rcr = 0; s->cr = 0xa0b1; s->ctr = 0x1210; s->ptr = 0; s->ercv = 0x1f; s->int_level = INT_TX_EMPTY; s->int_mask = 0; smc91c111_update(s); }
static void pmc_sss_init(Object *obj) { SSSBase *p = SSS_BASE(obj); PMCSSS *s = PMC_SSS(obj); SysBusDevice *sbd = SYS_BUS_DEVICE(obj); char *name; int remote; p->sss_population = pmc_sss_population; p->r_sss_shifts = r_pmc_cfg_sss_shifts; p->r_sss_encodings = r_pmc_cfg_sss_encodings; p->num_remotes = PMC_NUM_REMOTES; p->notifys = g_new0(StreamCanPushNotifyFn, PMC_NUM_REMOTES); p->notify_opaques = g_new0(void *, PMC_NUM_REMOTES); p->get_sss_regfield = pmc_get_sss_regfield; p->rx_devs = (SSSStream *) g_new(SSSStream, PMC_NUM_REMOTES); p->tx_devs = (StreamSlave **) g_new0(StreamSlave *, PMC_NUM_REMOTES); for (remote = 0 ; remote != NO_REMOTE; remote++) { name = g_strdup_printf("stream-connected-%s", pmc_sss_remote_names[remote]); object_property_add_link(OBJECT(s), name, TYPE_STREAM_SLAVE, (Object **)&p->tx_devs[remote], qdev_prop_allow_set_link_before_realize, OBJ_PROP_LINK_UNREF_ON_RELEASE, NULL); g_free(name); object_initialize(&p->rx_devs[remote], sizeof(SSSStream), TYPE_SSS_STREAM); name = g_strdup_printf("stream-connected-%s-target", pmc_sss_remote_names[remote]); object_property_add_child(OBJECT(s), name, (Object *)&p->rx_devs[remote], &error_abort); g_free(name); } memory_region_init_io(&s->iomem, obj, &sss_ops, s, "versal.pmc-stream-switch", R_MAX * 4); sysbus_init_mmio(sbd, &s->iomem); }
static void xlnx_axi_gpio_realize(DeviceState *dev, Error **errp) { XlnxAXIGPIO *s = XLNX_AXI_GPIO(dev); const char *prefix = object_get_canonical_path(OBJECT(dev)); unsigned int i; for (i = 0; i < ARRAY_SIZE(xlnx_axi_gpio_regs_info); ++i) { DepRegisterInfo *r = &s->regs_info[xlnx_axi_gpio_regs_info[i].decode.addr/4]; *r = (DepRegisterInfo) { .data = (uint8_t *)&s->regs[ xlnx_axi_gpio_regs_info[i].decode.addr/4], .data_size = sizeof(uint32_t), .access = &xlnx_axi_gpio_regs_info[i], .debug = XLNX_AXI_GPIO_ERR_DEBUG, .prefix = prefix, .opaque = s, }; } /* Create two GPIO in banks that QTest can use */ qdev_init_gpio_in(dev, data_handler1, 32); qdev_init_gpio_in(dev, data_handler2, 32); /* Create GPIO banks as well */ qdev_init_gpio_out(dev, s->outputs1, 32); qdev_init_gpio_out(dev, s->outputs2, 32); } static void xlnx_axi_gpio_init(Object *obj) { XlnxAXIGPIO *s = XLNX_AXI_GPIO(obj); SysBusDevice *sbd = SYS_BUS_DEVICE(obj); memory_region_init_io(&s->iomem, obj, &xlnx_axi_gpio_ops, s, TYPE_XLNX_AXI_GPIO, R_MAX * 4); sysbus_init_mmio(sbd, &s->iomem); sysbus_init_irq(sbd, &s->parent_irq); }
static pflash_t *xtfpga_flash_init(MemoryRegion *address_space, const LxBoardDesc *board, DriveInfo *dinfo, int be) { SysBusDevice *s; DeviceState *dev = qdev_create(NULL, "cfi.pflash01"); qdev_prop_set_drive(dev, "drive", blk_by_legacy_dinfo(dinfo), &error_abort); qdev_prop_set_uint32(dev, "num-blocks", board->flash_size / board->flash_sector_size); qdev_prop_set_uint64(dev, "sector-length", board->flash_sector_size); qdev_prop_set_uint8(dev, "width", 4); qdev_prop_set_bit(dev, "big-endian", be); qdev_prop_set_string(dev, "name", "lx60.io.flash"); qdev_init_nofail(dev); s = SYS_BUS_DEVICE(dev); memory_region_add_subregion(address_space, board->flash_base, sysbus_mmio_get_region(s, 0)); return OBJECT_CHECK(pflash_t, (dev), "cfi.pflash01"); }
static void xilinx_timer_realize(DeviceState *dev, Error **errp) { struct timerblock *t = XILINX_TIMER(dev); unsigned int i; /* Init all the ptimers. */ t->timers = g_malloc0(sizeof t->timers[0] * num_timers(t)); for (i = 0; i < num_timers(t); i++) { struct xlx_timer *xt = &t->timers[i]; xt->parent = t; xt->nr = i; xt->bh = qemu_bh_new(timer_hit, xt); xt->ptimer = ptimer_init(xt->bh); ptimer_set_freq(xt->ptimer, t->freq_hz); } memory_region_init_io(&t->mmio, OBJECT(t), &timer_ops, t, "xlnx.xps-timer", R_MAX * 4 * num_timers(t)); sysbus_init_mmio(SYS_BUS_DEVICE(dev), &t->mmio); }
void gicv3_its_init_mmio(GICv3ITSState *s, const MemoryRegionOps *ops) { SysBusDevice *sbd = SYS_BUS_DEVICE(s); memory_region_init_io(&s->iomem_its_cntrl, OBJECT(s), ops, s, "control", ITS_CONTROL_SIZE); memory_region_init_io(&s->iomem_its_translation, OBJECT(s), &gicv3_its_trans_ops, s, "translation", ITS_TRANS_SIZE); /* Our two regions are always adjacent, therefore we now combine them * into a single one in order to make our users' life easier. */ memory_region_init(&s->iomem_main, OBJECT(s), "gicv3_its", ITS_SIZE); memory_region_add_subregion(&s->iomem_main, 0, &s->iomem_its_cntrl); memory_region_add_subregion(&s->iomem_main, ITS_CONTROL_SIZE, &s->iomem_its_translation); sysbus_init_mmio(sbd, &s->iomem_main); msi_nonbroken = true; }
static void icp_pit_init(Object *obj) { icp_pit_state *s = INTEGRATOR_PIT(obj); SysBusDevice *dev = SYS_BUS_DEVICE(obj); /* Timer 0 runs at the system clock speed (40MHz). */ s->timer[0] = arm_timer_init(40000000); /* The other two timers run at 1MHz. */ s->timer[1] = arm_timer_init(1000000); s->timer[2] = arm_timer_init(1000000); sysbus_init_irq(dev, &s->timer[0]->irq); sysbus_init_irq(dev, &s->timer[1]->irq); sysbus_init_irq(dev, &s->timer[2]->irq); memory_region_init_io(&s->iomem, obj, &icp_pit_ops, s, "icp_pit", 0x1000); sysbus_init_mmio(dev, &s->iomem); /* This device has no state to save/restore. The component timers will save themselves. */ }
static int macio_common_initfn(PCIDevice *d) { MacIOState *s = MACIO(d); SysBusDevice *sysbus_dev; int ret; d->config[0x3d] = 0x01; // interrupt on pin 1 ret = qdev_init(DEVICE(&s->cuda)); if (ret < 0) { return ret; } sysbus_dev = SYS_BUS_DEVICE(&s->cuda); memory_region_add_subregion(&s->bar, 0x16000, sysbus_mmio_get_region(sysbus_dev, 0)); macio_bar_setup(s); pci_register_bar(d, 0, PCI_BASE_ADDRESS_SPACE_MEMORY, &s->bar); return 0; }