2 * SPDX-License-Identifier: GPL-2.0-or-later
4 * QEMU Vitual M68K Machine
6 * (c) 2020 Laurent Vivier <laurent@vivier.eu>
10 #include "qemu/osdep.h"
11 #include "qemu/units.h"
12 #include "qemu-common.h"
13 #include "sysemu/sysemu.h"
15 #include "hw/boards.h"
16 #include "hw/qdev-properties.h"
18 #include "hw/loader.h"
19 #include "ui/console.h"
20 #include "hw/sysbus.h"
21 #include "standard-headers/asm-m68k/bootinfo.h"
22 #include "standard-headers/asm-m68k/bootinfo-virt.h"
25 #include "qapi/error.h"
26 #include "sysemu/qtest.h"
27 #include "sysemu/runstate.h"
28 #include "sysemu/reset.h"
30 #include "hw/intc/m68k_irqc.h"
31 #include "hw/misc/virt_ctrl.h"
32 #include "hw/char/goldfish_tty.h"
33 #include "hw/rtc/goldfish_rtc.h"
34 #include "hw/intc/goldfish_pic.h"
35 #include "hw/virtio/virtio-mmio.h"
36 #include "hw/virtio/virtio-blk.h"
39 * 6 goldfish-pic for CPU IRQ #1 to IRQ #6
40 * CPU IRQ #1 -> PIC #1
41 * IRQ #1 to IRQ #31 -> unused
42 * IRQ #32 -> goldfish-tty
43 * CPU IRQ #2 -> PIC #2
44 * IRQ #1 to IRQ #32 -> virtio-mmio from 1 to 32
45 * CPU IRQ #3 -> PIC #3
46 * IRQ #1 to IRQ #32 -> virtio-mmio from 33 to 64
47 * CPU IRQ #4 -> PIC #4
48 * IRQ #1 to IRQ #32 -> virtio-mmio from 65 to 96
49 * CPU IRQ #5 -> PIC #5
50 * IRQ #1 to IRQ #32 -> virtio-mmio from 97 to 128
51 * CPU IRQ #6 -> PIC #6
52 * IRQ #1 -> goldfish-rtc
53 * IRQ #2 to IRQ #32 -> unused
57 #define PIC_IRQ_BASE(num) (8 + (num - 1) * 32)
58 #define PIC_IRQ(num, irq) (PIC_IRQ_BASE(num) + irq - 1)
59 #define PIC_GPIO(pic_irq) (qdev_get_gpio_in(pic_dev[(pic_irq - 8) / 32], \
62 #define VIRT_GF_PIC_MMIO_BASE 0xff000000 /* MMIO: 0xff000000 - 0xff005fff */
63 #define VIRT_GF_PIC_IRQ_BASE 1 /* IRQ: #1 -> #6 */
64 #define VIRT_GF_PIC_NB 6
66 /* 2 goldfish-rtc (and timer) */
67 #define VIRT_GF_RTC_MMIO_BASE 0xff006000 /* MMIO: 0xff006000 - 0xff007fff */
68 #define VIRT_GF_RTC_IRQ_BASE PIC_IRQ(6, 1) /* PIC: #6, IRQ: #1 */
69 #define VIRT_GF_RTC_NB 2
72 #define VIRT_GF_TTY_MMIO_BASE 0xff008000 /* MMIO: 0xff008000 - 0xff008fff */
73 #define VIRT_GF_TTY_IRQ_BASE PIC_IRQ(1, 32) /* PIC: #1, IRQ: #32 */
76 #define VIRT_CTRL_MMIO_BASE 0xff009000 /* MMIO: 0xff009000 - 0xff009fff */
77 #define VIRT_CTRL_IRQ_BASE PIC_IRQ(1, 1) /* PIC: #1, IRQ: #1 */
80 * virtio-mmio size is 0x200 bytes
81 * we use 4 goldfish-pic to attach them,
82 * we can attach 32 virtio devices / goldfish-pic
83 * -> we can manage 32 * 4 = 128 virtio devices
85 #define VIRT_VIRTIO_MMIO_BASE 0xff010000 /* MMIO: 0xff010000 - 0xff01ffff */
86 #define VIRT_VIRTIO_IRQ_BASE PIC_IRQ(2, 1) /* PIC: 2, 3, 4, 5, IRQ: ALL */
94 static void main_cpu_reset(void *opaque
)
96 ResetInfo
*reset_info
= opaque
;
97 M68kCPU
*cpu
= reset_info
->cpu
;
98 CPUState
*cs
= CPU(cpu
);
101 cpu
->env
.aregs
[7] = reset_info
->initial_stack
;
102 cpu
->env
.pc
= reset_info
->initial_pc
;
105 static void virt_init(MachineState
*machine
)
110 ram_addr_t initrd_base
;
112 ram_addr_t ram_size
= machine
->ram_size
;
113 const char *kernel_filename
= machine
->kernel_filename
;
114 const char *initrd_filename
= machine
->initrd_filename
;
115 const char *kernel_cmdline
= machine
->kernel_cmdline
;
116 hwaddr parameters_base
;
118 DeviceState
*irqc_dev
;
119 DeviceState
*pic_dev
[VIRT_GF_PIC_NB
];
120 SysBusDevice
*sysbus
;
123 ResetInfo
*reset_info
;
125 if (ram_size
> 3399672 * KiB
) {
127 * The physical memory can be up to 4 GiB - 16 MiB, but linux
128 * kernel crashes after this limit (~ 3.2 GiB)
130 error_report("Too much memory for this machine: %" PRId64
" KiB, "
131 "maximum 3399672 KiB", ram_size
/ KiB
);
135 reset_info
= g_new0(ResetInfo
, 1);
138 cpu
= M68K_CPU(cpu_create(machine
->cpu_type
));
140 reset_info
->cpu
= cpu
;
141 qemu_register_reset(main_cpu_reset
, reset_info
);
144 memory_region_add_subregion(get_system_memory(), 0, machine
->ram
);
148 irqc_dev
= qdev_new(TYPE_M68K_IRQC
);
149 sysbus_realize_and_unref(SYS_BUS_DEVICE(irqc_dev
), &error_fatal
);
154 * map: 0xff000000 - 0xff006fff = 28 KiB
155 * IRQ: #1 (lower priority) -> #6 (higher priority)
158 io_base
= VIRT_GF_PIC_MMIO_BASE
;
159 for (i
= 0; i
< VIRT_GF_PIC_NB
; i
++) {
160 pic_dev
[i
] = qdev_new(TYPE_GOLDFISH_PIC
);
161 sysbus
= SYS_BUS_DEVICE(pic_dev
[i
]);
162 qdev_prop_set_uint8(pic_dev
[i
], "index", i
);
163 sysbus_realize_and_unref(sysbus
, &error_fatal
);
165 sysbus_mmio_map(sysbus
, 0, io_base
);
166 sysbus_connect_irq(sysbus
, 0, qdev_get_gpio_in(irqc_dev
, i
));
172 io_base
= VIRT_GF_RTC_MMIO_BASE
;
173 for (i
= 0; i
< VIRT_GF_RTC_NB
; i
++) {
174 dev
= qdev_new(TYPE_GOLDFISH_RTC
);
175 sysbus
= SYS_BUS_DEVICE(dev
);
176 sysbus_realize_and_unref(sysbus
, &error_fatal
);
177 sysbus_mmio_map(sysbus
, 0, io_base
);
178 sysbus_connect_irq(sysbus
, 0, PIC_GPIO(VIRT_GF_RTC_IRQ_BASE
+ i
));
184 dev
= qdev_new(TYPE_GOLDFISH_TTY
);
185 sysbus
= SYS_BUS_DEVICE(dev
);
186 qdev_prop_set_chr(dev
, "chardev", serial_hd(0));
187 sysbus_realize_and_unref(sysbus
, &error_fatal
);
188 sysbus_mmio_map(sysbus
, 0, VIRT_GF_TTY_MMIO_BASE
);
189 sysbus_connect_irq(sysbus
, 0, PIC_GPIO(VIRT_GF_TTY_IRQ_BASE
));
191 /* virt controller */
192 dev
= qdev_new(TYPE_VIRT_CTRL
);
193 sysbus
= SYS_BUS_DEVICE(dev
);
194 sysbus_realize_and_unref(sysbus
, &error_fatal
);
195 sysbus_mmio_map(sysbus
, 0, VIRT_CTRL_MMIO_BASE
);
196 sysbus_connect_irq(sysbus
, 0, PIC_GPIO(VIRT_CTRL_IRQ_BASE
));
199 io_base
= VIRT_VIRTIO_MMIO_BASE
;
200 for (i
= 0; i
< 128; i
++) {
201 dev
= qdev_new(TYPE_VIRTIO_MMIO
);
202 qdev_prop_set_bit(dev
, "force-legacy", false);
203 sysbus
= SYS_BUS_DEVICE(dev
);
204 sysbus_realize_and_unref(sysbus
, &error_fatal
);
205 sysbus_connect_irq(sysbus
, 0, PIC_GPIO(VIRT_VIRTIO_IRQ_BASE
+ i
));
206 sysbus_mmio_map(sysbus
, 0, io_base
);
210 if (kernel_filename
) {
211 CPUState
*cs
= CPU(cpu
);
214 kernel_size
= load_elf(kernel_filename
, NULL
, NULL
, NULL
,
215 &elf_entry
, NULL
, &high
, NULL
, 1,
217 if (kernel_size
< 0) {
218 error_report("could not load kernel '%s'", kernel_filename
);
221 reset_info
->initial_pc
= elf_entry
;
222 parameters_base
= (high
+ 1) & ~1;
224 BOOTINFO1(cs
->as
, parameters_base
, BI_MACHTYPE
, MACH_VIRT
);
225 BOOTINFO1(cs
->as
, parameters_base
, BI_FPUTYPE
, FPU_68040
);
226 BOOTINFO1(cs
->as
, parameters_base
, BI_MMUTYPE
, MMU_68040
);
227 BOOTINFO1(cs
->as
, parameters_base
, BI_CPUTYPE
, CPU_68040
);
228 BOOTINFO2(cs
->as
, parameters_base
, BI_MEMCHUNK
, 0, ram_size
);
230 BOOTINFO1(cs
->as
, parameters_base
, BI_VIRT_QEMU_VERSION
,
231 ((QEMU_VERSION_MAJOR
<< 24) | (QEMU_VERSION_MINOR
<< 16) |
232 (QEMU_VERSION_MICRO
<< 8)));
233 BOOTINFO2(cs
->as
, parameters_base
, BI_VIRT_GF_PIC_BASE
,
234 VIRT_GF_PIC_MMIO_BASE
, VIRT_GF_PIC_IRQ_BASE
);
235 BOOTINFO2(cs
->as
, parameters_base
, BI_VIRT_GF_RTC_BASE
,
236 VIRT_GF_RTC_MMIO_BASE
, VIRT_GF_RTC_IRQ_BASE
);
237 BOOTINFO2(cs
->as
, parameters_base
, BI_VIRT_GF_TTY_BASE
,
238 VIRT_GF_TTY_MMIO_BASE
, VIRT_GF_TTY_IRQ_BASE
);
239 BOOTINFO2(cs
->as
, parameters_base
, BI_VIRT_CTRL_BASE
,
240 VIRT_CTRL_MMIO_BASE
, VIRT_CTRL_IRQ_BASE
);
241 BOOTINFO2(cs
->as
, parameters_base
, BI_VIRT_VIRTIO_BASE
,
242 VIRT_VIRTIO_MMIO_BASE
, VIRT_VIRTIO_IRQ_BASE
);
244 if (kernel_cmdline
) {
245 BOOTINFOSTR(cs
->as
, parameters_base
, BI_COMMAND_LINE
,
250 if (initrd_filename
) {
251 initrd_size
= get_image_size(initrd_filename
);
252 if (initrd_size
< 0) {
253 error_report("could not load initial ram disk '%s'",
258 initrd_base
= (ram_size
- initrd_size
) & TARGET_PAGE_MASK
;
259 load_image_targphys(initrd_filename
, initrd_base
,
260 ram_size
- initrd_base
);
261 BOOTINFO2(cs
->as
, parameters_base
, BI_RAMDISK
, initrd_base
,
267 BOOTINFO0(cs
->as
, parameters_base
, BI_LAST
);
271 static void virt_machine_class_init(ObjectClass
*oc
, void *data
)
273 MachineClass
*mc
= MACHINE_CLASS(oc
);
274 mc
->desc
= "QEMU M68K Virtual Machine";
275 mc
->init
= virt_init
;
276 mc
->default_cpu_type
= M68K_CPU_TYPE_NAME("m68040");
280 mc
->default_ram_id
= "m68k_virt.ram";
283 static const TypeInfo virt_machine_info
= {
284 .name
= MACHINE_TYPE_NAME("virt"),
285 .parent
= TYPE_MACHINE
,
287 .class_init
= virt_machine_class_init
,
290 static void virt_machine_register_types(void)
292 type_register_static(&virt_machine_info
);
295 type_init(virt_machine_register_types
)
297 #define DEFINE_VIRT_MACHINE(major, minor, latest) \
298 static void virt_##major##_##minor##_class_init(ObjectClass *oc, \
301 MachineClass *mc = MACHINE_CLASS(oc); \
302 virt_machine_##major##_##minor##_options(mc); \
303 mc->desc = "QEMU " # major "." # minor " M68K Virtual Machine"; \
305 mc->alias = "virt"; \
308 static const TypeInfo machvirt_##major##_##minor##_info = { \
309 .name = MACHINE_TYPE_NAME("virt-" # major "." # minor), \
310 .parent = MACHINE_TYPE_NAME("virt"), \
311 .class_init = virt_##major##_##minor##_class_init, \
313 static void machvirt_machine_##major##_##minor##_init(void) \
315 type_register_static(&machvirt_##major##_##minor##_info); \
317 type_init(machvirt_machine_##major##_##minor##_init);
319 static void virt_machine_7_0_options(MachineClass
*mc
)
322 DEFINE_VIRT_MACHINE(7, 0, true)
324 static void virt_machine_6_2_options(MachineClass
*mc
)
326 virt_machine_7_0_options(mc
);
327 compat_props_add(mc
->compat_props
, hw_compat_6_2
, hw_compat_6_2_len
);
329 DEFINE_VIRT_MACHINE(6, 2, false)
331 static void virt_machine_6_1_options(MachineClass
*mc
)
333 virt_machine_6_2_options(mc
);
334 compat_props_add(mc
->compat_props
, hw_compat_6_1
, hw_compat_6_1_len
);
336 DEFINE_VIRT_MACHINE(6, 1, false)
338 static void virt_machine_6_0_options(MachineClass
*mc
)
340 virt_machine_6_1_options(mc
);
341 compat_props_add(mc
->compat_props
, hw_compat_6_0
, hw_compat_6_0_len
);
343 DEFINE_VIRT_MACHINE(6, 0, false)