2 * ARM Integrator CP System emulation.
4 * Copyright (c) 2005-2007 CodeSourcery.
5 * Written by Paul Brook
7 * This code is licensed under the GPL
10 #include "qemu/osdep.h"
11 #include "qapi/error.h"
12 #include "hw/sysbus.h"
13 #include "migration/vmstate.h"
14 #include "hw/boards.h"
15 #include "hw/arm/boot.h"
16 #include "hw/misc/arm_integrator_debug.h"
17 #include "hw/net/smc91c111.h"
19 #include "exec/address-spaces.h"
20 #include "sysemu/runstate.h"
21 #include "sysemu/sysemu.h"
23 #include "qemu/error-report.h"
24 #include "hw/char/pl011.h"
28 #include "qom/object.h"
29 #include "audio/audio.h"
30 #include "target/arm/cpu-qom.h"
32 #define TYPE_INTEGRATOR_CM "integrator_core"
33 OBJECT_DECLARE_SIMPLE_TYPE(IntegratorCMState
, INTEGRATOR_CM
)
35 struct IntegratorCMState
{
37 SysBusDevice parent_obj
;
51 uint32_t cm_refcnt_offset
;
57 static uint8_t integrator_spd
[128] = {
58 128, 8, 4, 11, 9, 1, 64, 0, 2, 0xa0, 0xa0, 0, 0, 8, 0, 1,
59 0xe, 4, 0x1c, 1, 2, 0x20, 0xc0, 0, 0, 0, 0, 0x30, 0x28, 0x30, 0x28, 0x40
62 static const VMStateDescription vmstate_integratorcm
= {
63 .name
= "integratorcm",
65 .minimum_version_id
= 1,
66 .fields
= (const VMStateField
[]) {
67 VMSTATE_UINT32(cm_osc
, IntegratorCMState
),
68 VMSTATE_UINT32(cm_ctrl
, IntegratorCMState
),
69 VMSTATE_UINT32(cm_lock
, IntegratorCMState
),
70 VMSTATE_UINT32(cm_auxosc
, IntegratorCMState
),
71 VMSTATE_UINT32(cm_sdram
, IntegratorCMState
),
72 VMSTATE_UINT32(cm_init
, IntegratorCMState
),
73 VMSTATE_UINT32(cm_flags
, IntegratorCMState
),
74 VMSTATE_UINT32(cm_nvflags
, IntegratorCMState
),
75 VMSTATE_UINT32(int_level
, IntegratorCMState
),
76 VMSTATE_UINT32(irq_enabled
, IntegratorCMState
),
77 VMSTATE_UINT32(fiq_enabled
, IntegratorCMState
),
82 static uint64_t integratorcm_read(void *opaque
, hwaddr offset
,
85 IntegratorCMState
*s
= opaque
;
86 if (offset
>= 0x100 && offset
< 0x200) {
90 return integrator_spd
[offset
>> 2];
92 switch (offset
>> 2) {
101 case 4: /* CM_STAT */
103 case 5: /* CM_LOCK */
104 if (s
->cm_lock
== 0xa05f) {
109 case 6: /* CM_LMBUSCNT */
110 /* ??? High frequency timer. */
111 hw_error("integratorcm_read: CM_LMBUSCNT");
112 case 7: /* CM_AUXOSC */
114 case 8: /* CM_SDRAM */
116 case 9: /* CM_INIT */
118 case 10: /* CM_REFCNT */
119 /* This register, CM_REFCNT, provides a 32-bit count value.
120 * The count increments at the fixed reference clock frequency of 24MHz
121 * and can be used as a real-time counter.
123 return (uint32_t)muldiv64(qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
), 24,
124 1000) - s
->cm_refcnt_offset
;
125 case 12: /* CM_FLAGS */
127 case 14: /* CM_NVFLAGS */
128 return s
->cm_nvflags
;
129 case 16: /* CM_IRQ_STAT */
130 return s
->int_level
& s
->irq_enabled
;
131 case 17: /* CM_IRQ_RSTAT */
133 case 18: /* CM_IRQ_ENSET */
134 return s
->irq_enabled
;
135 case 20: /* CM_SOFT_INTSET */
136 return s
->int_level
& 1;
137 case 24: /* CM_FIQ_STAT */
138 return s
->int_level
& s
->fiq_enabled
;
139 case 25: /* CM_FIQ_RSTAT */
141 case 26: /* CM_FIQ_ENSET */
142 return s
->fiq_enabled
;
143 case 32: /* CM_VOLTAGE_CTL0 */
144 case 33: /* CM_VOLTAGE_CTL1 */
145 case 34: /* CM_VOLTAGE_CTL2 */
146 case 35: /* CM_VOLTAGE_CTL3 */
147 /* ??? Voltage control unimplemented. */
150 qemu_log_mask(LOG_UNIMP
,
151 "%s: Unimplemented offset 0x%" HWADDR_PRIX
"\n",
157 static void integratorcm_do_remap(IntegratorCMState
*s
)
159 /* Sync memory region state with CM_CTRL REMAP bit:
160 * bit 0 => flash at address 0; bit 1 => RAM
162 memory_region_set_enabled(&s
->flash
, !(s
->cm_ctrl
& 4));
165 static void integratorcm_set_ctrl(IntegratorCMState
*s
, uint32_t value
)
168 qemu_system_reset_request(SHUTDOWN_CAUSE_GUEST_RESET
);
170 if ((s
->cm_ctrl
^ value
) & 1) {
171 /* (value & 1) != 0 means the green "MISC LED" is lit.
172 * We don't have any nice place to display LEDs. printf is a bad
173 * idea because Linux uses the LED as a heartbeat and the output
174 * will swamp anything else on the terminal.
177 /* Note that the RESET bit [3] always reads as zero */
178 s
->cm_ctrl
= (s
->cm_ctrl
& ~5) | (value
& 5);
179 integratorcm_do_remap(s
);
182 static void integratorcm_update(IntegratorCMState
*s
)
184 /* ??? The CPU irq/fiq is raised when either the core module or base PIC
186 if (s
->int_level
& (s
->irq_enabled
| s
->fiq_enabled
))
187 hw_error("Core module interrupt\n");
190 static void integratorcm_write(void *opaque
, hwaddr offset
,
191 uint64_t value
, unsigned size
)
193 IntegratorCMState
*s
= opaque
;
194 switch (offset
>> 2) {
196 if (s
->cm_lock
== 0xa05f)
199 case 3: /* CM_CTRL */
200 integratorcm_set_ctrl(s
, value
);
202 case 5: /* CM_LOCK */
203 s
->cm_lock
= value
& 0xffff;
205 case 7: /* CM_AUXOSC */
206 if (s
->cm_lock
== 0xa05f)
207 s
->cm_auxosc
= value
;
209 case 8: /* CM_SDRAM */
212 case 9: /* CM_INIT */
213 /* ??? This can change the memory bus frequency. */
216 case 12: /* CM_FLAGSS */
217 s
->cm_flags
|= value
;
219 case 13: /* CM_FLAGSC */
220 s
->cm_flags
&= ~value
;
222 case 14: /* CM_NVFLAGSS */
223 s
->cm_nvflags
|= value
;
225 case 15: /* CM_NVFLAGSS */
226 s
->cm_nvflags
&= ~value
;
228 case 18: /* CM_IRQ_ENSET */
229 s
->irq_enabled
|= value
;
230 integratorcm_update(s
);
232 case 19: /* CM_IRQ_ENCLR */
233 s
->irq_enabled
&= ~value
;
234 integratorcm_update(s
);
236 case 20: /* CM_SOFT_INTSET */
237 s
->int_level
|= (value
& 1);
238 integratorcm_update(s
);
240 case 21: /* CM_SOFT_INTCLR */
241 s
->int_level
&= ~(value
& 1);
242 integratorcm_update(s
);
244 case 26: /* CM_FIQ_ENSET */
245 s
->fiq_enabled
|= value
;
246 integratorcm_update(s
);
248 case 27: /* CM_FIQ_ENCLR */
249 s
->fiq_enabled
&= ~value
;
250 integratorcm_update(s
);
252 case 32: /* CM_VOLTAGE_CTL0 */
253 case 33: /* CM_VOLTAGE_CTL1 */
254 case 34: /* CM_VOLTAGE_CTL2 */
255 case 35: /* CM_VOLTAGE_CTL3 */
256 /* ??? Voltage control unimplemented. */
259 qemu_log_mask(LOG_UNIMP
,
260 "%s: Unimplemented offset 0x%" HWADDR_PRIX
"\n",
266 /* Integrator/CM control registers. */
268 static const MemoryRegionOps integratorcm_ops
= {
269 .read
= integratorcm_read
,
270 .write
= integratorcm_write
,
271 .endianness
= DEVICE_NATIVE_ENDIAN
,
274 static void integratorcm_init(Object
*obj
)
276 IntegratorCMState
*s
= INTEGRATOR_CM(obj
);
278 s
->cm_osc
= 0x01000048;
279 /* ??? What should the high bits of this value be? */
280 s
->cm_auxosc
= 0x0007feff;
281 s
->cm_sdram
= 0x00011122;
282 memcpy(integrator_spd
+ 73, "QEMU-MEMORY", 11);
283 s
->cm_init
= 0x00000112;
284 s
->cm_refcnt_offset
= muldiv64(qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
), 24,
287 /* ??? Save/restore. */
290 static void integratorcm_realize(DeviceState
*d
, Error
**errp
)
292 IntegratorCMState
*s
= INTEGRATOR_CM(d
);
293 SysBusDevice
*dev
= SYS_BUS_DEVICE(d
);
295 if (!memory_region_init_ram(&s
->flash
, OBJECT(d
), "integrator.flash",
300 memory_region_init_io(&s
->iomem
, OBJECT(d
), &integratorcm_ops
, s
,
301 "integratorcm", 0x00800000);
302 sysbus_init_mmio(dev
, &s
->iomem
);
304 integratorcm_do_remap(s
);
306 if (s
->memsz
>= 256) {
307 integrator_spd
[31] = 64;
309 } else if (s
->memsz
>= 128) {
310 integrator_spd
[31] = 32;
312 } else if (s
->memsz
>= 64) {
313 integrator_spd
[31] = 16;
315 } else if (s
->memsz
>= 32) {
316 integrator_spd
[31] = 4;
319 integrator_spd
[31] = 2;
323 /* Integrator/CP hardware emulation. */
324 /* Primary interrupt controller. */
326 #define TYPE_INTEGRATOR_PIC "integrator_pic"
327 OBJECT_DECLARE_SIMPLE_TYPE(icp_pic_state
, INTEGRATOR_PIC
)
329 struct icp_pic_state
{
331 SysBusDevice parent_obj
;
336 uint32_t irq_enabled
;
337 uint32_t fiq_enabled
;
342 static const VMStateDescription vmstate_icp_pic
= {
345 .minimum_version_id
= 1,
346 .fields
= (const VMStateField
[]) {
347 VMSTATE_UINT32(level
, icp_pic_state
),
348 VMSTATE_UINT32(irq_enabled
, icp_pic_state
),
349 VMSTATE_UINT32(fiq_enabled
, icp_pic_state
),
350 VMSTATE_END_OF_LIST()
354 static void icp_pic_update(icp_pic_state
*s
)
358 flags
= (s
->level
& s
->irq_enabled
);
359 qemu_set_irq(s
->parent_irq
, flags
!= 0);
360 flags
= (s
->level
& s
->fiq_enabled
);
361 qemu_set_irq(s
->parent_fiq
, flags
!= 0);
364 static void icp_pic_set_irq(void *opaque
, int irq
, int level
)
366 icp_pic_state
*s
= (icp_pic_state
*)opaque
;
368 s
->level
|= 1 << irq
;
370 s
->level
&= ~(1 << irq
);
374 static uint64_t icp_pic_read(void *opaque
, hwaddr offset
,
377 icp_pic_state
*s
= (icp_pic_state
*)opaque
;
379 switch (offset
>> 2) {
380 case 0: /* IRQ_STATUS */
381 return s
->level
& s
->irq_enabled
;
382 case 1: /* IRQ_RAWSTAT */
384 case 2: /* IRQ_ENABLESET */
385 return s
->irq_enabled
;
386 case 4: /* INT_SOFTSET */
388 case 8: /* FRQ_STATUS */
389 return s
->level
& s
->fiq_enabled
;
390 case 9: /* FRQ_RAWSTAT */
392 case 10: /* FRQ_ENABLESET */
393 return s
->fiq_enabled
;
394 case 3: /* IRQ_ENABLECLR */
395 case 5: /* INT_SOFTCLR */
396 case 11: /* FRQ_ENABLECLR */
398 qemu_log_mask(LOG_GUEST_ERROR
, "%s: Bad offset 0x%" HWADDR_PRIX
"\n",
404 static void icp_pic_write(void *opaque
, hwaddr offset
,
405 uint64_t value
, unsigned size
)
407 icp_pic_state
*s
= (icp_pic_state
*)opaque
;
409 switch (offset
>> 2) {
410 case 2: /* IRQ_ENABLESET */
411 s
->irq_enabled
|= value
;
413 case 3: /* IRQ_ENABLECLR */
414 s
->irq_enabled
&= ~value
;
416 case 4: /* INT_SOFTSET */
418 icp_pic_set_irq(s
, 0, 1);
420 case 5: /* INT_SOFTCLR */
422 icp_pic_set_irq(s
, 0, 0);
424 case 10: /* FRQ_ENABLESET */
425 s
->fiq_enabled
|= value
;
427 case 11: /* FRQ_ENABLECLR */
428 s
->fiq_enabled
&= ~value
;
430 case 0: /* IRQ_STATUS */
431 case 1: /* IRQ_RAWSTAT */
432 case 8: /* FRQ_STATUS */
433 case 9: /* FRQ_RAWSTAT */
435 qemu_log_mask(LOG_GUEST_ERROR
, "%s: Bad offset 0x%" HWADDR_PRIX
"\n",
442 static const MemoryRegionOps icp_pic_ops
= {
443 .read
= icp_pic_read
,
444 .write
= icp_pic_write
,
445 .endianness
= DEVICE_NATIVE_ENDIAN
,
448 static void icp_pic_init(Object
*obj
)
450 DeviceState
*dev
= DEVICE(obj
);
451 icp_pic_state
*s
= INTEGRATOR_PIC(obj
);
452 SysBusDevice
*sbd
= SYS_BUS_DEVICE(obj
);
454 qdev_init_gpio_in(dev
, icp_pic_set_irq
, 32);
455 sysbus_init_irq(sbd
, &s
->parent_irq
);
456 sysbus_init_irq(sbd
, &s
->parent_fiq
);
457 memory_region_init_io(&s
->iomem
, obj
, &icp_pic_ops
, s
,
458 "icp-pic", 0x00800000);
459 sysbus_init_mmio(sbd
, &s
->iomem
);
462 /* CP control registers. */
464 #define TYPE_ICP_CONTROL_REGS "icp-ctrl-regs"
465 OBJECT_DECLARE_SIMPLE_TYPE(ICPCtrlRegsState
, ICP_CONTROL_REGS
)
467 struct ICPCtrlRegsState
{
469 SysBusDevice parent_obj
;
475 uint32_t intreg_state
;
478 #define ICP_GPIO_MMC_WPROT "mmc-wprot"
479 #define ICP_GPIO_MMC_CARDIN "mmc-cardin"
481 #define ICP_INTREG_WPROT (1 << 0)
482 #define ICP_INTREG_CARDIN (1 << 3)
484 static const VMStateDescription vmstate_icp_control
= {
485 .name
= "icp_control",
487 .minimum_version_id
= 1,
488 .fields
= (const VMStateField
[]) {
489 VMSTATE_UINT32(intreg_state
, ICPCtrlRegsState
),
490 VMSTATE_END_OF_LIST()
494 static uint64_t icp_control_read(void *opaque
, hwaddr offset
,
497 ICPCtrlRegsState
*s
= opaque
;
499 switch (offset
>> 2) {
500 case 0: /* CP_IDFIELD */
502 case 1: /* CP_FLASHPROG */
504 case 2: /* CP_INTREG */
505 return s
->intreg_state
;
506 case 3: /* CP_DECODE */
509 qemu_log_mask(LOG_GUEST_ERROR
, "%s: Bad offset 0x%" HWADDR_PRIX
"\n",
515 static void icp_control_write(void *opaque
, hwaddr offset
,
516 uint64_t value
, unsigned size
)
518 ICPCtrlRegsState
*s
= opaque
;
520 switch (offset
>> 2) {
521 case 2: /* CP_INTREG */
522 s
->intreg_state
&= ~(value
& ICP_INTREG_CARDIN
);
523 qemu_set_irq(s
->mmc_irq
, !!(s
->intreg_state
& ICP_INTREG_CARDIN
));
525 case 1: /* CP_FLASHPROG */
526 case 3: /* CP_DECODE */
527 /* Nothing interesting implemented yet. */
530 qemu_log_mask(LOG_GUEST_ERROR
, "%s: Bad offset 0x%" HWADDR_PRIX
"\n",
535 static const MemoryRegionOps icp_control_ops
= {
536 .read
= icp_control_read
,
537 .write
= icp_control_write
,
538 .endianness
= DEVICE_NATIVE_ENDIAN
,
541 static void icp_control_mmc_wprot(void *opaque
, int line
, int level
)
543 ICPCtrlRegsState
*s
= opaque
;
545 s
->intreg_state
&= ~ICP_INTREG_WPROT
;
547 s
->intreg_state
|= ICP_INTREG_WPROT
;
551 static void icp_control_mmc_cardin(void *opaque
, int line
, int level
)
553 ICPCtrlRegsState
*s
= opaque
;
555 /* line is released by writing to CP_INTREG */
557 s
->intreg_state
|= ICP_INTREG_CARDIN
;
558 qemu_set_irq(s
->mmc_irq
, 1);
562 static void icp_control_init(Object
*obj
)
564 SysBusDevice
*sbd
= SYS_BUS_DEVICE(obj
);
565 ICPCtrlRegsState
*s
= ICP_CONTROL_REGS(obj
);
566 DeviceState
*dev
= DEVICE(obj
);
568 memory_region_init_io(&s
->iomem
, OBJECT(s
), &icp_control_ops
, s
,
569 "icp_ctrl_regs", 0x00800000);
570 sysbus_init_mmio(sbd
, &s
->iomem
);
572 qdev_init_gpio_in_named(dev
, icp_control_mmc_wprot
, ICP_GPIO_MMC_WPROT
, 1);
573 qdev_init_gpio_in_named(dev
, icp_control_mmc_cardin
,
574 ICP_GPIO_MMC_CARDIN
, 1);
575 sysbus_init_irq(sbd
, &s
->mmc_irq
);
581 static struct arm_boot_info integrator_binfo
= {
586 static void integratorcp_init(MachineState
*machine
)
588 ram_addr_t ram_size
= machine
->ram_size
;
591 MemoryRegion
*address_space_mem
= get_system_memory();
592 MemoryRegion
*ram_alias
= g_new(MemoryRegion
, 1);
594 DeviceState
*dev
, *sic
, *icp
;
598 cpuobj
= object_new(machine
->cpu_type
);
600 /* By default ARM1176 CPUs have EL3 enabled. This board does not
601 * currently support EL3 so the CPU EL3 property is disabled before
604 if (object_property_find(cpuobj
, "has_el3")) {
605 object_property_set_bool(cpuobj
, "has_el3", false, &error_fatal
);
608 qdev_realize(DEVICE(cpuobj
), NULL
, &error_fatal
);
610 cpu
= ARM_CPU(cpuobj
);
612 /* ??? On a real system the first 1Mb is mapped as SSRAM or boot flash. */
613 /* ??? RAM should repeat to fill physical memory space. */
614 /* SDRAM at address zero*/
615 memory_region_add_subregion(address_space_mem
, 0, machine
->ram
);
616 /* And again at address 0x80000000 */
617 memory_region_init_alias(ram_alias
, NULL
, "ram.alias", machine
->ram
,
619 memory_region_add_subregion(address_space_mem
, 0x80000000, ram_alias
);
621 dev
= qdev_new(TYPE_INTEGRATOR_CM
);
622 qdev_prop_set_uint32(dev
, "memsz", ram_size
>> 20);
623 sysbus_realize_and_unref(SYS_BUS_DEVICE(dev
), &error_fatal
);
624 sysbus_mmio_map((SysBusDevice
*)dev
, 0, 0x10000000);
626 dev
= sysbus_create_varargs(TYPE_INTEGRATOR_PIC
, 0x14000000,
627 qdev_get_gpio_in(DEVICE(cpu
), ARM_CPU_IRQ
),
628 qdev_get_gpio_in(DEVICE(cpu
), ARM_CPU_FIQ
),
630 for (i
= 0; i
< 32; i
++) {
631 pic
[i
] = qdev_get_gpio_in(dev
, i
);
633 sic
= sysbus_create_simple(TYPE_INTEGRATOR_PIC
, 0xca000000, pic
[26]);
634 sysbus_create_varargs("integrator_pit", 0x13000000,
635 pic
[5], pic
[6], pic
[7], NULL
);
636 sysbus_create_simple("pl031", 0x15000000, pic
[8]);
637 pl011_create(0x16000000, pic
[1], serial_hd(0));
638 pl011_create(0x17000000, pic
[2], serial_hd(1));
639 icp
= sysbus_create_simple(TYPE_ICP_CONTROL_REGS
, 0xcb000000,
640 qdev_get_gpio_in(sic
, 3));
641 sysbus_create_simple("pl050_keyboard", 0x18000000, pic
[3]);
642 sysbus_create_simple("pl050_mouse", 0x19000000, pic
[4]);
643 sysbus_create_simple(TYPE_INTEGRATOR_DEBUG
, 0x1a000000, 0);
645 dev
= sysbus_create_varargs("pl181", 0x1c000000, pic
[23], pic
[24], NULL
);
646 qdev_connect_gpio_out_named(dev
, "card-read-only", 0,
647 qdev_get_gpio_in_named(icp
, ICP_GPIO_MMC_WPROT
, 0));
648 qdev_connect_gpio_out_named(dev
, "card-inserted", 0,
649 qdev_get_gpio_in_named(icp
, ICP_GPIO_MMC_CARDIN
, 0));
650 dinfo
= drive_get(IF_SD
, 0, 0);
654 card
= qdev_new(TYPE_SD_CARD
);
655 qdev_prop_set_drive_err(card
, "drive", blk_by_legacy_dinfo(dinfo
),
657 qdev_realize_and_unref(card
, qdev_get_child_bus(dev
, "sd-bus"),
661 dev
= qdev_new("pl041");
662 if (machine
->audiodev
) {
663 qdev_prop_set_string(dev
, "audiodev", machine
->audiodev
);
665 sysbus_realize_and_unref(SYS_BUS_DEVICE(dev
), &error_fatal
);
666 sysbus_mmio_map(SYS_BUS_DEVICE(dev
), 0, 0x1d000000);
667 sysbus_connect_irq(SYS_BUS_DEVICE(dev
), 0, pic
[25]);
669 if (qemu_find_nic_info("smc91c111", true, NULL
)) {
670 smc91c111_init(0xc8000000, pic
[27]);
673 dev
= qdev_new("pl110");
674 object_property_set_link(OBJECT(dev
), "framebuffer-memory",
675 OBJECT(address_space_mem
), &error_fatal
);
676 sysbus_realize_and_unref(SYS_BUS_DEVICE(dev
), &error_fatal
);
677 sysbus_mmio_map(SYS_BUS_DEVICE(dev
), 0, 0xc0000000);
678 sysbus_connect_irq(SYS_BUS_DEVICE(dev
), 0, pic
[22]);
680 integrator_binfo
.ram_size
= ram_size
;
681 arm_load_kernel(cpu
, machine
, &integrator_binfo
);
684 static void integratorcp_machine_init(MachineClass
*mc
)
686 mc
->desc
= "ARM Integrator/CP (ARM926EJ-S)";
687 mc
->init
= integratorcp_init
;
688 mc
->ignore_memory_transaction_failures
= true;
689 mc
->default_cpu_type
= ARM_CPU_TYPE_NAME("arm926");
690 mc
->default_ram_id
= "integrator.ram";
692 machine_add_audiodev_property(mc
);
695 DEFINE_MACHINE("integratorcp", integratorcp_machine_init
)
697 static Property core_properties
[] = {
698 DEFINE_PROP_UINT32("memsz", IntegratorCMState
, memsz
, 0),
699 DEFINE_PROP_END_OF_LIST(),
702 static void core_class_init(ObjectClass
*klass
, void *data
)
704 DeviceClass
*dc
= DEVICE_CLASS(klass
);
706 device_class_set_props(dc
, core_properties
);
707 dc
->realize
= integratorcm_realize
;
708 dc
->vmsd
= &vmstate_integratorcm
;
711 static void icp_pic_class_init(ObjectClass
*klass
, void *data
)
713 DeviceClass
*dc
= DEVICE_CLASS(klass
);
715 dc
->vmsd
= &vmstate_icp_pic
;
718 static void icp_control_class_init(ObjectClass
*klass
, void *data
)
720 DeviceClass
*dc
= DEVICE_CLASS(klass
);
722 dc
->vmsd
= &vmstate_icp_control
;
725 static const TypeInfo core_info
= {
726 .name
= TYPE_INTEGRATOR_CM
,
727 .parent
= TYPE_SYS_BUS_DEVICE
,
728 .instance_size
= sizeof(IntegratorCMState
),
729 .instance_init
= integratorcm_init
,
730 .class_init
= core_class_init
,
733 static const TypeInfo icp_pic_info
= {
734 .name
= TYPE_INTEGRATOR_PIC
,
735 .parent
= TYPE_SYS_BUS_DEVICE
,
736 .instance_size
= sizeof(icp_pic_state
),
737 .instance_init
= icp_pic_init
,
738 .class_init
= icp_pic_class_init
,
741 static const TypeInfo icp_ctrl_regs_info
= {
742 .name
= TYPE_ICP_CONTROL_REGS
,
743 .parent
= TYPE_SYS_BUS_DEVICE
,
744 .instance_size
= sizeof(ICPCtrlRegsState
),
745 .instance_init
= icp_control_init
,
746 .class_init
= icp_control_class_init
,
749 static void integratorcp_register_types(void)
751 type_register_static(&icp_pic_info
);
752 type_register_static(&core_info
);
753 type_register_static(&icp_ctrl_regs_info
);
756 type_init(integratorcp_register_types
)