as.fmt = AUD_FMT_S16; as.endianness = 1; s->voice_in = AUD_open_in(&s->card, s->voice_in, "mm_ac97.in", s, ac97_in_cb, &as); s->voice_out = AUD_open_out(&s->card, s->voice_out, "mm_ac97.out", s, ac97_out_cb, &as); } static const VMStateDescription vmstate_milkymist_ac97 = { .name = "milkymist-ac97", .version_id = 1, .minimum_version_id = 1, .post_load = ac97_post_load, .fields = (VMStateField[]) { VMSTATE_UINT32_ARRAY(regs, MilkymistAC97State, R_MAX), VMSTATE_END_OF_LIST() } }; static void milkymist_ac97_class_init(ObjectClass *klass, void *data) { DeviceClass *dc = DEVICE_CLASS(klass); dc->realize = milkymist_ac97_realize; dc->reset = milkymist_ac97_reset; dc->vmsd = &vmstate_milkymist_ac97; } static const TypeInfo milkymist_ac97_info = { .name = TYPE_MILKYMIST_AC97,
static bool iwmmxt_needed(void *opaque) { ARMCPU *cpu = opaque; CPUARMState *env = &cpu->env; return arm_feature(env, ARM_FEATURE_IWMMXT); } static const VMStateDescription vmstate_iwmmxt = { .name = "cpu/iwmmxt", .version_id = 1, .minimum_version_id = 1, .minimum_version_id_old = 1, .fields = (VMStateField[]) { VMSTATE_UINT64_ARRAY(env.iwmmxt.regs, ARMCPU, 16), VMSTATE_UINT32_ARRAY(env.iwmmxt.cregs, ARMCPU, 16), VMSTATE_END_OF_LIST() } }; static bool m_needed(void *opaque) { ARMCPU *cpu = opaque; CPUARMState *env = &cpu->env; return arm_feature(env, ARM_FEATURE_M); } const VMStateDescription vmstate_m = { .name = "cpu/m", .version_id = 1,
SysBusDevice *sbd = SYS_BUS_DEVICE(obj); MilkymistUartState *s = MILKYMIST_UART(obj); sysbus_init_irq(sbd, &s->irq); memory_region_init_io(&s->regs_region, OBJECT(s), &uart_mmio_ops, s, "milkymist-uart", R_MAX * 4); sysbus_init_mmio(sbd, &s->regs_region); } static const VMStateDescription vmstate_milkymist_uart = { .name = "milkymist-uart", .version_id = 1, .minimum_version_id = 1, .fields = (VMStateField[]) { VMSTATE_UINT32_ARRAY(regs, MilkymistUartState, R_MAX), VMSTATE_END_OF_LIST() } }; static Property milkymist_uart_properties[] = { DEFINE_PROP_CHR("chardev", MilkymistUartState, chr), DEFINE_PROP_END_OF_LIST(), }; static void milkymist_uart_class_init(ObjectClass *klass, void *data) { DeviceClass *dc = DEVICE_CLASS(klass); dc->realize = milkymist_uart_realize; dc->reset = milkymist_uart_reset;
{ SysBusDevice *sbd = SYS_BUS_DEVICE(obj); ZynqXADCState *s = ZYNQ_XADC(obj); memory_region_init_io(&s->iomem, obj, &xadc_ops, s, "zynq-xadc", ZYNQ_XADC_MMIO_SIZE); sysbus_init_mmio(sbd, &s->iomem); sysbus_init_irq(sbd, &s->qemu_irq); } static const VMStateDescription vmstate_zynq_xadc = { .name = "zynq-xadc", .version_id = 1, .minimum_version_id = 1, .fields = (VMStateField[]) { VMSTATE_UINT32_ARRAY(regs, ZynqXADCState, ZYNQ_XADC_NUM_IO_REGS), VMSTATE_UINT16_ARRAY(xadc_regs, ZynqXADCState, ZYNQ_XADC_NUM_ADC_REGS), VMSTATE_UINT16_ARRAY(xadc_dfifo, ZynqXADCState, ZYNQ_XADC_FIFO_DEPTH), VMSTATE_UINT16(xadc_read_reg_previous, ZynqXADCState), VMSTATE_UINT16(xadc_dfifo_entries, ZynqXADCState), VMSTATE_END_OF_LIST() } }; static void zynq_xadc_class_init(ObjectClass *klass, void *data) { DeviceClass *dc = DEVICE_CLASS(klass); dc->vmsd = &vmstate_zynq_xadc;
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 const VMStateDescription vmstate_xpio_dci_component = { .name = TYPE_XILINX_XPIO_DCI_COMPONENT, .version_id = 1, .minimum_version_id = 1, .fields = (VMStateField[]) { VMSTATE_UINT32_ARRAY(regs, XPIO_DCI_COMPONENT, XPIO_DCI_COMPONENT_R_MAX), VMSTATE_END_OF_LIST(), } }; static void xpio_dci_component_class_init(ObjectClass *klass, void *data) { DeviceClass *dc = DEVICE_CLASS(klass); dc->reset = xpio_dci_component_reset; dc->realize = xpio_dci_component_realize; dc->vmsd = &vmstate_xpio_dci_component; } static const TypeInfo xpio_dci_component_info = { .name = TYPE_XILINX_XPIO_DCI_COMPONENT,
/* Called from RCU critical section */ static IOMMUTLBEntry sun4m_translate_iommu(IOMMUMemoryRegion *iommu, hwaddr addr, IOMMUAccessFlags flags) { IOMMUState *is = container_of(iommu, IOMMUState, iommu); hwaddr page, pa; int is_write = (flags & IOMMU_WO) ? 1 : 0; uint32_t pte; IOMMUTLBEntry ret = { .target_as = &address_space_memory, .iova = 0, .translated_addr = 0, .addr_mask = ~(hwaddr)0, .perm = IOMMU_NONE, }; page = addr & IOMMU_PAGE_MASK; pte = iommu_page_get_flags(is, page); if (!(pte & IOPTE_VALID)) { iommu_bad_addr(is, page, is_write); return ret; } pa = iommu_translate_pa(addr, pte); if (is_write && !(pte & IOPTE_WRITE)) { iommu_bad_addr(is, page, is_write); return ret; } if (pte & IOPTE_WRITE) { ret.perm = IOMMU_RW; } else { ret.perm = IOMMU_RO; } ret.iova = page; ret.translated_addr = pa; ret.addr_mask = ~IOMMU_PAGE_MASK; return ret; } static const VMStateDescription vmstate_iommu = { .name ="iommu", .version_id = 2, .minimum_version_id = 2, .fields = (VMStateField[]) { VMSTATE_UINT32_ARRAY(regs, IOMMUState, IOMMU_NREGS), VMSTATE_UINT64(iostart, IOMMUState), VMSTATE_END_OF_LIST() } }; static void iommu_reset(DeviceState *d) { IOMMUState *s = SUN4M_IOMMU(d); memset(s->regs, 0, IOMMU_NREGS * 4); s->iostart = 0; s->regs[IOMMU_CTRL] = s->version; s->regs[IOMMU_ARBEN] = IOMMU_MID; s->regs[IOMMU_AFSR] = IOMMU_AFSR_RESV; s->regs[IOMMU_AER] = IOMMU_AER_EN_P0_ARB | IOMMU_AER_EN_P1_ARB; s->regs[IOMMU_MASK_ID] = IOMMU_TS_MASK; } static void iommu_init(Object *obj) { IOMMUState *s = SUN4M_IOMMU(obj); SysBusDevice *dev = SYS_BUS_DEVICE(obj); memory_region_init_iommu(&s->iommu, sizeof(s->iommu), TYPE_SUN4M_IOMMU_MEMORY_REGION, OBJECT(dev), "iommu-sun4m", UINT64_MAX); address_space_init(&s->iommu_as, MEMORY_REGION(&s->iommu), "iommu-as"); sysbus_init_irq(dev, &s->irq); memory_region_init_io(&s->iomem, obj, &iommu_mem_ops, s, "iommu", IOMMU_NREGS * sizeof(uint32_t)); sysbus_init_mmio(dev, &s->iomem); }
(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 const VMStateDescription vmstate_pmc_sss = { .name = "pmc_sss", .version_id = 1, .minimum_version_id = 1, .minimum_version_id_old = 1, .fields = (VMStateField[]) { VMSTATE_UINT32_ARRAY(regs, PMCSSS, R_MAX), VMSTATE_END_OF_LIST(), } }; static void pmc_sss_class_init(ObjectClass *klass, void *data) { DeviceClass *dc = DEVICE_CLASS(klass); dc->reset = sss_reset; dc->realize = pmc_sss_realize; dc->vmsd = &vmstate_pmc_sss; } static const TypeInfo pmc_sss_info = { .name = TYPE_PMC_SSS,
.version_id = 4, .minimum_version_id = 3, .fields = (VMStateField[]) { VMSTATE_UINT64_ARRAY(env.regs, S390CPU, 16), VMSTATE_UINT64(env.psw.mask, S390CPU), VMSTATE_UINT64(env.psw.addr, S390CPU), VMSTATE_UINT64(env.psa, S390CPU), VMSTATE_UINT32(env.todpr, S390CPU), VMSTATE_UINT64(env.pfault_token, S390CPU), VMSTATE_UINT64(env.pfault_compare, S390CPU), VMSTATE_UINT64(env.pfault_select, S390CPU), VMSTATE_UINT64(env.cputm, S390CPU), VMSTATE_UINT64(env.ckc, S390CPU), VMSTATE_UINT64(env.gbea, S390CPU), VMSTATE_UINT64(env.pp, S390CPU), VMSTATE_UINT32_ARRAY(env.aregs, S390CPU, 16), VMSTATE_UINT64_ARRAY(env.cregs, S390CPU, 16), VMSTATE_UINT8(env.cpu_state, S390CPU), VMSTATE_UINT8(env.sigp_order, S390CPU), VMSTATE_UINT32_V(irqstate_saved_size, S390CPU, 4), VMSTATE_VBUFFER_UINT32(irqstate, S390CPU, 4, NULL, 0, irqstate_saved_size), VMSTATE_END_OF_LIST() }, .subsections = (VMStateSubsection[]) { { .vmsd = &vmstate_fpu, .needed = fpu_needed, } , { .vmsd = &vmstate_vregs, .needed = vregs_needed,
qemu_irq cardstatus[2]; } pl181_state; static const VMStateDescription vmstate_pl181 = { .name = "pl181", .version_id = 1, .minimum_version_id = 1, .fields = (VMStateField[]) { VMSTATE_UINT32(clock, pl181_state), VMSTATE_UINT32(power, pl181_state), VMSTATE_UINT32(cmdarg, pl181_state), VMSTATE_UINT32(cmd, pl181_state), VMSTATE_UINT32(datatimer, pl181_state), VMSTATE_UINT32(datalength, pl181_state), VMSTATE_UINT32(respcmd, pl181_state), VMSTATE_UINT32_ARRAY(response, pl181_state, 4), VMSTATE_UINT32(datactrl, pl181_state), VMSTATE_UINT32(datacnt, pl181_state), VMSTATE_UINT32(status, pl181_state), VMSTATE_UINT32_ARRAY(mask, pl181_state, 2), VMSTATE_INT32(fifo_pos, pl181_state), VMSTATE_INT32(fifo_len, pl181_state), VMSTATE_INT32(linux_hack, pl181_state), VMSTATE_UINT32_ARRAY(fifo, pl181_state, PL181_FIFO_LEN), VMSTATE_END_OF_LIST() } }; #define PL181_CMD_INDEX 0x3f #define PL181_CMD_RESPONSE (1 << 6) #define PL181_CMD_LONGRESP (1 << 7)
{ UartState *s = opaque; uart_parameters_setup(s); uart_update_status(s); return 0; } static const VMStateDescription vmstate_cadence_uart = { .name = "cadence_uart", .version_id = 1, .minimum_version_id = 1, .minimum_version_id_old = 1, .post_load = cadence_uart_post_load, .fields = (VMStateField[]) { VMSTATE_UINT32_ARRAY(r, UartState, R_MAX), VMSTATE_UINT8_ARRAY(r_fifo, UartState, RX_FIFO_SIZE), VMSTATE_UINT32(rx_count, UartState), VMSTATE_UINT32(rx_wpos, UartState), VMSTATE_TIMER(fifo_trigger_handle, UartState), VMSTATE_TIMER(tx_time_handle, UartState), VMSTATE_END_OF_LIST() } }; static void cadence_uart_class_init(ObjectClass *klass, void *data) { DeviceClass *dc = DEVICE_CLASS(klass); SysBusDeviceClass *sdc = SYS_BUS_DEVICE_CLASS(klass); sdc->init = cadence_uart_init;
break; default: g_assert_not_reached(); } memory_region_init_io(&s->iomem, OBJECT(s), &aspeed_sdmc_ops, s, TYPE_ASPEED_SDMC, 0x1000); sysbus_init_mmio(sbd, &s->iomem); } static const VMStateDescription vmstate_aspeed_sdmc = { .name = "aspeed.sdmc", .version_id = 1, .minimum_version_id = 1, .fields = (VMStateField[]) { VMSTATE_UINT32_ARRAY(regs, AspeedSDMCState, ASPEED_SDMC_NR_REGS), VMSTATE_END_OF_LIST() } }; static Property aspeed_sdmc_properties[] = { DEFINE_PROP_UINT32("silicon-rev", AspeedSDMCState, silicon_rev, 0), DEFINE_PROP_UINT64("ram-size", AspeedSDMCState, ram_size, 0), DEFINE_PROP_END_OF_LIST(), }; static void aspeed_sdmc_class_init(ObjectClass *klass, void *data) { DeviceClass *dc = DEVICE_CLASS(klass); dc->realize = aspeed_sdmc_realize; dc->reset = aspeed_sdmc_reset;
s->chr = qemu_char_get_next_serial(); if (s->chr) { qemu_chr_add_handlers(s->chr, &uart_handlers, s); } return 0; } static const VMStateDescription vmstate_lm32_uart = { .name = "lm32-uart", .version_id = 1, .minimum_version_id = 1, .minimum_version_id_old = 1, .fields = (VMStateField[]) { VMSTATE_UINT32_ARRAY(regs, LM32UartState, R_MAX), VMSTATE_END_OF_LIST() } }; static void lm32_uart_class_init(ObjectClass *klass, void *data) { DeviceClass *dc = DEVICE_CLASS(klass); SysBusDeviceClass *k = SYS_BUS_DEVICE_CLASS(klass); k->init = lm32_uart_init; dc->reset = uart_reset; dc->vmsd = &vmstate_lm32_uart; } static const TypeInfo lm32_uart_info = {
return "lpimr0"; case IMX25_CCM_LPIMR1_REG: return "lpimr1"; default: sprintf(unknown, "[%d ?]", reg); return unknown; } } #define CKIH_FREQ 24000000 /* 24MHz crystal input */ static const VMStateDescription vmstate_imx25_ccm = { .name = TYPE_IMX25_CCM, .version_id = 1, .minimum_version_id = 1, .fields = (VMStateField[]) { VMSTATE_UINT32_ARRAY(reg, IMX25CCMState, IMX25_CCM_MAX_REG), VMSTATE_END_OF_LIST() }, }; static uint32_t imx25_ccm_get_mpll_clk(IMXCCMState *dev) { uint32_t freq; IMX25CCMState *s = IMX25_CCM(dev); if (EXTRACT(s->reg[IMX25_CCM_CCTL_REG], MPLL_BYPASS)) { freq = CKIH_FREQ; } else { freq = imx_ccm_calc_pll(s->reg[IMX25_CCM_MPCTL_REG], CKIH_FREQ); }
static const MemoryRegionOps bcm2835_mbox_ops = { .read = bcm2835_mbox_read, .write = bcm2835_mbox_write, .endianness = DEVICE_NATIVE_ENDIAN, .valid.min_access_size = 4, .valid.max_access_size = 4, }; /* vmstate of a single mailbox */ static const VMStateDescription vmstate_bcm2835_mbox_box = { .name = TYPE_BCM2835_MBOX "_box", .version_id = 1, .minimum_version_id = 1, .fields = (VMStateField[]) { VMSTATE_UINT32_ARRAY(reg, BCM2835Mbox, MBOX_SIZE), VMSTATE_UINT32(count, BCM2835Mbox), VMSTATE_UINT32(status, BCM2835Mbox), VMSTATE_UINT32(config, BCM2835Mbox), VMSTATE_END_OF_LIST() } }; /* vmstate of the entire device */ static const VMStateDescription vmstate_bcm2835_mbox = { .name = TYPE_BCM2835_MBOX, .version_id = 1, .minimum_version_id = 1, .minimum_version_id_old = 1, .fields = (VMStateField[]) { VMSTATE_BOOL_ARRAY(available, BCM2835MboxState, MBOX_CHAN_COUNT),
} } static const MemoryRegionOps cs_mem_ops = { .read = cs_mem_read, .write = cs_mem_write, .endianness = DEVICE_NATIVE_ENDIAN, }; static const VMStateDescription vmstate_cs4231 = { .name ="cs4231", .version_id = 1, .minimum_version_id = 1, .minimum_version_id_old = 1, .fields = (VMStateField []) { VMSTATE_UINT32_ARRAY(regs, CSState, CS_REGS), VMSTATE_UINT8_ARRAY(dregs, CSState, CS_DREGS), VMSTATE_END_OF_LIST() } }; static int cs4231_init1(SysBusDevice *dev) { CSState *s = FROM_SYSBUS(CSState, dev); memory_region_init_io(&s->iomem, &cs_mem_ops, s, "cs4321", CS_SIZE); sysbus_init_mmio(dev, &s->iomem); sysbus_init_irq(dev, &s->irq); return 0; }
.version_id = 3, .minimum_version_id = 3, .minimum_version_id_old = 1, .load_state_old = apic_load_old, .pre_load = apic_pre_load, .pre_save = apic_dispatch_pre_save, .post_load = apic_dispatch_post_load, .fields = (VMStateField[]) { VMSTATE_UINT32(apicbase, APICCommonState), VMSTATE_UINT8(id, APICCommonState), VMSTATE_UINT8(arb_id, APICCommonState), VMSTATE_UINT8(tpr, APICCommonState), VMSTATE_UINT32(spurious_vec, APICCommonState), VMSTATE_UINT8(log_dest, APICCommonState), VMSTATE_UINT8(dest_mode, APICCommonState), VMSTATE_UINT32_ARRAY(isr, APICCommonState, 8), VMSTATE_UINT32_ARRAY(tmr, APICCommonState, 8), VMSTATE_UINT32_ARRAY(irr, APICCommonState, 8), VMSTATE_UINT32_ARRAY(lvt, APICCommonState, APIC_LVT_NB), VMSTATE_UINT32(esr, APICCommonState), VMSTATE_UINT32_ARRAY(icr, APICCommonState, 2), VMSTATE_UINT32(divide_conf, APICCommonState), VMSTATE_INT32(count_shift, APICCommonState), VMSTATE_UINT32(initial_count, APICCommonState), VMSTATE_INT64(initial_count_load_time, APICCommonState), VMSTATE_INT64(next_time, APICCommonState), VMSTATE_INT64(timer_expiry, APICCommonState), /* open-coded timer state */ VMSTATE_END_OF_LIST() }, .subsections = (const VMStateDescription*[]) {
bcm2835_aux_put_fifo(opaque, 0x400); } } static const MemoryRegionOps bcm2835_aux_ops = { .read = bcm2835_aux_read, .write = bcm2835_aux_write, .endianness = DEVICE_NATIVE_ENDIAN, }; static const VMStateDescription vmstate_bcm2835_aux = { .name = "bcm2835_aux", .version_id = 2, .minimum_version_id = 2, .fields = (VMStateField[]) { VMSTATE_UINT32_ARRAY(read_fifo, BCM2835AuxState, 8), VMSTATE_INT32(read_pos, BCM2835AuxState), VMSTATE_INT32(read_count, BCM2835AuxState), VMSTATE_END_OF_LIST() } }; static void bcm2835_aux_init(Object *obj) { SysBusDevice *sbd = SYS_BUS_DEVICE(obj); BCM2835AuxState *s = BCM2835_AUX(obj); memory_region_init_io(&s->iomem, OBJECT(s), &bcm2835_aux_ops, s, "bcm2835_aux", 0x100); sysbus_init_mmio(sbd, &s->iomem); sysbus_init_irq(sbd, &s->irq);
(*irqs) = qdev_get_gpio_in(DEVICE(obj), cells[1]); return 1; default: error_setg(errp, "Invalid cell 0 value in interrupt binding: %d", cells[0]); return 0; } }; static const VMStateDescription vmstate_gic_proxy = { .name = TYPE_XILINX_GIC_PROXY, .version_id = 1, .minimum_version_id = 1, .minimum_version_id_old = 1, .fields = (VMStateField[]) { VMSTATE_UINT32_ARRAY(regs, GICProxy, R_MAX), VMSTATE_END_OF_LIST(), } }; static const FDTGenericGPIOSet gic_proxy_client_gpios[] = { { .names = &fdt_generic_gpio_name_set_gpio, .gpios = (FDTGenericGPIOConnection[]) { { .name = "gicp-irq", .fdt_index = 0 }, { }, }, }, { }, };
ptimer_set_freq(s->ptimer1, s->freq_hz); memory_region_init_io(&s->regs_region, &sysctl_mmio_ops, s, "milkymist-sysctl", R_MAX * 4); sysbus_init_mmio(dev, &s->regs_region); return 0; } static const VMStateDescription vmstate_milkymist_sysctl = { .name = "milkymist-sysctl", .version_id = 1, .minimum_version_id = 1, .minimum_version_id_old = 1, .fields = (VMStateField[]) { VMSTATE_UINT32_ARRAY(regs, MilkymistSysctlState, R_MAX), VMSTATE_PTIMER(ptimer0, MilkymistSysctlState), VMSTATE_PTIMER(ptimer1, MilkymistSysctlState), VMSTATE_END_OF_LIST() } }; static Property milkymist_sysctl_properties[] = { DEFINE_PROP_UINT32("frequency", MilkymistSysctlState, freq_hz, 80000000), DEFINE_PROP_UINT32("capabilities", MilkymistSysctlState, capabilities, 0x00000000), DEFINE_PROP_UINT32("systemid", MilkymistSysctlState, systemid, 0x10014d31), DEFINE_PROP_UINT32("gpio_strappings", MilkymistSysctlState, strappings, 0x00000001),
.write = pxa2xx_keypad_write, .endianness = DEVICE_NATIVE_ENDIAN, }; static const VMStateDescription vmstate_pxa2xx_keypad = { .name = "pxa2xx_keypad", .version_id = 0, .minimum_version_id = 0, .minimum_version_id_old = 0, .fields = (VMStateField[]) { VMSTATE_UINT32(kpc, PXA2xxKeyPadState), VMSTATE_UINT32(kpdk, PXA2xxKeyPadState), VMSTATE_UINT32(kprec, PXA2xxKeyPadState), VMSTATE_UINT32(kpmk, PXA2xxKeyPadState), VMSTATE_UINT32(kpas, PXA2xxKeyPadState), VMSTATE_UINT32_ARRAY(kpasmkp, PXA2xxKeyPadState, 4), VMSTATE_UINT32(kpkdi, PXA2xxKeyPadState), VMSTATE_END_OF_LIST() } }; PXA2xxKeyPadState *pxa27x_keypad_init(MemoryRegion *sysmem, target_phys_addr_t base, qemu_irq irq) { PXA2xxKeyPadState *s; s = (PXA2xxKeyPadState *) g_malloc0(sizeof(PXA2xxKeyPadState)); s->irq = irq; memory_region_init_io(&s->iomem, &pxa2xx_keypad_ops, s,
static void dma_reset(DeviceState *d) { DMAState *s = container_of(d, DMAState, busdev.qdev); memset(s->dmaregs, 0, DMA_SIZE); s->dmaregs[0] = DMA_VER; } static const VMStateDescription vmstate_dma = { .name ="sparc32_dma", .version_id = 2, .minimum_version_id = 2, .minimum_version_id_old = 2, .fields = (VMStateField []) { VMSTATE_UINT32_ARRAY(dmaregs, DMAState, DMA_REGS), VMSTATE_END_OF_LIST() } }; static int sparc32_dma_init1(SysBusDevice *dev) { DMAState *s = FROM_SYSBUS(DMAState, dev); int dma_io_memory; sysbus_init_irq(dev, &s->irq); dma_io_memory = cpu_register_io_memory(dma_mem_read, dma_mem_write, s); sysbus_init_mmio(dev, DMA_SIZE, dma_io_memory); qdev_init_gpio_in(&dev->qdev, dma_set_irq, 1);
.name = "cpu", .version_id = 5, .minimum_version_id = 5, .minimum_version_id_old = 4, .load_state_old = cpu_load_old, .pre_save = cpu_pre_save, .post_load = cpu_post_load, .fields = (VMStateField[]) { VMSTATE_UNUSED(sizeof(target_ulong)), /* was _EQUAL(env.spr[SPR_PVR]) */ /* User mode architected state */ VMSTATE_UINTTL_ARRAY(env.gpr, PowerPCCPU, 32), #if !defined(TARGET_PPC64) VMSTATE_UINTTL_ARRAY(env.gprh, PowerPCCPU, 32), #endif VMSTATE_UINT32_ARRAY(env.crf, PowerPCCPU, 8), VMSTATE_UINTTL(env.nip, PowerPCCPU), /* SPRs */ VMSTATE_UINTTL_ARRAY(env.spr, PowerPCCPU, 1024), VMSTATE_UINT64(env.spe_acc, PowerPCCPU), /* Reservation */ VMSTATE_UINTTL(env.reserve_addr, PowerPCCPU), /* Supervisor mode architected state */ VMSTATE_UINTTL(env.msr, PowerPCCPU), /* Internal state */ VMSTATE_UINTTL(env.hflags_nmsr, PowerPCCPU), /* FIXME: access_type? */
s->silicon_rev); return; } memory_region_init_io(&s->iomem, OBJECT(s), &aspeed_scu_ops, s, TYPE_ASPEED_SCU, SCU_IO_REGION_SIZE); sysbus_init_mmio(sbd, &s->iomem); } static const VMStateDescription vmstate_aspeed_scu = { .name = "aspeed.scu", .version_id = 1, .minimum_version_id = 1, .fields = (VMStateField[]) { VMSTATE_UINT32_ARRAY(regs, AspeedSCUState, ASPEED_SCU_NR_REGS), VMSTATE_END_OF_LIST() } }; static Property aspeed_scu_properties[] = { DEFINE_PROP_UINT32("silicon-rev", AspeedSCUState, silicon_rev, 0), DEFINE_PROP_UINT32("hw-strap1", AspeedSCUState, hw_strap1, 0), DEFINE_PROP_UINT32("hw-strap2", AspeedSCUState, hw_strap2, 0), DEFINE_PROP_UINT32("hw-prot-key", AspeedSCUState, hw_prot_key, 0), DEFINE_PROP_END_OF_LIST(), }; static void aspeed_scu_class_init(ObjectClass *klass, void *data) { DeviceClass *dc = DEVICE_CLASS(klass);
.fields = (VMStateField[]) { VMSTATE_PCI_DEVICE(dev, PCISerialState), VMSTATE_STRUCT(state, PCISerialState, 0, vmstate_serial, SerialState), VMSTATE_END_OF_LIST() } }; static const VMStateDescription vmstate_pci_multi_serial = { .name = "pci-serial-multi", .version_id = 1, .minimum_version_id = 1, .fields = (VMStateField[]) { VMSTATE_PCI_DEVICE(dev, PCIMultiSerialState), VMSTATE_STRUCT_ARRAY(state, PCIMultiSerialState, PCI_SERIAL_MAX_PORTS, 0, vmstate_serial, SerialState), VMSTATE_UINT32_ARRAY(level, PCIMultiSerialState, PCI_SERIAL_MAX_PORTS), VMSTATE_END_OF_LIST() } }; static Property serial_pci_properties[] = { DEFINE_PROP_CHR("chardev", PCISerialState, state.chr), DEFINE_PROP_END_OF_LIST(), }; static Property multi_2x_serial_pci_properties[] = { DEFINE_PROP_CHR("chardev1", PCIMultiSerialState, state[0].chr), DEFINE_PROP_CHR("chardev2", PCIMultiSerialState, state[1].chr), DEFINE_PROP_END_OF_LIST(), };
.endianness = DEVICE_NATIVE_ENDIAN, }; typedef struct { SysBusDevice busdev; MemoryRegion *iomem; uint32_t regs[NUM_REGS]; } HighbankRegsState; static VMStateDescription vmstate_highbank_regs = { .name = "highbank-regs", .version_id = 0, .minimum_version_id = 0, .minimum_version_id_old = 0, .fields = (VMStateField[]) { VMSTATE_UINT32_ARRAY(regs, HighbankRegsState, NUM_REGS), VMSTATE_END_OF_LIST(), }, }; static void highbank_regs_reset(DeviceState *dev) { SysBusDevice *sys_dev = sysbus_from_qdev(dev); HighbankRegsState *s = FROM_SYSBUS(HighbankRegsState, sys_dev); s->regs[0x40] = 0x05F20121; s->regs[0x41] = 0x2; s->regs[0x42] = 0x05F30121; s->regs[0x43] = 0x05F40121; }
sysbus_init_mmio(dev, &s->iomem); /* Note: This device is not created in the board initialization, * instead it has to be added with the -device parameter. Therefore, * the device maps itself. */ sysbus_mmio_map(dev, 0, s->base); return 0; } static const VMStateDescription vmstate_lm32_sys = { .name = "lm32-sys", .version_id = 1, .minimum_version_id = 1, .fields = (VMStateField[]) { VMSTATE_UINT32_ARRAY(regs, LM32SysState, R_MAX), VMSTATE_BUFFER(testname, LM32SysState), VMSTATE_END_OF_LIST() } }; static Property lm32_sys_properties[] = { DEFINE_PROP_UINT32("base", LM32SysState, base, 0xffff0000), DEFINE_PROP_END_OF_LIST(), }; static void lm32_sys_class_init(ObjectClass *klass, void *data) { DeviceClass *dc = DEVICE_CLASS(klass); SysBusDeviceClass *k = SYS_BUS_DEVICE_CLASS(klass);
return 0; } static const VMStateDescription vmstate_milkymist_memcard = { .name = "milkymist-memcard", .version_id = 1, .minimum_version_id = 1, .fields = (VMStateField[]) { VMSTATE_INT32(command_write_ptr, MilkymistMemcardState), VMSTATE_INT32(response_read_ptr, MilkymistMemcardState), VMSTATE_INT32(response_len, MilkymistMemcardState), VMSTATE_INT32(ignore_next_cmd, MilkymistMemcardState), VMSTATE_INT32(enabled, MilkymistMemcardState), VMSTATE_UINT8_ARRAY(command, MilkymistMemcardState, 6), VMSTATE_UINT8_ARRAY(response, MilkymistMemcardState, 17), VMSTATE_UINT32_ARRAY(regs, MilkymistMemcardState, R_MAX), VMSTATE_END_OF_LIST() } }; static void milkymist_memcard_class_init(ObjectClass *klass, void *data) { DeviceClass *dc = DEVICE_CLASS(klass); SysBusDeviceClass *k = SYS_BUS_DEVICE_CLASS(klass); k->init = milkymist_memcard_init; dc->reset = milkymist_memcard_reset; dc->vmsd = &vmstate_milkymist_memcard; /* Reason: init() method uses drive_get_next() */ dc->cannot_instantiate_with_device_add_yet = true; }
return "ECSPI_MSGDATA"; default: sprintf(unknown, "%d ?", reg); return unknown; } } static const VMStateDescription vmstate_imx_spi = { .name = TYPE_IMX_SPI, .version_id = 1, .minimum_version_id = 1, .fields = (VMStateField[]) { VMSTATE_FIFO32(tx_fifo, IMXSPIState), VMSTATE_FIFO32(rx_fifo, IMXSPIState), VMSTATE_INT16(burst_length, IMXSPIState), VMSTATE_UINT32_ARRAY(regs, IMXSPIState, ECSPI_MAX), VMSTATE_END_OF_LIST() }, }; static void imx_spi_txfifo_reset(IMXSPIState *s) { fifo32_reset(&s->tx_fifo); s->regs[ECSPI_STATREG] |= ECSPI_STATREG_TE; s->regs[ECSPI_STATREG] &= ~ECSPI_STATREG_TF; } static void imx_spi_rxfifo_reset(IMXSPIState *s) { fifo32_reset(&s->rx_fifo); s->regs[ECSPI_STATREG] &= ~ECSPI_STATREG_RR;
s->irqline = -1; fifo8_create(&s->tx_fifo, FIFO_CAPACITY); fifo8_create(&s->rx_fifo, FIFO_CAPACITY); return 0; } static const VMStateDescription vmstate_xilinx_spi = { .name = "xilinx_spi", .version_id = 1, .minimum_version_id = 1, .fields = (VMStateField[]) { VMSTATE_FIFO8(tx_fifo, XilinxSPI), VMSTATE_FIFO8(rx_fifo, XilinxSPI), VMSTATE_UINT32_ARRAY(regs, XilinxSPI, R_MAX), VMSTATE_END_OF_LIST() } }; static Property xilinx_spi_properties[] = { DEFINE_PROP_UINT8("num-ss-bits", XilinxSPI, num_cs, 1), DEFINE_PROP_END_OF_LIST(), }; static void xilinx_spi_class_init(ObjectClass *klass, void *data) { DeviceClass *dc = DEVICE_CLASS(klass); SysBusDeviceClass *k = SYS_BUS_DEVICE_CLASS(klass); k->init = xilinx_spi_init;
VMSTATE_UINT32(mac_mii_data, lan9118_state), VMSTATE_UINT32(mac_flow, lan9118_state), VMSTATE_UINT32(phy_status, lan9118_state), VMSTATE_UINT32(phy_control, lan9118_state), VMSTATE_UINT32(phy_advertise, lan9118_state), VMSTATE_UINT32(phy_int, lan9118_state), VMSTATE_UINT32(phy_int_mask, lan9118_state), VMSTATE_INT32(eeprom_writable, lan9118_state), VMSTATE_UINT8_ARRAY(eeprom, lan9118_state, 128), VMSTATE_INT32(tx_fifo_size, lan9118_state), /* txp always points at tx_packet so need not be saved */ VMSTATE_STRUCT(tx_packet, lan9118_state, 0, vmstate_lan9118_packet, LAN9118Packet), VMSTATE_INT32(tx_status_fifo_used, lan9118_state), VMSTATE_INT32(tx_status_fifo_head, lan9118_state), VMSTATE_UINT32_ARRAY(tx_status_fifo, lan9118_state, 512), VMSTATE_INT32(rx_status_fifo_size, lan9118_state), VMSTATE_INT32(rx_status_fifo_used, lan9118_state), VMSTATE_INT32(rx_status_fifo_head, lan9118_state), VMSTATE_UINT32_ARRAY(rx_status_fifo, lan9118_state, 896), VMSTATE_INT32(rx_fifo_size, lan9118_state), VMSTATE_INT32(rx_fifo_used, lan9118_state), VMSTATE_INT32(rx_fifo_head, lan9118_state), VMSTATE_UINT32_ARRAY(rx_fifo, lan9118_state, 3360), VMSTATE_INT32(rx_packet_size_head, lan9118_state), VMSTATE_INT32(rx_packet_size_tail, lan9118_state), VMSTATE_INT32_ARRAY(rx_packet_size, lan9118_state, 1024), VMSTATE_INT32(rxp_offset, lan9118_state), VMSTATE_INT32(rxp_size, lan9118_state), VMSTATE_INT32(rxp_pad, lan9118_state), VMSTATE_UINT32_V(write_word_prev_offset, lan9118_state, 2),