2 * ARM mach-virt emulation
4 * Copyright (c) 2013 Linaro Limited
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms and conditions of the GNU General Public License,
8 * version 2 or later, as published by the Free Software Foundation.
10 * This program is distributed in the hope it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
15 * You should have received a copy of the GNU General Public License along with
16 * this program. If not, see <http://www.gnu.org/licenses/>.
18 * Emulate a virtual board which works by passing Linux all the information
19 * it needs about what devices are present via the device tree.
20 * There are some restrictions about what we can do here:
21 * + we can only present devices whose Linux drivers will work based
22 * purely on the device tree with no platform data at all
23 * + we want to present a very stripped-down minimalist platform,
24 * both because this reduces the security attack surface from the guest
25 * and also because it reduces our exposure to being broken when
26 * the kernel updates its device tree bindings and requires further
27 * information in a device binding that we aren't providing.
28 * This is essentially the same approach kvmtool uses.
31 #include "hw/sysbus.h"
32 #include "hw/arm/arm.h"
33 #include "hw/arm/primecell.h"
34 #include "hw/devices.h"
36 #include "sysemu/device_tree.h"
37 #include "sysemu/sysemu.h"
38 #include "sysemu/kvm.h"
39 #include "hw/boards.h"
40 #include "exec/address-spaces.h"
41 #include "qemu/bitops.h"
42 #include "qemu/error-report.h"
44 #define NUM_VIRTIO_TRANSPORTS 32
46 /* Number of external interrupt lines to configure the GIC with */
49 #define GIC_FDT_IRQ_TYPE_SPI 0
50 #define GIC_FDT_IRQ_TYPE_PPI 1
52 #define GIC_FDT_IRQ_FLAGS_EDGE_LO_HI 1
53 #define GIC_FDT_IRQ_FLAGS_EDGE_HI_LO 2
54 #define GIC_FDT_IRQ_FLAGS_LEVEL_HI 4
55 #define GIC_FDT_IRQ_FLAGS_LEVEL_LO 8
57 #define GIC_FDT_IRQ_PPI_CPU_START 8
58 #define GIC_FDT_IRQ_PPI_CPU_WIDTH 8
70 typedef struct MemMapEntry
{
75 typedef struct VirtBoardInfo
{
76 struct arm_boot_info bootinfo
;
77 const char *cpu_model
;
78 const MemMapEntry
*memmap
;
83 uint32_t clock_phandle
;
86 /* Addresses and sizes of our components.
87 * 0..128MB is space for a flash device so we can run bootrom code such as UEFI.
88 * 128MB..256MB is used for miscellaneous device I/O.
89 * 256MB..1GB is reserved for possible future PCI support (ie where the
90 * PCI memory window will go if we add a PCI host controller).
91 * 1GB and up is RAM (which may happily spill over into the
92 * high memory region beyond 4GB).
93 * This represents a compromise between how much RAM can be given to
94 * a 32 bit VM and leaving space for expansion and in particular for PCI.
96 static const MemMapEntry a15memmap
[] = {
97 /* Space up to 0x8000000 is reserved for a boot ROM */
98 [VIRT_FLASH
] = { 0, 0x8000000 },
99 [VIRT_CPUPERIPHS
] = { 0x8000000, 0x20000 },
100 /* GIC distributor and CPU interfaces sit inside the CPU peripheral space */
101 [VIRT_GIC_DIST
] = { 0x8000000, 0x10000 },
102 [VIRT_GIC_CPU
] = { 0x8010000, 0x10000 },
103 [VIRT_UART
] = { 0x9000000, 0x1000 },
104 [VIRT_MMIO
] = { 0xa000000, 0x200 },
105 /* ...repeating for a total of NUM_VIRTIO_TRANSPORTS, each of that size */
106 /* 0x10000000 .. 0x40000000 reserved for PCI */
107 [VIRT_MEM
] = { 0x40000000, 30ULL * 1024 * 1024 * 1024 },
110 static const int a15irqmap
[] = {
112 [VIRT_MMIO
] = 16, /* ...to 16 + NUM_VIRTIO_TRANSPORTS - 1 */
115 static VirtBoardInfo machines
[] = {
117 .cpu_model
= "cortex-a15",
122 .cpu_model
= "cortex-a57",
133 static VirtBoardInfo
*find_machine_info(const char *cpu
)
137 for (i
= 0; i
< ARRAY_SIZE(machines
); i
++) {
138 if (strcmp(cpu
, machines
[i
].cpu_model
) == 0) {
145 static void create_fdt(VirtBoardInfo
*vbi
)
147 void *fdt
= create_device_tree(&vbi
->fdt_size
);
150 error_report("create_device_tree() failed");
157 qemu_fdt_setprop_string(fdt
, "/", "compatible", "linux,dummy-virt");
158 qemu_fdt_setprop_cell(fdt
, "/", "#address-cells", 0x2);
159 qemu_fdt_setprop_cell(fdt
, "/", "#size-cells", 0x2);
162 * /chosen and /memory nodes must exist for load_dtb
163 * to fill in necessary properties later
165 qemu_fdt_add_subnode(fdt
, "/chosen");
166 qemu_fdt_add_subnode(fdt
, "/memory");
167 qemu_fdt_setprop_string(fdt
, "/memory", "device_type", "memory");
169 /* Clock node, for the benefit of the UART. The kernel device tree
170 * binding documentation claims the PL011 node clock properties are
171 * optional but in practice if you omit them the kernel refuses to
172 * probe for the device.
174 vbi
->clock_phandle
= qemu_fdt_alloc_phandle(fdt
);
175 qemu_fdt_add_subnode(fdt
, "/apb-pclk");
176 qemu_fdt_setprop_string(fdt
, "/apb-pclk", "compatible", "fixed-clock");
177 qemu_fdt_setprop_cell(fdt
, "/apb-pclk", "#clock-cells", 0x0);
178 qemu_fdt_setprop_cell(fdt
, "/apb-pclk", "clock-frequency", 24000000);
179 qemu_fdt_setprop_string(fdt
, "/apb-pclk", "clock-output-names",
181 qemu_fdt_setprop_cell(fdt
, "/apb-pclk", "phandle", vbi
->clock_phandle
);
183 /* No PSCI for TCG yet */
185 qemu_fdt_add_subnode(fdt
, "/psci");
186 qemu_fdt_setprop_string(fdt
, "/psci", "compatible", "arm,psci");
187 qemu_fdt_setprop_string(fdt
, "/psci", "method", "hvc");
188 qemu_fdt_setprop_cell(fdt
, "/psci", "cpu_suspend",
189 PSCI_FN_CPU_SUSPEND
);
190 qemu_fdt_setprop_cell(fdt
, "/psci", "cpu_off", PSCI_FN_CPU_OFF
);
191 qemu_fdt_setprop_cell(fdt
, "/psci", "cpu_on", PSCI_FN_CPU_ON
);
192 qemu_fdt_setprop_cell(fdt
, "/psci", "migrate", PSCI_FN_MIGRATE
);
196 static void fdt_add_timer_nodes(const VirtBoardInfo
*vbi
)
198 /* Note that on A15 h/w these interrupts are level-triggered,
199 * but for the GIC implementation provided by both QEMU and KVM
200 * they are edge-triggered.
202 uint32_t irqflags
= GIC_FDT_IRQ_FLAGS_EDGE_LO_HI
;
204 irqflags
= deposit32(irqflags
, GIC_FDT_IRQ_PPI_CPU_START
,
205 GIC_FDT_IRQ_PPI_CPU_WIDTH
, (1 << vbi
->smp_cpus
) - 1);
207 qemu_fdt_add_subnode(vbi
->fdt
, "/timer");
208 qemu_fdt_setprop_string(vbi
->fdt
, "/timer",
209 "compatible", "arm,armv7-timer");
210 qemu_fdt_setprop_cells(vbi
->fdt
, "/timer", "interrupts",
211 GIC_FDT_IRQ_TYPE_PPI
, 13, irqflags
,
212 GIC_FDT_IRQ_TYPE_PPI
, 14, irqflags
,
213 GIC_FDT_IRQ_TYPE_PPI
, 11, irqflags
,
214 GIC_FDT_IRQ_TYPE_PPI
, 10, irqflags
);
217 static void fdt_add_cpu_nodes(const VirtBoardInfo
*vbi
)
221 qemu_fdt_add_subnode(vbi
->fdt
, "/cpus");
222 qemu_fdt_setprop_cell(vbi
->fdt
, "/cpus", "#address-cells", 0x1);
223 qemu_fdt_setprop_cell(vbi
->fdt
, "/cpus", "#size-cells", 0x0);
225 for (cpu
= vbi
->smp_cpus
- 1; cpu
>= 0; cpu
--) {
226 char *nodename
= g_strdup_printf("/cpus/cpu@%d", cpu
);
227 ARMCPU
*armcpu
= ARM_CPU(qemu_get_cpu(cpu
));
229 qemu_fdt_add_subnode(vbi
->fdt
, nodename
);
230 qemu_fdt_setprop_string(vbi
->fdt
, nodename
, "device_type", "cpu");
231 qemu_fdt_setprop_string(vbi
->fdt
, nodename
, "compatible",
232 armcpu
->dtb_compatible
);
234 if (vbi
->smp_cpus
> 1) {
235 qemu_fdt_setprop_string(vbi
->fdt
, nodename
,
236 "enable-method", "psci");
239 qemu_fdt_setprop_cell(vbi
->fdt
, nodename
, "reg", cpu
);
244 static void fdt_add_gic_node(const VirtBoardInfo
*vbi
)
246 uint32_t gic_phandle
;
248 gic_phandle
= qemu_fdt_alloc_phandle(vbi
->fdt
);
249 qemu_fdt_setprop_cell(vbi
->fdt
, "/", "interrupt-parent", gic_phandle
);
251 qemu_fdt_add_subnode(vbi
->fdt
, "/intc");
252 /* 'cortex-a15-gic' means 'GIC v2' */
253 qemu_fdt_setprop_string(vbi
->fdt
, "/intc", "compatible",
254 "arm,cortex-a15-gic");
255 qemu_fdt_setprop_cell(vbi
->fdt
, "/intc", "#interrupt-cells", 3);
256 qemu_fdt_setprop(vbi
->fdt
, "/intc", "interrupt-controller", NULL
, 0);
257 qemu_fdt_setprop_sized_cells(vbi
->fdt
, "/intc", "reg",
258 2, vbi
->memmap
[VIRT_GIC_DIST
].base
,
259 2, vbi
->memmap
[VIRT_GIC_DIST
].size
,
260 2, vbi
->memmap
[VIRT_GIC_CPU
].base
,
261 2, vbi
->memmap
[VIRT_GIC_CPU
].size
);
262 qemu_fdt_setprop_cell(vbi
->fdt
, "/intc", "phandle", gic_phandle
);
265 static void create_gic(const VirtBoardInfo
*vbi
, qemu_irq
*pic
)
267 /* We create a standalone GIC v2 */
269 SysBusDevice
*gicbusdev
;
270 const char *gictype
= "arm_gic";
273 if (kvm_irqchip_in_kernel()) {
274 gictype
= "kvm-arm-gic";
277 gicdev
= qdev_create(NULL
, gictype
);
278 qdev_prop_set_uint32(gicdev
, "revision", 2);
279 qdev_prop_set_uint32(gicdev
, "num-cpu", smp_cpus
);
280 /* Note that the num-irq property counts both internal and external
281 * interrupts; there are always 32 of the former (mandated by GIC spec).
283 qdev_prop_set_uint32(gicdev
, "num-irq", NUM_IRQS
+ 32);
284 qdev_init_nofail(gicdev
);
285 gicbusdev
= SYS_BUS_DEVICE(gicdev
);
286 sysbus_mmio_map(gicbusdev
, 0, vbi
->memmap
[VIRT_GIC_DIST
].base
);
287 sysbus_mmio_map(gicbusdev
, 1, vbi
->memmap
[VIRT_GIC_CPU
].base
);
289 /* Wire the outputs from each CPU's generic timer to the
290 * appropriate GIC PPI inputs, and the GIC's IRQ output to
291 * the CPU's IRQ input.
293 for (i
= 0; i
< smp_cpus
; i
++) {
294 DeviceState
*cpudev
= DEVICE(qemu_get_cpu(i
));
295 int ppibase
= NUM_IRQS
+ i
* 32;
296 /* physical timer; we wire it up to the non-secure timer's ID,
297 * since a real A15 always has TrustZone but QEMU doesn't.
299 qdev_connect_gpio_out(cpudev
, 0,
300 qdev_get_gpio_in(gicdev
, ppibase
+ 30));
302 qdev_connect_gpio_out(cpudev
, 1,
303 qdev_get_gpio_in(gicdev
, ppibase
+ 27));
305 sysbus_connect_irq(gicbusdev
, i
, qdev_get_gpio_in(cpudev
, ARM_CPU_IRQ
));
308 for (i
= 0; i
< NUM_IRQS
; i
++) {
309 pic
[i
] = qdev_get_gpio_in(gicdev
, i
);
312 fdt_add_gic_node(vbi
);
315 static void create_uart(const VirtBoardInfo
*vbi
, qemu_irq
*pic
)
318 hwaddr base
= vbi
->memmap
[VIRT_UART
].base
;
319 hwaddr size
= vbi
->memmap
[VIRT_UART
].size
;
320 int irq
= vbi
->irqmap
[VIRT_UART
];
321 const char compat
[] = "arm,pl011\0arm,primecell";
322 const char clocknames
[] = "uartclk\0apb_pclk";
324 sysbus_create_simple("pl011", base
, pic
[irq
]);
326 nodename
= g_strdup_printf("/pl011@%" PRIx64
, base
);
327 qemu_fdt_add_subnode(vbi
->fdt
, nodename
);
328 /* Note that we can't use setprop_string because of the embedded NUL */
329 qemu_fdt_setprop(vbi
->fdt
, nodename
, "compatible",
330 compat
, sizeof(compat
));
331 qemu_fdt_setprop_sized_cells(vbi
->fdt
, nodename
, "reg",
333 qemu_fdt_setprop_cells(vbi
->fdt
, nodename
, "interrupts",
334 GIC_FDT_IRQ_TYPE_SPI
, irq
,
335 GIC_FDT_IRQ_FLAGS_EDGE_LO_HI
);
336 qemu_fdt_setprop_cells(vbi
->fdt
, nodename
, "clocks",
337 vbi
->clock_phandle
, vbi
->clock_phandle
);
338 qemu_fdt_setprop(vbi
->fdt
, nodename
, "clock-names",
339 clocknames
, sizeof(clocknames
));
343 static void create_virtio_devices(const VirtBoardInfo
*vbi
, qemu_irq
*pic
)
346 hwaddr size
= vbi
->memmap
[VIRT_MMIO
].size
;
348 /* Note that we have to create the transports in forwards order
349 * so that command line devices are inserted lowest address first,
350 * and then add dtb nodes in reverse order so that they appear in
351 * the finished device tree lowest address first.
353 for (i
= 0; i
< NUM_VIRTIO_TRANSPORTS
; i
++) {
354 int irq
= vbi
->irqmap
[VIRT_MMIO
] + i
;
355 hwaddr base
= vbi
->memmap
[VIRT_MMIO
].base
+ i
* size
;
357 sysbus_create_simple("virtio-mmio", base
, pic
[irq
]);
360 for (i
= NUM_VIRTIO_TRANSPORTS
- 1; i
>= 0; i
--) {
362 int irq
= vbi
->irqmap
[VIRT_MMIO
] + i
;
363 hwaddr base
= vbi
->memmap
[VIRT_MMIO
].base
+ i
* size
;
365 nodename
= g_strdup_printf("/virtio_mmio@%" PRIx64
, base
);
366 qemu_fdt_add_subnode(vbi
->fdt
, nodename
);
367 qemu_fdt_setprop_string(vbi
->fdt
, nodename
,
368 "compatible", "virtio,mmio");
369 qemu_fdt_setprop_sized_cells(vbi
->fdt
, nodename
, "reg",
371 qemu_fdt_setprop_cells(vbi
->fdt
, nodename
, "interrupts",
372 GIC_FDT_IRQ_TYPE_SPI
, irq
,
373 GIC_FDT_IRQ_FLAGS_EDGE_LO_HI
);
378 static void *machvirt_dtb(const struct arm_boot_info
*binfo
, int *fdt_size
)
380 const VirtBoardInfo
*board
= (const VirtBoardInfo
*)binfo
;
382 *fdt_size
= board
->fdt_size
;
386 static void machvirt_init(MachineState
*machine
)
388 qemu_irq pic
[NUM_IRQS
];
389 MemoryRegion
*sysmem
= get_system_memory();
391 MemoryRegion
*ram
= g_new(MemoryRegion
, 1);
392 const char *cpu_model
= machine
->cpu_model
;
396 cpu_model
= "cortex-a15";
399 vbi
= find_machine_info(cpu_model
);
402 error_report("mach-virt: CPU %s not supported", cpu_model
);
406 vbi
->smp_cpus
= smp_cpus
;
409 * Only supported method of starting secondary CPUs is PSCI and
410 * PSCI is not yet supported with TCG, so limit smp_cpus to 1
411 * if we're not using KVM.
413 if (!kvm_enabled() && smp_cpus
> 1) {
414 error_report("mach-virt: must enable KVM to use multiple CPUs");
418 if (machine
->ram_size
> vbi
->memmap
[VIRT_MEM
].size
) {
419 error_report("mach-virt: cannot model more than 30GB RAM");
424 fdt_add_timer_nodes(vbi
);
426 for (n
= 0; n
< smp_cpus
; n
++) {
427 ObjectClass
*oc
= cpu_class_by_name(TYPE_ARM_CPU
, cpu_model
);
431 fprintf(stderr
, "Unable to find CPU definition\n");
434 cpuobj
= object_new(object_class_get_name(oc
));
436 /* Secondary CPUs start in PSCI powered-down state */
438 object_property_set_bool(cpuobj
, true, "start-powered-off", NULL
);
441 if (object_property_find(cpuobj
, "reset-cbar", NULL
)) {
442 object_property_set_int(cpuobj
, vbi
->memmap
[VIRT_CPUPERIPHS
].base
,
443 "reset-cbar", &error_abort
);
446 object_property_set_bool(cpuobj
, true, "realized", NULL
);
448 fdt_add_cpu_nodes(vbi
);
450 memory_region_init_ram(ram
, NULL
, "mach-virt.ram", machine
->ram_size
);
451 vmstate_register_ram_global(ram
);
452 memory_region_add_subregion(sysmem
, vbi
->memmap
[VIRT_MEM
].base
, ram
);
454 create_gic(vbi
, pic
);
456 create_uart(vbi
, pic
);
458 /* Create mmio transports, so the user can create virtio backends
459 * (which will be automatically plugged in to the transports). If
460 * no backend is created the transport will just sit harmlessly idle.
462 create_virtio_devices(vbi
, pic
);
464 vbi
->bootinfo
.ram_size
= machine
->ram_size
;
465 vbi
->bootinfo
.kernel_filename
= machine
->kernel_filename
;
466 vbi
->bootinfo
.kernel_cmdline
= machine
->kernel_cmdline
;
467 vbi
->bootinfo
.initrd_filename
= machine
->initrd_filename
;
468 vbi
->bootinfo
.nb_cpus
= smp_cpus
;
469 vbi
->bootinfo
.board_id
= -1;
470 vbi
->bootinfo
.loader_start
= vbi
->memmap
[VIRT_MEM
].base
;
471 vbi
->bootinfo
.get_dtb
= machvirt_dtb
;
472 arm_load_kernel(ARM_CPU(first_cpu
), &vbi
->bootinfo
);
475 static QEMUMachine machvirt_a15_machine
= {
477 .desc
= "ARM Virtual Machine",
478 .init
= machvirt_init
,
482 static void machvirt_machine_init(void)
484 qemu_register_machine(&machvirt_a15_machine
);
487 machine_init(machvirt_machine_init
);