Lines Matching +full:build +full:- +full:tcg +full:- +full:disabled
2 * ARM mach-virt emulation
23 * + we want to present a very stripped-down minimalist platform,
41 #include "hw/vfio/vfio-calxeda-xgmac.h"
42 #include "hw/vfio/vfio-amd-xgbe.h"
49 #include "system/tcg.h"
57 #include "qemu/error-report.h"
59 #include "hw/pci-host/gpex.h"
60 #include "hw/pci-bridge/pci_expander_bridge.h"
61 #include "hw/virtio/virtio-pci.h"
62 #include "hw/core/sysbus-fdt.h"
63 #include "hw/platform-bus.h"
64 #include "hw/qdev-properties.h"
74 #include "qapi/qapi-visit-common.h"
76 #include "standard-headers/linux/input.h"
80 #include "target/arm/cpu-qom.h"
84 #include "hw/mem/pc-dimm.h"
87 #include "hw/uefi/var-service-api.h"
88 #include "hw/virtio/virtio-md-pci.h"
89 #include "hw/virtio/virtio-iommu.h"
93 #include "qemu/guest-random.h"
96 { TYPE_VIRTIO_IOMMU_PCI, "aw-bits", "48" },
102 * TYPE_VIRT_MACHINE is abstract and mc->compat_props g_ptr_array_new()
107 compat_props_add(mc->compat_props, arm_virt_compat, in arm_virt_compat_set()
119 mc->desc = "QEMU " MACHINE_VER_STR(__VA_ARGS__) " ARM Virtual Machine"; \
122 mc->alias = "virt"; \
202 /* Update the docs for highmem-mmio-size when changing this default */
217 * layout, depending on 'compact-highmem' property. With legacy layout, the
219 * has been disabled or doesn't fit into the PA space. However, the PA space
222 * Note that the highmem-mmio-size property will update the high PCIE MMIO size
242 [VIRT_MMIO] = 16, /* ...to 16 + NUM_VIRTIO_TRANSPORTS - 1 */
243 [VIRT_GIC_V2M] = 48, /* ...to 48 + NUM_GICV2M_SPIS - 1 */
244 [VIRT_SMMU] = 74, /* ...to 74 + NUM_SMMU_IRQS - 1 */
245 [VIRT_PLATFORM_BUS] = 112, /* ...to 112 + PLATFORM_BUS_NUM_IRQS -1 */
258 qemu_fdt_setprop_u64(ms->fdt, node, "kaslr-seed", seed.kaslr); in create_randomness()
259 qemu_fdt_setprop(ms->fdt, node, "rng-seed", seed.rng, sizeof(seed.rng)); in create_randomness()
270 CPUARMState *env = &cpu->env; in ns_el2_virt_timer_present()
279 int nb_numa_nodes = ms->numa_state->num_nodes; in create_fdt()
280 void *fdt = create_device_tree(&vms->fdt_size); in create_fdt()
287 ms->fdt = fdt; in create_fdt()
290 qemu_fdt_setprop_string(fdt, "/", "compatible", "linux,dummy-virt"); in create_fdt()
291 qemu_fdt_setprop_cell(fdt, "/", "#address-cells", 0x2); in create_fdt()
292 qemu_fdt_setprop_cell(fdt, "/", "#size-cells", 0x2); in create_fdt()
293 qemu_fdt_setprop_string(fdt, "/", "model", "linux,dummy-virt"); in create_fdt()
299 * - It avoids potential bugs where we forget to mark a DMA in create_fdt()
300 * capable device as being dma-coherent in create_fdt()
301 * - It avoids spurious warnings from the Linux kernel about in create_fdt()
304 qemu_fdt_setprop(fdt, "/", "dma-coherent", NULL, 0); in create_fdt()
308 if (vms->dtb_randomness) { in create_fdt()
312 if (vms->secure) { in create_fdt()
313 qemu_fdt_add_subnode(fdt, "/secure-chosen"); in create_fdt()
314 if (vms->dtb_randomness) { in create_fdt()
315 create_randomness(ms, "/secure-chosen"); in create_fdt()
326 vms->clock_phandle = qemu_fdt_alloc_phandle(fdt); in create_fdt()
327 qemu_fdt_add_subnode(fdt, "/apb-pclk"); in create_fdt()
328 qemu_fdt_setprop_string(fdt, "/apb-pclk", "compatible", "fixed-clock"); in create_fdt()
329 qemu_fdt_setprop_cell(fdt, "/apb-pclk", "#clock-cells", 0x0); in create_fdt()
330 qemu_fdt_setprop_cell(fdt, "/apb-pclk", "clock-frequency", 24000000); in create_fdt()
331 qemu_fdt_setprop_string(fdt, "/apb-pclk", "clock-output-names", in create_fdt()
333 qemu_fdt_setprop_cell(fdt, "/apb-pclk", "phandle", vms->clock_phandle); in create_fdt()
335 if (nb_numa_nodes > 0 && ms->numa_state->have_numa_distance) { in create_fdt()
346 cpu_to_be32(ms->numa_state->nodes[i].distance[j]); in create_fdt()
350 qemu_fdt_add_subnode(fdt, "/distance-map"); in create_fdt()
351 qemu_fdt_setprop_string(fdt, "/distance-map", "compatible", in create_fdt()
352 "numa-distance-map-v1"); in create_fdt()
353 qemu_fdt_setprop(fdt, "/distance-map", "distance-matrix", in create_fdt()
361 /* On real hardware these interrupts are level-triggered. in fdt_add_timer_nodes()
362 * On KVM they were edge-triggered before host kernel version 4.4, in fdt_add_timer_nodes()
363 * and level-triggered afterwards. in fdt_add_timer_nodes()
364 * On emulated QEMU they are level-triggered. in fdt_add_timer_nodes()
368 * pre-4.8 ignore the DT and leave the interrupt configured in fdt_add_timer_nodes()
375 * For backwards-compatibility, virt-2.8 and earlier will continue in fdt_add_timer_nodes()
376 * to say these are edge-triggered, but later machines will report in fdt_add_timer_nodes()
383 if (vms->gic_version == VIRT_GIC_VERSION_2) { in fdt_add_timer_nodes()
386 (1 << MACHINE(vms)->smp.cpus) - 1); in fdt_add_timer_nodes()
389 qemu_fdt_add_subnode(ms->fdt, "/timer"); in fdt_add_timer_nodes()
392 if (arm_feature(&armcpu->env, ARM_FEATURE_V8)) { in fdt_add_timer_nodes()
393 const char compat[] = "arm,armv8-timer\0arm,armv7-timer"; in fdt_add_timer_nodes()
394 qemu_fdt_setprop(ms->fdt, "/timer", "compatible", in fdt_add_timer_nodes()
397 qemu_fdt_setprop_string(ms->fdt, "/timer", "compatible", in fdt_add_timer_nodes()
398 "arm,armv7-timer"); in fdt_add_timer_nodes()
400 qemu_fdt_setprop(ms->fdt, "/timer", "always-on", NULL, 0); in fdt_add_timer_nodes()
401 if (vms->ns_el2_virt_timer_irq) { in fdt_add_timer_nodes()
402 qemu_fdt_setprop_cells(ms->fdt, "/timer", "interrupts", in fdt_add_timer_nodes()
414 qemu_fdt_setprop_cells(ms->fdt, "/timer", "interrupts", in fdt_add_timer_nodes()
432 int smp_cpus = ms->smp.cpus; in fdt_add_cpu_nodes()
436 * On ARM v8 64-bit systems value should be set to 2, in fdt_add_cpu_nodes()
439 * in the system, #address-cells can be set to 1, since in fdt_add_cpu_nodes()
443 * Here we actually don't know whether our system is 32- or 64-bit one. in fdt_add_cpu_nodes()
445 * at least one of them has Aff3 populated, we set #address-cells to 2. in fdt_add_cpu_nodes()
456 qemu_fdt_add_subnode(ms->fdt, "/cpus"); in fdt_add_cpu_nodes()
457 qemu_fdt_setprop_cell(ms->fdt, "/cpus", "#address-cells", addr_cells); in fdt_add_cpu_nodes()
458 qemu_fdt_setprop_cell(ms->fdt, "/cpus", "#size-cells", 0x0); in fdt_add_cpu_nodes()
460 for (cpu = smp_cpus - 1; cpu >= 0; cpu--) { in fdt_add_cpu_nodes()
465 qemu_fdt_add_subnode(ms->fdt, nodename); in fdt_add_cpu_nodes()
466 qemu_fdt_setprop_string(ms->fdt, nodename, "device_type", "cpu"); in fdt_add_cpu_nodes()
467 qemu_fdt_setprop_string(ms->fdt, nodename, "compatible", in fdt_add_cpu_nodes()
468 armcpu->dtb_compatible); in fdt_add_cpu_nodes()
470 if (vms->psci_conduit != QEMU_PSCI_CONDUIT_DISABLED && smp_cpus > 1) { in fdt_add_cpu_nodes()
471 qemu_fdt_setprop_string(ms->fdt, nodename, in fdt_add_cpu_nodes()
472 "enable-method", "psci"); in fdt_add_cpu_nodes()
476 qemu_fdt_setprop_u64(ms->fdt, nodename, "reg", in fdt_add_cpu_nodes()
479 qemu_fdt_setprop_cell(ms->fdt, nodename, "reg", in fdt_add_cpu_nodes()
483 if (ms->possible_cpus->cpus[cs->cpu_index].props.has_node_id) { in fdt_add_cpu_nodes()
484 qemu_fdt_setprop_cell(ms->fdt, nodename, "numa-node-id", in fdt_add_cpu_nodes()
485 ms->possible_cpus->cpus[cs->cpu_index].props.node_id); in fdt_add_cpu_nodes()
488 if (!vmc->no_cpu_topology) { in fdt_add_cpu_nodes()
489 qemu_fdt_setprop_cell(ms->fdt, nodename, "phandle", in fdt_add_cpu_nodes()
490 qemu_fdt_alloc_phandle(ms->fdt)); in fdt_add_cpu_nodes()
496 if (!vmc->no_cpu_topology) { in fdt_add_cpu_nodes()
498 * Add vCPU topology description through fdt node cpu-map. in fdt_add_cpu_nodes()
500 * See Linux Documentation/devicetree/bindings/cpu/cpu-topology.txt in fdt_add_cpu_nodes()
513 qemu_fdt_add_subnode(ms->fdt, "/cpus/cpu-map"); in fdt_add_cpu_nodes()
515 for (cpu = smp_cpus - 1; cpu >= 0; cpu--) { in fdt_add_cpu_nodes()
519 if (ms->smp.threads > 1) { in fdt_add_cpu_nodes()
521 "/cpus/cpu-map/socket%d/cluster%d/core%d/thread%d", in fdt_add_cpu_nodes()
522 cpu / (ms->smp.clusters * ms->smp.cores * ms->smp.threads), in fdt_add_cpu_nodes()
523 (cpu / (ms->smp.cores * ms->smp.threads)) % ms->smp.clusters, in fdt_add_cpu_nodes()
524 (cpu / ms->smp.threads) % ms->smp.cores, in fdt_add_cpu_nodes()
525 cpu % ms->smp.threads); in fdt_add_cpu_nodes()
528 "/cpus/cpu-map/socket%d/cluster%d/core%d", in fdt_add_cpu_nodes()
529 cpu / (ms->smp.clusters * ms->smp.cores), in fdt_add_cpu_nodes()
530 (cpu / ms->smp.cores) % ms->smp.clusters, in fdt_add_cpu_nodes()
531 cpu % ms->smp.cores); in fdt_add_cpu_nodes()
533 qemu_fdt_add_path(ms->fdt, map_path); in fdt_add_cpu_nodes()
534 qemu_fdt_setprop_phandle(ms->fdt, map_path, "cpu", cpu_path); in fdt_add_cpu_nodes()
547 vms->msi_phandle = qemu_fdt_alloc_phandle(ms->fdt); in fdt_add_its_gic_node()
549 vms->memmap[VIRT_GIC_ITS].base); in fdt_add_its_gic_node()
550 qemu_fdt_add_subnode(ms->fdt, nodename); in fdt_add_its_gic_node()
551 qemu_fdt_setprop_string(ms->fdt, nodename, "compatible", in fdt_add_its_gic_node()
552 "arm,gic-v3-its"); in fdt_add_its_gic_node()
553 qemu_fdt_setprop(ms->fdt, nodename, "msi-controller", NULL, 0); in fdt_add_its_gic_node()
554 qemu_fdt_setprop_cell(ms->fdt, nodename, "#msi-cells", 1); in fdt_add_its_gic_node()
555 qemu_fdt_setprop_sized_cells(ms->fdt, nodename, "reg", in fdt_add_its_gic_node()
556 2, vms->memmap[VIRT_GIC_ITS].base, in fdt_add_its_gic_node()
557 2, vms->memmap[VIRT_GIC_ITS].size); in fdt_add_its_gic_node()
558 qemu_fdt_setprop_cell(ms->fdt, nodename, "phandle", vms->msi_phandle); in fdt_add_its_gic_node()
568 vms->memmap[VIRT_GIC_V2M].base); in fdt_add_v2m_gic_node()
569 vms->msi_phandle = qemu_fdt_alloc_phandle(ms->fdt); in fdt_add_v2m_gic_node()
570 qemu_fdt_add_subnode(ms->fdt, nodename); in fdt_add_v2m_gic_node()
571 qemu_fdt_setprop_string(ms->fdt, nodename, "compatible", in fdt_add_v2m_gic_node()
572 "arm,gic-v2m-frame"); in fdt_add_v2m_gic_node()
573 qemu_fdt_setprop(ms->fdt, nodename, "msi-controller", NULL, 0); in fdt_add_v2m_gic_node()
574 qemu_fdt_setprop_sized_cells(ms->fdt, nodename, "reg", in fdt_add_v2m_gic_node()
575 2, vms->memmap[VIRT_GIC_V2M].base, in fdt_add_v2m_gic_node()
576 2, vms->memmap[VIRT_GIC_V2M].size); in fdt_add_v2m_gic_node()
577 qemu_fdt_setprop_cell(ms->fdt, nodename, "phandle", vms->msi_phandle); in fdt_add_v2m_gic_node()
586 vms->gic_phandle = qemu_fdt_alloc_phandle(ms->fdt); in fdt_add_gic_node()
587 qemu_fdt_setprop_cell(ms->fdt, "/", "interrupt-parent", vms->gic_phandle); in fdt_add_gic_node()
590 vms->memmap[VIRT_GIC_DIST].base); in fdt_add_gic_node()
591 qemu_fdt_add_subnode(ms->fdt, nodename); in fdt_add_gic_node()
592 qemu_fdt_setprop_cell(ms->fdt, nodename, "#interrupt-cells", 3); in fdt_add_gic_node()
593 qemu_fdt_setprop(ms->fdt, nodename, "interrupt-controller", NULL, 0); in fdt_add_gic_node()
594 qemu_fdt_setprop_cell(ms->fdt, nodename, "#address-cells", 0x2); in fdt_add_gic_node()
595 qemu_fdt_setprop_cell(ms->fdt, nodename, "#size-cells", 0x2); in fdt_add_gic_node()
596 qemu_fdt_setprop(ms->fdt, nodename, "ranges", NULL, 0); in fdt_add_gic_node()
597 if (vms->gic_version != VIRT_GIC_VERSION_2) { in fdt_add_gic_node()
600 qemu_fdt_setprop_string(ms->fdt, nodename, "compatible", in fdt_add_gic_node()
601 "arm,gic-v3"); in fdt_add_gic_node()
603 qemu_fdt_setprop_cell(ms->fdt, nodename, in fdt_add_gic_node()
604 "#redistributor-regions", nb_redist_regions); in fdt_add_gic_node()
607 qemu_fdt_setprop_sized_cells(ms->fdt, nodename, "reg", in fdt_add_gic_node()
608 2, vms->memmap[VIRT_GIC_DIST].base, in fdt_add_gic_node()
609 2, vms->memmap[VIRT_GIC_DIST].size, in fdt_add_gic_node()
610 2, vms->memmap[VIRT_GIC_REDIST].base, in fdt_add_gic_node()
611 2, vms->memmap[VIRT_GIC_REDIST].size); in fdt_add_gic_node()
613 qemu_fdt_setprop_sized_cells(ms->fdt, nodename, "reg", in fdt_add_gic_node()
614 2, vms->memmap[VIRT_GIC_DIST].base, in fdt_add_gic_node()
615 2, vms->memmap[VIRT_GIC_DIST].size, in fdt_add_gic_node()
616 2, vms->memmap[VIRT_GIC_REDIST].base, in fdt_add_gic_node()
617 2, vms->memmap[VIRT_GIC_REDIST].size, in fdt_add_gic_node()
618 2, vms->memmap[VIRT_HIGH_GIC_REDIST2].base, in fdt_add_gic_node()
619 2, vms->memmap[VIRT_HIGH_GIC_REDIST2].size); in fdt_add_gic_node()
622 if (vms->virt) { in fdt_add_gic_node()
623 qemu_fdt_setprop_cells(ms->fdt, nodename, "interrupts", in fdt_add_gic_node()
629 /* 'cortex-a15-gic' means 'GIC v2' */ in fdt_add_gic_node()
630 qemu_fdt_setprop_string(ms->fdt, nodename, "compatible", in fdt_add_gic_node()
631 "arm,cortex-a15-gic"); in fdt_add_gic_node()
632 if (!vms->virt) { in fdt_add_gic_node()
633 qemu_fdt_setprop_sized_cells(ms->fdt, nodename, "reg", in fdt_add_gic_node()
634 2, vms->memmap[VIRT_GIC_DIST].base, in fdt_add_gic_node()
635 2, vms->memmap[VIRT_GIC_DIST].size, in fdt_add_gic_node()
636 2, vms->memmap[VIRT_GIC_CPU].base, in fdt_add_gic_node()
637 2, vms->memmap[VIRT_GIC_CPU].size); in fdt_add_gic_node()
639 qemu_fdt_setprop_sized_cells(ms->fdt, nodename, "reg", in fdt_add_gic_node()
640 2, vms->memmap[VIRT_GIC_DIST].base, in fdt_add_gic_node()
641 2, vms->memmap[VIRT_GIC_DIST].size, in fdt_add_gic_node()
642 2, vms->memmap[VIRT_GIC_CPU].base, in fdt_add_gic_node()
643 2, vms->memmap[VIRT_GIC_CPU].size, in fdt_add_gic_node()
644 2, vms->memmap[VIRT_GIC_HYP].base, in fdt_add_gic_node()
645 2, vms->memmap[VIRT_GIC_HYP].size, in fdt_add_gic_node()
646 2, vms->memmap[VIRT_GIC_VCPU].base, in fdt_add_gic_node()
647 2, vms->memmap[VIRT_GIC_VCPU].size); in fdt_add_gic_node()
648 qemu_fdt_setprop_cells(ms->fdt, nodename, "interrupts", in fdt_add_gic_node()
655 qemu_fdt_setprop_cell(ms->fdt, nodename, "phandle", vms->gic_phandle); in fdt_add_gic_node()
665 if (!arm_feature(&armcpu->env, ARM_FEATURE_PMU)) { in fdt_add_pmu_nodes()
670 if (vms->gic_version == VIRT_GIC_VERSION_2) { in fdt_add_pmu_nodes()
673 (1 << MACHINE(vms)->smp.cpus) - 1); in fdt_add_pmu_nodes()
676 qemu_fdt_add_subnode(ms->fdt, "/pmu"); in fdt_add_pmu_nodes()
677 if (arm_feature(&armcpu->env, ARM_FEATURE_V8)) { in fdt_add_pmu_nodes()
678 const char compat[] = "arm,armv8-pmuv3"; in fdt_add_pmu_nodes()
679 qemu_fdt_setprop(ms->fdt, "/pmu", "compatible", in fdt_add_pmu_nodes()
681 qemu_fdt_setprop_cells(ms->fdt, "/pmu", "interrupts", in fdt_add_pmu_nodes()
692 int irq = vms->irqmap[VIRT_ACPI_GED]; in create_acpi_ged()
696 if (ms->ram_slots) { in create_acpi_ged()
700 if (ms->nvdimms_state->is_enabled) { in create_acpi_ged()
705 qdev_prop_set_uint32(dev, "ged-event", event); in create_acpi_ged()
706 object_property_set_link(OBJECT(dev), "bus", OBJECT(vms->bus), &error_abort); in create_acpi_ged()
710 sysbus_mmio_map_name(sbdev, TYPE_ACPI_GED, vms->memmap[VIRT_ACPI_GED].base); in create_acpi_ged()
712 vms->memmap[VIRT_PCDIMM_ACPI].base); in create_acpi_ged()
721 vms->memmap[VIRT_ACPI_PCIHP].base); in create_acpi_ged()
725 sysbus_connect_irq(sbdev, 0, qdev_get_gpio_in(vms->gic, irq)); in create_acpi_ged()
734 assert(vms->its); in create_its()
735 if (!kvm_irqchip_in_kernel() && !vms->tcg_its) { in create_its()
745 object_property_set_link(OBJECT(dev), "parent-gicv3", OBJECT(vms->gic), in create_its()
748 sysbus_mmio_map(SYS_BUS_DEVICE(dev), 0, vms->memmap[VIRT_GIC_ITS].base); in create_its()
751 vms->msi_controller = VIRT_MSI_CTRL_ITS; in create_its()
757 int irq = vms->irqmap[VIRT_GIC_V2M]; in create_v2m()
760 dev = qdev_new("arm-gicv2m"); in create_v2m()
761 qdev_prop_set_uint32(dev, "base-spi", irq); in create_v2m()
762 qdev_prop_set_uint32(dev, "num-spi", NUM_GICV2M_SPIS); in create_v2m()
764 sysbus_mmio_map(SYS_BUS_DEVICE(dev), 0, vms->memmap[VIRT_GIC_V2M].base); in create_v2m()
768 qdev_get_gpio_in(vms->gic, irq + i)); in create_v2m()
772 vms->msi_controller = VIRT_MSI_CTRL_GICV2M; in create_v2m()
786 (vms->gic_version != VIRT_GIC_VERSION_2); in gicv3_nmi_present()
796 unsigned int smp_cpus = ms->smp.cpus; in create_gic()
800 if (vms->gic_version == VIRT_GIC_VERSION_2) { in create_gic()
806 switch (vms->gic_version) { in create_gic()
820 if (kvm_enabled() && vms->virt && in create_gic()
822 error_report("KVM EL2 is only supported with in-kernel GICv3"); in create_gic()
826 vms->gic = qdev_new(gictype); in create_gic()
827 qdev_prop_set_uint32(vms->gic, "revision", revision); in create_gic()
828 qdev_prop_set_uint32(vms->gic, "num-cpu", smp_cpus); in create_gic()
829 /* Note that the num-irq property counts both internal and external in create_gic()
832 qdev_prop_set_uint32(vms->gic, "num-irq", NUM_IRQS + 32); in create_gic()
834 qdev_prop_set_bit(vms->gic, "has-security-extensions", vms->secure); in create_gic()
837 if (vms->gic_version != VIRT_GIC_VERSION_2) { in create_gic()
851 MIN(smp_cpus - redist0_count, redist1_capacity)); in create_gic()
853 qdev_prop_set_array(vms->gic, "redist-region-count", in create_gic()
857 if (vms->tcg_its) { in create_gic()
858 object_property_set_link(OBJECT(vms->gic), "sysmem", in create_gic()
860 qdev_prop_set_bit(vms->gic, "has-lpi", true); in create_gic()
862 } else if (vms->virt) { in create_gic()
863 qdev_prop_set_uint32(vms->gic, "maintenance-interrupt-id", in create_gic()
868 qdev_prop_set_bit(vms->gic, "has-virtualization-extensions", in create_gic()
869 vms->virt); in create_gic()
874 qdev_prop_set_bit(vms->gic, "has-nmi", true); in create_gic()
877 gicbusdev = SYS_BUS_DEVICE(vms->gic); in create_gic()
879 sysbus_mmio_map(gicbusdev, 0, vms->memmap[VIRT_GIC_DIST].base); in create_gic()
880 if (vms->gic_version != VIRT_GIC_VERSION_2) { in create_gic()
881 sysbus_mmio_map(gicbusdev, 1, vms->memmap[VIRT_GIC_REDIST].base); in create_gic()
884 vms->memmap[VIRT_HIGH_GIC_REDIST2].base); in create_gic()
887 sysbus_mmio_map(gicbusdev, 1, vms->memmap[VIRT_GIC_CPU].base); in create_gic()
888 if (vms->virt) { in create_gic()
889 sysbus_mmio_map(gicbusdev, 2, vms->memmap[VIRT_GIC_HYP].base); in create_gic()
890 sysbus_mmio_map(gicbusdev, 3, vms->memmap[VIRT_GIC_VCPU].base); in create_gic()
917 qdev_get_gpio_in(vms->gic, in create_gic()
921 if (vms->gic_version != VIRT_GIC_VERSION_2) { in create_gic()
922 qemu_irq irq = qdev_get_gpio_in(vms->gic, in create_gic()
924 qdev_connect_gpio_out_named(cpudev, "gicv3-maintenance-interrupt", in create_gic()
926 } else if (vms->virt) { in create_gic()
927 qemu_irq irq = qdev_get_gpio_in(vms->gic, in create_gic()
932 qdev_connect_gpio_out_named(cpudev, "pmu-interrupt", 0, in create_gic()
933 qdev_get_gpio_in(vms->gic, intidbase in create_gic()
944 if (vms->gic_version != VIRT_GIC_VERSION_2) { in create_gic()
954 if (vms->gic_version != VIRT_GIC_VERSION_2 && vms->its) { in create_gic()
956 } else if (vms->gic_version == VIRT_GIC_VERSION_2) { in create_gic()
965 hwaddr base = vms->memmap[uart].base; in create_uart()
966 hwaddr size = vms->memmap[uart].size; in create_uart()
967 int irq = vms->irqmap[uart]; in create_uart()
978 sysbus_connect_irq(s, 0, qdev_get_gpio_in(vms->gic, irq)); in create_uart()
981 qemu_fdt_add_subnode(ms->fdt, nodename); in create_uart()
983 qemu_fdt_setprop(ms->fdt, nodename, "compatible", in create_uart()
985 qemu_fdt_setprop_sized_cells(ms->fdt, nodename, "reg", in create_uart()
987 qemu_fdt_setprop_cells(ms->fdt, nodename, "interrupts", in create_uart()
990 qemu_fdt_setprop_cells(ms->fdt, nodename, "clocks", in create_uart()
991 vms->clock_phandle, vms->clock_phandle); in create_uart()
992 qemu_fdt_setprop(ms->fdt, nodename, "clock-names", in create_uart()
996 qemu_fdt_setprop_string(ms->fdt, "/chosen", "stdout-path", nodename); in create_uart()
997 qemu_fdt_setprop_string(ms->fdt, "/aliases", "serial0", nodename); in create_uart()
999 qemu_fdt_setprop_string(ms->fdt, "/aliases", "serial1", nodename); in create_uart()
1003 qemu_fdt_setprop_string(ms->fdt, nodename, "status", "disabled"); in create_uart()
1004 qemu_fdt_setprop_string(ms->fdt, nodename, "secure-status", "okay"); in create_uart()
1006 qemu_fdt_setprop_string(ms->fdt, "/secure-chosen", "stdout-path", in create_uart()
1016 hwaddr base = vms->memmap[VIRT_RTC].base; in create_rtc()
1017 hwaddr size = vms->memmap[VIRT_RTC].size; in create_rtc()
1018 int irq = vms->irqmap[VIRT_RTC]; in create_rtc()
1022 sysbus_create_simple("pl031", base, qdev_get_gpio_in(vms->gic, irq)); in create_rtc()
1025 qemu_fdt_add_subnode(ms->fdt, nodename); in create_rtc()
1026 qemu_fdt_setprop(ms->fdt, nodename, "compatible", compat, sizeof(compat)); in create_rtc()
1027 qemu_fdt_setprop_sized_cells(ms->fdt, nodename, "reg", in create_rtc()
1029 qemu_fdt_setprop_cells(ms->fdt, nodename, "interrupts", in create_rtc()
1032 qemu_fdt_setprop_cell(ms->fdt, nodename, "clocks", vms->clock_phandle); in create_rtc()
1033 qemu_fdt_setprop_string(ms->fdt, nodename, "clock-names", "apb_pclk"); in create_rtc()
1042 if (s->acpi_dev) { in virt_powerdown_req()
1043 acpi_send_event(s->acpi_dev, ACPI_POWER_DOWN_STATUS); in virt_powerdown_req()
1053 gpio_key_dev = sysbus_create_simple("gpio-key", -1, in create_gpio_keys()
1057 qemu_fdt_add_subnode(fdt, "/gpio-keys"); in create_gpio_keys()
1058 qemu_fdt_setprop_string(fdt, "/gpio-keys", "compatible", "gpio-keys"); in create_gpio_keys()
1060 qemu_fdt_add_subnode(fdt, "/gpio-keys/poweroff"); in create_gpio_keys()
1061 qemu_fdt_setprop_string(fdt, "/gpio-keys/poweroff", in create_gpio_keys()
1063 qemu_fdt_setprop_cell(fdt, "/gpio-keys/poweroff", "linux,code", in create_gpio_keys()
1065 qemu_fdt_setprop_cells(fdt, "/gpio-keys/poweroff", in create_gpio_keys()
1077 /* gpio-pwr */ in create_secure_gpio_pwr()
1078 gpio_pwr_dev = sysbus_create_simple("gpio-pwr", -1, NULL); in create_secure_gpio_pwr()
1080 /* connect secure pl061 to gpio-pwr */ in create_secure_gpio_pwr()
1086 qemu_fdt_add_subnode(fdt, "/gpio-poweroff"); in create_secure_gpio_pwr()
1087 qemu_fdt_setprop_string(fdt, "/gpio-poweroff", "compatible", in create_secure_gpio_pwr()
1088 "gpio-poweroff"); in create_secure_gpio_pwr()
1089 qemu_fdt_setprop_cells(fdt, "/gpio-poweroff", in create_secure_gpio_pwr()
1091 qemu_fdt_setprop_string(fdt, "/gpio-poweroff", "status", "disabled"); in create_secure_gpio_pwr()
1092 qemu_fdt_setprop_string(fdt, "/gpio-poweroff", "secure-status", in create_secure_gpio_pwr()
1095 qemu_fdt_add_subnode(fdt, "/gpio-restart"); in create_secure_gpio_pwr()
1096 qemu_fdt_setprop_string(fdt, "/gpio-restart", "compatible", in create_secure_gpio_pwr()
1097 "gpio-restart"); in create_secure_gpio_pwr()
1098 qemu_fdt_setprop_cells(fdt, "/gpio-restart", in create_secure_gpio_pwr()
1100 qemu_fdt_setprop_string(fdt, "/gpio-restart", "status", "disabled"); in create_secure_gpio_pwr()
1101 qemu_fdt_setprop_string(fdt, "/gpio-restart", "secure-status", in create_secure_gpio_pwr()
1110 hwaddr base = vms->memmap[gpio].base; in create_gpio_devices()
1111 hwaddr size = vms->memmap[gpio].size; in create_gpio_devices()
1112 int irq = vms->irqmap[gpio]; in create_gpio_devices()
1124 sysbus_connect_irq(s, 0, qdev_get_gpio_in(vms->gic, irq)); in create_gpio_devices()
1126 uint32_t phandle = qemu_fdt_alloc_phandle(ms->fdt); in create_gpio_devices()
1128 qemu_fdt_add_subnode(ms->fdt, nodename); in create_gpio_devices()
1129 qemu_fdt_setprop_sized_cells(ms->fdt, nodename, "reg", in create_gpio_devices()
1131 qemu_fdt_setprop(ms->fdt, nodename, "compatible", compat, sizeof(compat)); in create_gpio_devices()
1132 qemu_fdt_setprop_cell(ms->fdt, nodename, "#gpio-cells", 2); in create_gpio_devices()
1133 qemu_fdt_setprop(ms->fdt, nodename, "gpio-controller", NULL, 0); in create_gpio_devices()
1134 qemu_fdt_setprop_cells(ms->fdt, nodename, "interrupts", in create_gpio_devices()
1137 qemu_fdt_setprop_cell(ms->fdt, nodename, "clocks", vms->clock_phandle); in create_gpio_devices()
1138 qemu_fdt_setprop_string(ms->fdt, nodename, "clock-names", "apb_pclk"); in create_gpio_devices()
1139 qemu_fdt_setprop_cell(ms->fdt, nodename, "phandle", phandle); in create_gpio_devices()
1143 qemu_fdt_setprop_string(ms->fdt, nodename, "status", "disabled"); in create_gpio_devices()
1144 qemu_fdt_setprop_string(ms->fdt, nodename, "secure-status", "okay"); in create_gpio_devices()
1150 create_gpio_keys(ms->fdt, pl061_dev, phandle); in create_gpio_devices()
1152 create_secure_gpio_pwr(ms->fdt, pl061_dev, phandle); in create_gpio_devices()
1159 hwaddr size = vms->memmap[VIRT_MMIO].size; in create_virtio_devices()
1164 * create a list of virtio-mmio buses with decreasing base addresses. in create_virtio_devices()
1166 * When a -device option is processed from the command line, in create_virtio_devices()
1167 * qbus_find_recursive() picks the next free virtio-mmio bus in forwards in create_virtio_devices()
1168 * order. The upshot is that -device options in increasing command line in create_virtio_devices()
1169 * order are mapped to virtio-mmio buses with decreasing base addresses. in create_virtio_devices()
1173 * the first -device on the command line. (The end-to-end order is a in create_virtio_devices()
1175 * guest kernel's name-to-address assignment strategy.) in create_virtio_devices()
1190 int irq = vms->irqmap[VIRT_MMIO] + i; in create_virtio_devices()
1191 hwaddr base = vms->memmap[VIRT_MMIO].base + i * size; in create_virtio_devices()
1193 sysbus_create_simple("virtio-mmio", base, in create_virtio_devices()
1194 qdev_get_gpio_in(vms->gic, irq)); in create_virtio_devices()
1204 for (i = NUM_VIRTIO_TRANSPORTS - 1; i >= 0; i--) { in create_virtio_devices()
1206 int irq = vms->irqmap[VIRT_MMIO] + i; in create_virtio_devices()
1207 hwaddr base = vms->memmap[VIRT_MMIO].base + i * size; in create_virtio_devices()
1210 qemu_fdt_add_subnode(ms->fdt, nodename); in create_virtio_devices()
1211 qemu_fdt_setprop_string(ms->fdt, nodename, in create_virtio_devices()
1213 qemu_fdt_setprop_sized_cells(ms->fdt, nodename, "reg", in create_virtio_devices()
1215 qemu_fdt_setprop_cells(ms->fdt, nodename, "interrupts", in create_virtio_devices()
1218 qemu_fdt_setprop(ms->fdt, nodename, "dma-coherent", NULL, 0); in create_virtio_devices()
1235 qdev_prop_set_uint64(dev, "sector-length", VIRT_FLASH_SECTOR_SIZE); in virt_flash_create1()
1237 qdev_prop_set_uint8(dev, "device-width", 2); in virt_flash_create1()
1238 qdev_prop_set_bit(dev, "big-endian", false); in virt_flash_create1()
1252 vms->flash[0] = virt_flash_create1(vms, "virt.flash0", "pflash0"); in virt_flash_create()
1253 vms->flash[1] = virt_flash_create1(vms, "virt.flash1", "pflash1"); in virt_flash_create()
1264 qdev_prop_set_uint32(dev, "num-blocks", size / VIRT_FLASH_SECTOR_SIZE); in virt_flash_map1()
1284 hwaddr flashsize = vms->memmap[VIRT_FLASH].size / 2; in virt_flash_map()
1285 hwaddr flashbase = vms->memmap[VIRT_FLASH].base; in virt_flash_map()
1287 virt_flash_map1(vms->flash[0], flashbase, flashsize, in virt_flash_map()
1289 virt_flash_map1(vms->flash[1], flashbase + flashsize, flashsize, in virt_flash_map()
1297 hwaddr flashsize = vms->memmap[VIRT_FLASH].size / 2; in virt_flash_fdt()
1298 hwaddr flashbase = vms->memmap[VIRT_FLASH].base; in virt_flash_fdt()
1305 qemu_fdt_add_subnode(ms->fdt, nodename); in virt_flash_fdt()
1306 qemu_fdt_setprop_string(ms->fdt, nodename, "compatible", "cfi-flash"); in virt_flash_fdt()
1307 qemu_fdt_setprop_sized_cells(ms->fdt, nodename, "reg", in virt_flash_fdt()
1310 qemu_fdt_setprop_cell(ms->fdt, nodename, "bank-width", 4); in virt_flash_fdt()
1318 qemu_fdt_add_subnode(ms->fdt, nodename); in virt_flash_fdt()
1319 qemu_fdt_setprop_string(ms->fdt, nodename, "compatible", "cfi-flash"); in virt_flash_fdt()
1320 qemu_fdt_setprop_sized_cells(ms->fdt, nodename, "reg", in virt_flash_fdt()
1322 qemu_fdt_setprop_cell(ms->fdt, nodename, "bank-width", 4); in virt_flash_fdt()
1323 qemu_fdt_setprop_string(ms->fdt, nodename, "status", "disabled"); in virt_flash_fdt()
1324 qemu_fdt_setprop_string(ms->fdt, nodename, "secure-status", "okay"); in virt_flash_fdt()
1328 qemu_fdt_add_subnode(ms->fdt, nodename); in virt_flash_fdt()
1329 qemu_fdt_setprop_string(ms->fdt, nodename, "compatible", "cfi-flash"); in virt_flash_fdt()
1330 qemu_fdt_setprop_sized_cells(ms->fdt, nodename, "reg", in virt_flash_fdt()
1332 qemu_fdt_setprop_cell(ms->fdt, nodename, "bank-width", 4); in virt_flash_fdt()
1345 /* Map legacy -drive if=pflash to machine properties */ in virt_firmware_init()
1346 for (i = 0; i < ARRAY_SIZE(vms->flash); i++) { in virt_firmware_init()
1347 pflash_cfi01_legacy_drive(vms->flash[i], in virt_firmware_init()
1353 pflash_blk0 = pflash_cfi01_get_blk(vms->flash[0]); in virt_firmware_init()
1355 bios_name = MACHINE(vms)->firmware; in virt_firmware_init()
1363 "specified with -bios or with -drive if=pflash... " in virt_firmware_init()
1368 /* Fall back to -bios */ in virt_firmware_init()
1375 mr = sysbus_mmio_get_region(SYS_BUS_DEVICE(vms->flash[0]), 0); in virt_firmware_init()
1390 hwaddr base = vms->memmap[VIRT_FW_CFG].base; in create_fw_cfg()
1391 hwaddr size = vms->memmap[VIRT_FW_CFG].size; in create_fw_cfg()
1396 fw_cfg_add_i16(fw_cfg, FW_CFG_NB_CPUS, (uint16_t)ms->smp.cpus); in create_fw_cfg()
1398 nodename = g_strdup_printf("/fw-cfg@%" PRIx64, base); in create_fw_cfg()
1399 qemu_fdt_add_subnode(ms->fdt, nodename); in create_fw_cfg()
1400 qemu_fdt_setprop_string(ms->fdt, nodename, in create_fw_cfg()
1401 "compatible", "qemu,fw-cfg-mmio"); in create_fw_cfg()
1402 qemu_fdt_setprop_sized_cells(ms->fdt, nodename, "reg", in create_fw_cfg()
1404 qemu_fdt_setprop(ms->fdt, nodename, "dma-coherent", NULL, 0); in create_fw_cfg()
1437 qemu_fdt_setprop(ms->fdt, nodename, "interrupt-map", in create_pcie_irq_map()
1440 qemu_fdt_setprop_cells(ms->fdt, nodename, "interrupt-map-mask", in create_pcie_irq_map()
1451 const char compat[] = "arm,smmu-v3"; in create_smmu()
1452 int irq = vms->irqmap[VIRT_SMMU]; in create_smmu()
1454 hwaddr base = vms->memmap[VIRT_SMMU].base; in create_smmu()
1455 hwaddr size = vms->memmap[VIRT_SMMU].size; in create_smmu()
1456 const char irq_names[] = "eventq\0priq\0cmdq-sync\0gerror"; in create_smmu()
1460 if (vms->iommu != VIRT_IOMMU_SMMUV3 || !vms->iommu_phandle) { in create_smmu()
1466 if (!vmc->no_nested_smmu) { in create_smmu()
1469 object_property_set_link(OBJECT(dev), "primary-bus", OBJECT(bus), in create_smmu()
1475 qdev_get_gpio_in(vms->gic, irq + i)); in create_smmu()
1479 qemu_fdt_add_subnode(ms->fdt, node); in create_smmu()
1480 qemu_fdt_setprop(ms->fdt, node, "compatible", compat, sizeof(compat)); in create_smmu()
1481 qemu_fdt_setprop_sized_cells(ms->fdt, node, "reg", 2, base, 2, size); in create_smmu()
1483 qemu_fdt_setprop_cells(ms->fdt, node, "interrupts", in create_smmu()
1489 qemu_fdt_setprop(ms->fdt, node, "interrupt-names", irq_names, in create_smmu()
1492 qemu_fdt_setprop(ms->fdt, node, "dma-coherent", NULL, 0); in create_smmu()
1494 qemu_fdt_setprop_cell(ms->fdt, node, "#iommu-cells", 1); in create_smmu()
1496 qemu_fdt_setprop_cell(ms->fdt, node, "phandle", vms->iommu_phandle); in create_smmu()
1502 const char compat[] = "virtio,pci-iommu\0pci1af4,1057"; in create_virtio_iommu_dt_bindings()
1503 uint16_t bdf = vms->virtio_iommu_bdf; in create_virtio_iommu_dt_bindings()
1507 vms->iommu_phandle = qemu_fdt_alloc_phandle(ms->fdt); in create_virtio_iommu_dt_bindings()
1509 node = g_strdup_printf("%s/virtio_iommu@%x,%x", vms->pciehb_nodename, in create_virtio_iommu_dt_bindings()
1511 qemu_fdt_add_subnode(ms->fdt, node); in create_virtio_iommu_dt_bindings()
1512 qemu_fdt_setprop(ms->fdt, node, "compatible", compat, sizeof(compat)); in create_virtio_iommu_dt_bindings()
1513 qemu_fdt_setprop_sized_cells(ms->fdt, node, "reg", in create_virtio_iommu_dt_bindings()
1517 qemu_fdt_setprop_cell(ms->fdt, node, "#iommu-cells", 1); in create_virtio_iommu_dt_bindings()
1518 qemu_fdt_setprop_cell(ms->fdt, node, "phandle", vms->iommu_phandle); in create_virtio_iommu_dt_bindings()
1521 if (!vms->default_bus_bypass_iommu) { in create_virtio_iommu_dt_bindings()
1522 qemu_fdt_setprop_cells(ms->fdt, vms->pciehb_nodename, "iommu-map", in create_virtio_iommu_dt_bindings()
1523 0x0, vms->iommu_phandle, 0x0, bdf, in create_virtio_iommu_dt_bindings()
1524 bdf + 1, vms->iommu_phandle, bdf + 1, in create_virtio_iommu_dt_bindings()
1525 0xffff - bdf); in create_virtio_iommu_dt_bindings()
1531 hwaddr base_mmio = vms->memmap[VIRT_PCIE_MMIO].base; in create_pcie()
1532 hwaddr size_mmio = vms->memmap[VIRT_PCIE_MMIO].size; in create_pcie()
1533 hwaddr base_mmio_high = vms->memmap[VIRT_HIGH_PCIE_MMIO].base; in create_pcie()
1534 hwaddr size_mmio_high = vms->memmap[VIRT_HIGH_PCIE_MMIO].size; in create_pcie()
1535 hwaddr base_pio = vms->memmap[VIRT_PCIE_PIO].base; in create_pcie()
1536 hwaddr size_pio = vms->memmap[VIRT_PCIE_PIO].size; in create_pcie()
1540 int irq = vms->irqmap[VIRT_PCIE]; in create_pcie()
1555 ecam_id = VIRT_ECAM_ID(vms->highmem_ecam); in create_pcie()
1556 base_ecam = vms->memmap[ecam_id].base; in create_pcie()
1557 size_ecam = vms->memmap[ecam_id].size; in create_pcie()
1562 memory_region_init_alias(ecam_alias, OBJECT(dev), "pcie-ecam", in create_pcie()
1573 memory_region_init_alias(mmio_alias, OBJECT(dev), "pcie-mmio", in create_pcie()
1577 if (vms->highmem_mmio) { in create_pcie()
1581 memory_region_init_alias(high_mmio_alias, OBJECT(dev), "pcie-mmio-high", in create_pcie()
1592 qdev_get_gpio_in(vms->gic, irq + i)); in create_pcie()
1597 pci->bypass_iommu = vms->default_bus_bypass_iommu; in create_pcie()
1598 vms->bus = pci->bus; in create_pcie()
1599 if (vms->bus) { in create_pcie()
1600 pci_init_nic_devices(pci->bus, mc->default_nic); in create_pcie()
1603 nodename = vms->pciehb_nodename = g_strdup_printf("/pcie@%" PRIx64, base); in create_pcie()
1604 qemu_fdt_add_subnode(ms->fdt, nodename); in create_pcie()
1605 qemu_fdt_setprop_string(ms->fdt, nodename, in create_pcie()
1606 "compatible", "pci-host-ecam-generic"); in create_pcie()
1607 qemu_fdt_setprop_string(ms->fdt, nodename, "device_type", "pci"); in create_pcie()
1608 qemu_fdt_setprop_cell(ms->fdt, nodename, "#address-cells", 3); in create_pcie()
1609 qemu_fdt_setprop_cell(ms->fdt, nodename, "#size-cells", 2); in create_pcie()
1610 qemu_fdt_setprop_cell(ms->fdt, nodename, "linux,pci-domain", 0); in create_pcie()
1611 qemu_fdt_setprop_cells(ms->fdt, nodename, "bus-range", 0, in create_pcie()
1612 nr_pcie_buses - 1); in create_pcie()
1613 qemu_fdt_setprop(ms->fdt, nodename, "dma-coherent", NULL, 0); in create_pcie()
1615 if (vms->msi_phandle) { in create_pcie()
1616 qemu_fdt_setprop_cells(ms->fdt, nodename, "msi-map", in create_pcie()
1617 0, vms->msi_phandle, 0, 0x10000); in create_pcie()
1620 qemu_fdt_setprop_sized_cells(ms->fdt, nodename, "reg", in create_pcie()
1623 if (vms->highmem_mmio) { in create_pcie()
1624 qemu_fdt_setprop_sized_cells(ms->fdt, nodename, "ranges", in create_pcie()
1633 qemu_fdt_setprop_sized_cells(ms->fdt, nodename, "ranges", in create_pcie()
1640 qemu_fdt_setprop_cell(ms->fdt, nodename, "#interrupt-cells", 1); in create_pcie()
1641 create_pcie_irq_map(ms, vms->gic_phandle, irq, nodename); in create_pcie()
1643 if (vms->iommu) { in create_pcie()
1644 vms->iommu_phandle = qemu_fdt_alloc_phandle(ms->fdt); in create_pcie()
1646 switch (vms->iommu) { in create_pcie()
1648 create_smmu(vms, vms->bus); in create_pcie()
1649 if (!vms->default_bus_bypass_iommu) { in create_pcie()
1650 qemu_fdt_setprop_cells(ms->fdt, nodename, "iommu-map", in create_pcie()
1651 0x0, vms->iommu_phandle, 0x0, 0x10000); in create_pcie()
1663 MemoryRegion *mr = &vms->cxl_devices_state.host_mr; in create_cxl_host_reg_region()
1666 vms->memmap[VIRT_CXL_HOST].size); in create_cxl_host_reg_region()
1667 memory_region_add_subregion(sysmem, vms->memmap[VIRT_CXL_HOST].base, mr); in create_cxl_host_reg_region()
1668 vms->highmem_cxl = true; in create_cxl_host_reg_region()
1679 dev->id = g_strdup(TYPE_PLATFORM_BUS_DEVICE); in create_platform_bus()
1681 qdev_prop_set_uint32(dev, "mmio_size", vms->memmap[VIRT_PLATFORM_BUS].size); in create_platform_bus()
1683 vms->platform_bus_dev = dev; in create_platform_bus()
1687 int irq = vms->irqmap[VIRT_PLATFORM_BUS] + i; in create_platform_bus()
1688 sysbus_connect_irq(s, i, qdev_get_gpio_in(vms->gic, irq)); in create_platform_bus()
1692 vms->memmap[VIRT_PLATFORM_BUS].base, in create_platform_bus()
1712 hwaddr base = vms->memmap[VIRT_SECURE_MEM].base; in create_secure_ram()
1713 hwaddr size = vms->memmap[VIRT_SECURE_MEM].size; in create_secure_ram()
1716 memory_region_init_ram(secram, NULL, "virt.secure-ram", size, in create_secure_ram()
1721 qemu_fdt_add_subnode(ms->fdt, nodename); in create_secure_ram()
1722 qemu_fdt_setprop_string(ms->fdt, nodename, "device_type", "memory"); in create_secure_ram()
1723 qemu_fdt_setprop_sized_cells(ms->fdt, nodename, "reg", 2, base, 2, size); in create_secure_ram()
1724 qemu_fdt_setprop_string(ms->fdt, nodename, "status", "disabled"); in create_secure_ram()
1725 qemu_fdt_setprop_string(ms->fdt, nodename, "secure-status", "okay"); in create_secure_ram()
1728 create_tag_ram(secure_tag_sysmem, base, size, "mach-virt.secure-tag"); in create_secure_ram()
1741 *fdt_size = board->fdt_size; in machvirt_dtb()
1742 return ms->fdt; in machvirt_dtb()
1758 smbios_set_defaults("QEMU", product, mc->name); in virt_build_smbios()
1760 /* build the array of physical mem area from base_memmap */ in virt_build_smbios()
1761 mem_array.address = vms->memmap[VIRT_MEM].base; in virt_build_smbios()
1762 mem_array.length = ms->ram_size; in virt_build_smbios()
1770 fw_cfg_add_file(vms->fw_cfg, "etc/smbios/smbios-tables", in virt_build_smbios()
1772 fw_cfg_add_file(vms->fw_cfg, "etc/smbios/smbios-anchor", in virt_build_smbios()
1784 struct arm_boot_info *info = &vms->bootinfo; in virt_machine_done()
1787 cxl_hook_up_pxb_registers(vms->bus, &vms->cxl_devices_state, in virt_machine_done()
1790 if (vms->cxl_devices_state.is_enabled) { in virt_machine_done()
1800 if (info->dtb_filename == NULL) { in virt_machine_done()
1801 platform_bus_add_all_fdt_nodes(ms->fdt, "/intc", in virt_machine_done()
1802 vms->memmap[VIRT_PLATFORM_BUS].base, in virt_machine_done()
1803 vms->memmap[VIRT_PLATFORM_BUS].size, in virt_machine_done()
1804 vms->irqmap[VIRT_PLATFORM_BUS]); in virt_machine_done()
1806 if (arm_load_dtb(info->dtb_start, info, info->dtb_limit, as, ms, cpu) < 0) { in virt_machine_done()
1810 pci_bus_add_fw_cfg_extra_pci_roots(vms->fw_cfg, vms->bus, in virt_machine_done()
1822 * Adjust MPIDR to make TCG consistent (with 64-bit KVM hosts) in virt_cpu_mp_affinity()
1825 if (vms->gic_version == VIRT_GIC_VERSION_2) { in virt_cpu_mp_affinity()
1838 &vms->highmem_redists, in virt_get_high_memmap_enabled()
1839 &vms->highmem_cxl, in virt_get_high_memmap_enabled()
1840 &vms->highmem_ecam, in virt_get_high_memmap_enabled()
1841 &vms->highmem_mmio, in virt_get_high_memmap_enabled()
1844 assert(ARRAY_SIZE(extended_memmap) - VIRT_LOWMEMMAP_LAST == in virt_get_high_memmap_enabled()
1846 assert(index - VIRT_LOWMEMMAP_LAST < ARRAY_SIZE(enabled_array)); in virt_get_high_memmap_enabled()
1848 return enabled_array[index - VIRT_LOWMEMMAP_LAST]; in virt_get_high_memmap_enabled()
1863 vms->memmap[i].base = region_base; in virt_set_high_memmap()
1864 vms->memmap[i].size = region_size; in virt_set_high_memmap()
1869 * highest_gpa for disabled fitting devices as well, if in virt_set_high_memmap()
1870 * the compact layout has been disabled. in virt_set_high_memmap()
1876 if (vms->highmem_compact && !*region_enabled) { in virt_set_high_memmap()
1882 vms->highest_gpa = base - 1; in virt_set_high_memmap()
1893 vms->memmap = extended_memmap; in virt_set_memmap()
1896 vms->memmap[i] = base_memmap[i]; in virt_set_memmap()
1899 if (ms->ram_slots > ACPI_MAX_RAM_SLOTS) { in virt_set_memmap()
1901 ms->ram_slots); in virt_set_memmap()
1909 if (!vms->highmem) { in virt_set_memmap()
1921 ROUND_UP(vms->memmap[VIRT_MEM].base + ms->ram_size, GiB); in virt_set_memmap()
1922 device_memory_size = ms->maxram_size - ms->ram_size + ms->ram_slots * GiB; in virt_set_memmap()
1928 pa_bits, memtop - BIT_ULL(pa_bits)); in virt_set_memmap()
1935 if (base < vms->memmap[VIRT_MEM].base + LEGACY_RAMLIMIT_BYTES) { in virt_set_memmap()
1936 base = vms->memmap[VIRT_MEM].base + LEGACY_RAMLIMIT_BYTES; in virt_set_memmap()
1940 vms->highest_gpa = memtop - 1; in virt_set_memmap()
1947 vms->highest_gpa = cxl_fmws_set_memmap(ROUND_UP(vms->highest_gpa + 1, in virt_set_memmap()
1949 BIT_ULL(pa_bits)) - 1; in virt_set_memmap()
1961 error_report("gic-version=host requires KVM"); in finalize_gic_version_do()
1965 /* For KVM, gic-version=host means gic-version=max */ in finalize_gic_version_do()
1984 * the end-user requested more than 8 VCPUs we now default in finalize_gic_version_do()
2031 * finalize_gic_version - Determines the final gic_version
2032 * according to the gic-version property
2039 unsigned int max_cpus = MACHINE(vms)->smp.max_cpus; in finalize_gic_version()
2060 accel_name = "KVM with kernel-irqchip=off"; in finalize_gic_version()
2063 if (module_object_class_by_name("arm-gicv3")) { in finalize_gic_version()
2065 if (vms->virt) { in finalize_gic_version()
2079 vms->gic_version = finalize_gic_version_do(accel_name, vms->gic_version, in finalize_gic_version()
2090 int max_cpus = MACHINE(vms)->smp.max_cpus; in virt_post_cpus_gic_realized()
2097 "kvm-steal-time", NULL); in virt_post_cpus_gic_realized()
2100 hwaddr pvtime_reg_base = vms->memmap[VIRT_PVTIME].base; in virt_post_cpus_gic_realized()
2101 hwaddr pvtime_reg_size = vms->memmap[VIRT_PVTIME].size; in virt_post_cpus_gic_realized()
2121 if (!aarch64 && vms->virt) { in virt_post_cpus_gic_realized()
2128 assert(arm_feature(&ARM_CPU(cpu)->env, ARM_FEATURE_PMU)); in virt_post_cpus_gic_realized()
2136 + cpu->cpu_index in virt_post_cpus_gic_realized()
2141 if (aarch64 && vms->highmem) { in virt_post_cpus_gic_realized()
2142 int requested_pa_size = 64 - clz64(vms->highest_gpa); in virt_post_cpus_gic_realized()
2168 bool has_ged = !vmc->no_ged; in machvirt_init()
2169 unsigned int smp_cpus = machine->smp.cpus; in machvirt_init()
2170 unsigned int max_cpus = machine->smp.max_cpus; in machvirt_init()
2172 possible_cpus = mc->possible_cpu_arch_ids(machine); in machvirt_init()
2179 if (!vms->memmap) { in machvirt_init()
2189 cpuobj = object_new(possible_cpus->cpus[0].type); in machvirt_init()
2204 if (vms->secure) { in machvirt_init()
2208 * containing the system memory at low priority; any secure-only in machvirt_init()
2212 memory_region_init(secure_sysmem, OBJECT(machine), "secure-memory", in machvirt_init()
2214 memory_region_add_subregion_overlap(secure_sysmem, 0, sysmem, -1); in machvirt_init()
2230 if (vms->secure && firmware_loaded) { in machvirt_init()
2231 vms->psci_conduit = QEMU_PSCI_CONDUIT_DISABLED; in machvirt_init()
2232 } else if (vms->virt) { in machvirt_init()
2233 vms->psci_conduit = QEMU_PSCI_CONDUIT_SMC; in machvirt_init()
2235 vms->psci_conduit = QEMU_PSCI_CONDUIT_HVC; in machvirt_init()
2243 if (vms->gic_version == VIRT_GIC_VERSION_2) { in machvirt_init()
2247 if (vms->highmem_redists) { in machvirt_init()
2254 "supported by machine 'mach-virt' (%d)", in machvirt_init()
2256 if (vms->gic_version != VIRT_GIC_VERSION_2 && !vms->highmem_redists) { in machvirt_init()
2257 error_printf("Try 'highmem-redists=on' for more CPUs\n"); in machvirt_init()
2263 if (vms->secure && !tcg_enabled() && !qtest_enabled()) { in machvirt_init()
2264 error_report("mach-virt: %s does not support providing " in machvirt_init()
2270 if (vms->virt && kvm_enabled() && !kvm_arm_el2_supported()) { in machvirt_init()
2271 error_report("mach-virt: host kernel KVM does not support providing " in machvirt_init()
2276 if (vms->virt && !kvm_enabled() && !tcg_enabled() && !qtest_enabled()) { in machvirt_init()
2277 error_report("mach-virt: %s does not support providing " in machvirt_init()
2283 if (vms->mte && hvf_enabled()) { in machvirt_init()
2284 error_report("mach-virt: %s does not support providing " in machvirt_init()
2292 assert(possible_cpus->len == max_cpus); in machvirt_init()
2293 for (n = 0; n < possible_cpus->len; n++) { in machvirt_init()
2301 cpuobj = object_new(possible_cpus->cpus[n].type); in machvirt_init()
2302 object_property_set_int(cpuobj, "mp-affinity", in machvirt_init()
2303 possible_cpus->cpus[n].arch_id, NULL); in machvirt_init()
2306 cs->cpu_index = n; in machvirt_init()
2308 numa_cpu_pre_plug(&possible_cpus->cpus[cs->cpu_index], DEVICE(cpuobj), in machvirt_init()
2313 if (!vms->secure) { in machvirt_init()
2317 if (!vms->virt && object_property_find(cpuobj, "has_el2")) { in machvirt_init()
2321 if (vmc->kvm_no_adjvtime && in machvirt_init()
2322 object_property_find(cpuobj, "kvm-no-adjvtime")) { in machvirt_init()
2323 object_property_set_bool(cpuobj, "kvm-no-adjvtime", true, NULL); in machvirt_init()
2326 if (vmc->no_kvm_steal_time && in machvirt_init()
2327 object_property_find(cpuobj, "kvm-steal-time")) { in machvirt_init()
2328 object_property_set_bool(cpuobj, "kvm-steal-time", false, NULL); in machvirt_init()
2331 if (vmc->no_tcg_lpa2 && object_property_find(cpuobj, "lpa2")) { in machvirt_init()
2335 if (object_property_find(cpuobj, "reset-cbar")) { in machvirt_init()
2336 object_property_set_int(cpuobj, "reset-cbar", in machvirt_init()
2337 vms->memmap[VIRT_CPUPERIPHS].base, in machvirt_init()
2343 if (vms->secure) { in machvirt_init()
2344 object_property_set_link(cpuobj, "secure-memory", in machvirt_init()
2348 if (vms->mte) { in machvirt_init()
2356 if (!object_property_find(cpuobj, "tag-memory")) { in machvirt_init()
2364 "tag-memory", UINT64_MAX / 32); in machvirt_init()
2366 if (vms->secure) { in machvirt_init()
2369 "secure-tag-memory", in machvirt_init()
2372 /* As with ram, secure-tag takes precedence over tag. */ in machvirt_init()
2374 0, tag_sysmem, -1); in machvirt_init()
2378 object_property_set_link(cpuobj, "tag-memory", in machvirt_init()
2380 if (vms->secure) { in machvirt_init()
2381 object_property_set_link(cpuobj, "secure-tag-memory", in machvirt_init()
2402 vms->ns_el2_virt_timer_irq = ns_el2_virt_timer_present() && in machvirt_init()
2403 !vmc->no_ns_el2_virt_timer_irq; in machvirt_init()
2408 memory_region_add_subregion(sysmem, vms->memmap[VIRT_MEM].base, in machvirt_init()
2409 machine->ram); in machvirt_init()
2424 * if a backend is configured explicitly via '-serial <backend>'. in machvirt_init()
2434 * aliases node information and /chosen/stdout-path regardless of in machvirt_init()
2437 * For similar back-compatibility reasons, if UART1 is the secure UART in machvirt_init()
2441 if (!vms->secure) { in machvirt_init()
2445 vms->second_ns_uart_present = true; in machvirt_init()
2450 if (vms->secure) { in machvirt_init()
2454 if (vms->secure) { in machvirt_init()
2459 create_tag_ram(tag_sysmem, vms->memmap[VIRT_MEM].base, in machvirt_init()
2460 machine->ram_size, "mach-virt.tag"); in machvirt_init()
2463 vms->highmem_ecam &= (!firmware_loaded || aarch64); in machvirt_init()
2471 vms->acpi_dev = create_acpi_ged(vms); in machvirt_init()
2476 if (vms->secure && !vmc->no_secure_gpio) { in machvirt_init()
2481 vms->powerdown_notifier.notify = virt_powerdown_req; in machvirt_init()
2482 qemu_register_powerdown_notifier(&vms->powerdown_notifier); in machvirt_init()
2490 vms->fw_cfg = create_fw_cfg(vms, &address_space_memory); in machvirt_init()
2491 rom_set_fw(vms->fw_cfg); in machvirt_init()
2495 if (machine->nvdimms_state->is_enabled) { in machvirt_init()
2498 .address = vms->memmap[VIRT_NVDIMM_ACPI].base, in machvirt_init()
2502 nvdimm_init_acpi_state(machine->nvdimms_state, sysmem, in machvirt_init()
2504 vms->fw_cfg, OBJECT(vms)); in machvirt_init()
2507 vms->bootinfo.ram_size = machine->ram_size; in machvirt_init()
2508 vms->bootinfo.board_id = -1; in machvirt_init()
2509 vms->bootinfo.loader_start = vms->memmap[VIRT_MEM].base; in machvirt_init()
2510 vms->bootinfo.get_dtb = machvirt_dtb; in machvirt_init()
2511 vms->bootinfo.skip_dtb_autoload = true; in machvirt_init()
2512 vms->bootinfo.firmware_loaded = firmware_loaded; in machvirt_init()
2513 vms->bootinfo.psci_conduit = vms->psci_conduit; in machvirt_init()
2514 arm_load_kernel(ARM_CPU(first_cpu), machine, &vms->bootinfo); in machvirt_init()
2516 vms->machine_done.notify = virt_machine_done; in machvirt_init()
2517 qemu_add_machine_init_done_notifier(&vms->machine_done); in machvirt_init()
2524 return vms->secure; in virt_get_secure()
2531 vms->secure = value; in virt_set_secure()
2538 return vms->virt; in virt_get_virt()
2545 vms->virt = value; in virt_set_virt()
2552 return vms->highmem; in virt_get_highmem()
2559 vms->highmem = value; in virt_set_highmem()
2566 return vms->highmem_compact; in virt_get_compact_highmem()
2573 vms->highmem_compact = value; in virt_set_compact_highmem()
2580 return vms->highmem_redists; in virt_get_highmem_redists()
2587 vms->highmem_redists = value; in virt_set_highmem_redists()
2594 return vms->highmem_ecam; in virt_get_highmem_ecam()
2601 vms->highmem_ecam = value; in virt_set_highmem_ecam()
2608 return vms->highmem_mmio; in virt_get_highmem_mmio()
2615 vms->highmem_mmio = value; in virt_set_highmem_mmio()
2638 error_setg(errp, "highmem-mmio-size is not a power of 2"); in virt_set_highmem_mmio_size()
2644 error_setg(errp, "highmem-mmio-size cannot be set to a lower value " in virt_set_highmem_mmio_size()
2657 return vms->its; in virt_get_its()
2664 vms->its = value; in virt_set_its()
2671 return vms->dtb_randomness; in virt_get_dtb_randomness()
2678 vms->dtb_randomness = value; in virt_set_dtb_randomness()
2685 return g_strdup(vms->oem_id); in virt_get_oem_id()
2695 "User specified oem-id value is bigger than 6 bytes in size"); in virt_set_oem_id()
2699 strncpy(vms->oem_id, value, 6); in virt_set_oem_id()
2706 return g_strdup(vms->oem_table_id); in virt_get_oem_table_id()
2717 "User specified oem-table-id value is bigger than 8 bytes in size"); in virt_set_oem_table_id()
2720 strncpy(vms->oem_table_id, value, 8); in virt_set_oem_table_id()
2726 if (vms->acpi == ON_OFF_AUTO_OFF) { in virt_is_acpi_enabled()
2736 OnOffAuto acpi = vms->acpi; in virt_get_acpi()
2746 visit_type_OnOffAuto(v, name, &vms->acpi, errp); in virt_set_acpi()
2753 return vms->ras; in virt_get_ras()
2760 vms->ras = value; in virt_set_ras()
2767 return vms->mte; in virt_get_mte()
2774 vms->mte = value; in virt_set_mte()
2782 switch (vms->gic_version) { in virt_get_gic_version()
2801 vms->gic_version = VIRT_GIC_VERSION_4; in virt_set_gic_version()
2803 vms->gic_version = VIRT_GIC_VERSION_3; in virt_set_gic_version()
2805 vms->gic_version = VIRT_GIC_VERSION_2; in virt_set_gic_version()
2807 vms->gic_version = VIRT_GIC_VERSION_HOST; /* Will probe later */ in virt_set_gic_version()
2809 vms->gic_version = VIRT_GIC_VERSION_MAX; /* Will probe later */ in virt_set_gic_version()
2811 error_setg(errp, "Invalid gic-version value"); in virt_set_gic_version()
2820 switch (vms->iommu) { in virt_get_iommu()
2835 vms->iommu = VIRT_IOMMU_SMMUV3; in virt_set_iommu()
2837 vms->iommu = VIRT_IOMMU_NONE; in virt_set_iommu()
2848 return vms->default_bus_bypass_iommu; in virt_get_default_bus_bypass_iommu()
2856 vms->default_bus_bypass_iommu = value; in virt_set_default_bus_bypass_iommu()
2863 const CPUArchIdList *possible_cpus = mc->possible_cpu_arch_ids(ms); in virt_cpu_index_to_props()
2865 assert(cpu_index < possible_cpus->len); in virt_cpu_index_to_props()
2866 return possible_cpus->cpus[cpu_index].props; in virt_cpu_index_to_props()
2871 int64_t socket_id = ms->possible_cpus->cpus[idx].props.socket_id; in virt_get_default_cpu_node_id()
2873 return socket_id % ms->numa_state->num_nodes; in virt_get_default_cpu_node_id()
2879 unsigned int max_cpus = ms->smp.max_cpus; in virt_possible_cpu_arch_ids()
2883 if (ms->possible_cpus) { in virt_possible_cpu_arch_ids()
2884 assert(ms->possible_cpus->len == max_cpus); in virt_possible_cpu_arch_ids()
2885 return ms->possible_cpus; in virt_possible_cpu_arch_ids()
2888 ms->possible_cpus = g_malloc0(sizeof(CPUArchIdList) + in virt_possible_cpu_arch_ids()
2890 ms->possible_cpus->len = max_cpus; in virt_possible_cpu_arch_ids()
2891 for (n = 0; n < ms->possible_cpus->len; n++) { in virt_possible_cpu_arch_ids()
2892 ms->possible_cpus->cpus[n].type = ms->cpu_type; in virt_possible_cpu_arch_ids()
2893 ms->possible_cpus->cpus[n].arch_id = in virt_possible_cpu_arch_ids()
2896 assert(!mc->smp_props.dies_supported); in virt_possible_cpu_arch_ids()
2897 ms->possible_cpus->cpus[n].props.has_socket_id = true; in virt_possible_cpu_arch_ids()
2898 ms->possible_cpus->cpus[n].props.socket_id = in virt_possible_cpu_arch_ids()
2899 n / (ms->smp.clusters * ms->smp.cores * ms->smp.threads); in virt_possible_cpu_arch_ids()
2900 ms->possible_cpus->cpus[n].props.has_cluster_id = true; in virt_possible_cpu_arch_ids()
2901 ms->possible_cpus->cpus[n].props.cluster_id = in virt_possible_cpu_arch_ids()
2902 (n / (ms->smp.cores * ms->smp.threads)) % ms->smp.clusters; in virt_possible_cpu_arch_ids()
2903 ms->possible_cpus->cpus[n].props.has_core_id = true; in virt_possible_cpu_arch_ids()
2904 ms->possible_cpus->cpus[n].props.core_id = in virt_possible_cpu_arch_ids()
2905 (n / ms->smp.threads) % ms->smp.cores; in virt_possible_cpu_arch_ids()
2906 ms->possible_cpus->cpus[n].props.has_thread_id = true; in virt_possible_cpu_arch_ids()
2907 ms->possible_cpus->cpus[n].props.thread_id = in virt_possible_cpu_arch_ids()
2908 n % ms->smp.threads; in virt_possible_cpu_arch_ids()
2910 return ms->possible_cpus; in virt_possible_cpu_arch_ids()
2920 if (!vms->acpi_dev) { in virt_memory_pre_plug()
2922 "memory hotplug is not enabled: missing acpi-ged device"); in virt_memory_pre_plug()
2926 if (vms->mte) { in virt_memory_pre_plug()
2931 if (is_nvdimm && !ms->nvdimms_state->is_enabled) { in virt_memory_pre_plug()
2932 error_setg(errp, "nvdimm is not enabled: add 'nvdimm=on' to '-M'"); in virt_memory_pre_plug()
2949 nvdimm_plug(ms->nvdimms_state); in virt_memory_plug()
2952 hotplug_handler_plug(HOTPLUG_HANDLER(vms->acpi_dev), in virt_memory_plug()
2970 if (vms->iommu != VIRT_IOMMU_NONE) { in virt_machine_device_pre_plug_cb()
2975 switch (vms->msi_controller) { in virt_machine_device_pre_plug_cb()
2982 base_memmap[VIRT_GIC_ITS].size - 1; in virt_machine_device_pre_plug_cb()
2987 db_end = db_start + base_memmap[VIRT_GIC_V2M].size - 1; in virt_machine_device_pre_plug_cb()
2996 qdev_prop_set_array(dev, "reserved-regions", reserved_regions); in virt_machine_device_pre_plug_cb()
3006 if (vms->platform_bus_dev) { in virt_machine_device_plug_cb()
3010 platform_bus_link_device(PLATFORM_BUS_DEVICE(vms->platform_bus_dev), in virt_machine_device_plug_cb()
3024 vms->iommu = VIRT_IOMMU_VIRTIO; in virt_machine_device_plug_cb()
3025 vms->virtio_iommu_bdf = pci_get_bdf(pdev); in virt_machine_device_plug_cb()
3035 if (!vms->acpi_dev) { in virt_dimm_unplug_request()
3037 "memory hotplug is not enabled: missing acpi-ged device"); in virt_dimm_unplug_request()
3046 hotplug_handler_unplug_request(HOTPLUG_HANDLER(vms->acpi_dev), dev, in virt_dimm_unplug_request()
3056 hotplug_handler_unplug(HOTPLUG_HANDLER(vms->acpi_dev), dev, &local_err); in virt_dimm_unplug()
3110 * for arm64 kvm_type [7-0] encodes the requested number of bits
3124 requested_pa_size = 64 - clz64(vms->highest_gpa); in virt_kvm_type()
3134 error_report("-m and ,maxmem option values " in virt_kvm_type()
3138 return -1; in virt_kvm_type()
3158 int requested_ipa_size = 64 - clz64(vms->highest_gpa); in virt_hvf_get_physical_address_range()
3171 error_report("-m and ,maxmem option values " in virt_hvf_get_physical_address_range()
3175 return -1; in virt_hvf_get_physical_address_range()
3187 ARM_CPU_TYPE_NAME("cortex-a7"), in virt_machine_class_init()
3188 ARM_CPU_TYPE_NAME("cortex-a15"), in virt_machine_class_init()
3190 ARM_CPU_TYPE_NAME("cortex-a35"), in virt_machine_class_init()
3191 ARM_CPU_TYPE_NAME("cortex-a55"), in virt_machine_class_init()
3192 ARM_CPU_TYPE_NAME("cortex-a72"), in virt_machine_class_init()
3193 ARM_CPU_TYPE_NAME("cortex-a76"), in virt_machine_class_init()
3194 ARM_CPU_TYPE_NAME("cortex-a710"), in virt_machine_class_init()
3196 ARM_CPU_TYPE_NAME("neoverse-n1"), in virt_machine_class_init()
3197 ARM_CPU_TYPE_NAME("neoverse-v1"), in virt_machine_class_init()
3198 ARM_CPU_TYPE_NAME("neoverse-n2"), in virt_machine_class_init()
3202 ARM_CPU_TYPE_NAME("cortex-a53"), in virt_machine_class_init()
3203 ARM_CPU_TYPE_NAME("cortex-a57"), in virt_machine_class_init()
3212 mc->init = machvirt_init; in virt_machine_class_init()
3217 mc->max_cpus = 512; in virt_machine_class_init()
3226 mc->block_default_type = IF_VIRTIO; in virt_machine_class_init()
3227 mc->no_cdrom = 1; in virt_machine_class_init()
3228 mc->pci_allow_0_address = true; in virt_machine_class_init()
3229 /* We know we will never create a pre-ARMv7 CPU which needs 1K pages */ in virt_machine_class_init()
3230 mc->minimum_page_bits = 12; in virt_machine_class_init()
3231 mc->possible_cpu_arch_ids = virt_possible_cpu_arch_ids; in virt_machine_class_init()
3232 mc->cpu_index_to_instance_props = virt_cpu_index_to_props; in virt_machine_class_init()
3234 mc->default_cpu_type = ARM_CPU_TYPE_NAME("cortex-a15"); in virt_machine_class_init()
3236 mc->default_cpu_type = ARM_CPU_TYPE_NAME("max"); in virt_machine_class_init()
3238 mc->valid_cpu_types = valid_cpu_types; in virt_machine_class_init()
3239 mc->get_default_cpu_node_id = virt_get_default_cpu_node_id; in virt_machine_class_init()
3240 mc->kvm_type = virt_kvm_type; in virt_machine_class_init()
3241 mc->hvf_get_physical_address_range = virt_hvf_get_physical_address_range; in virt_machine_class_init()
3242 assert(!mc->get_hotplug_handler); in virt_machine_class_init()
3243 mc->get_hotplug_handler = virt_machine_get_hotplug_handler; in virt_machine_class_init()
3244 hc->pre_plug = virt_machine_device_pre_plug_cb; in virt_machine_class_init()
3245 hc->plug = virt_machine_device_plug_cb; in virt_machine_class_init()
3246 hc->unplug_request = virt_machine_device_unplug_request_cb; in virt_machine_class_init()
3247 hc->unplug = virt_machine_device_unplug_cb; in virt_machine_class_init()
3248 mc->nvdimm_supported = true; in virt_machine_class_init()
3249 mc->smp_props.clusters_supported = true; in virt_machine_class_init()
3250 mc->auto_enable_numa_with_memhp = true; in virt_machine_class_init()
3251 mc->auto_enable_numa_with_memdev = true; in virt_machine_class_init()
3253 mc->cpu_cluster_has_numa_boundary = true; in virt_machine_class_init()
3254 mc->default_ram_id = "mach-virt.ram"; in virt_machine_class_init()
3255 mc->default_nic = "virtio-net-pci"; in virt_machine_class_init()
3281 object_class_property_add_bool(oc, "compact-highmem", in virt_machine_class_init()
3284 object_class_property_set_description(oc, "compact-highmem", in virt_machine_class_init()
3288 object_class_property_add_bool(oc, "highmem-redists", in virt_machine_class_init()
3291 object_class_property_set_description(oc, "highmem-redists", in virt_machine_class_init()
3296 object_class_property_add_bool(oc, "highmem-ecam", in virt_machine_class_init()
3299 object_class_property_set_description(oc, "highmem-ecam", in virt_machine_class_init()
3303 object_class_property_add_bool(oc, "highmem-mmio", in virt_machine_class_init()
3306 object_class_property_set_description(oc, "highmem-mmio", in virt_machine_class_init()
3310 object_class_property_add(oc, "highmem-mmio-size", "size", in virt_machine_class_init()
3314 object_class_property_set_description(oc, "highmem-mmio-size", in virt_machine_class_init()
3318 object_class_property_add_str(oc, "gic-version", virt_get_gic_version, in virt_machine_class_init()
3320 object_class_property_set_description(oc, "gic-version", in virt_machine_class_init()
3329 object_class_property_add_bool(oc, "default-bus-bypass-iommu", in virt_machine_class_init()
3332 object_class_property_set_description(oc, "default-bus-bypass-iommu", in virt_machine_class_init()
3354 object_class_property_add_bool(oc, "dtb-randomness", in virt_machine_class_init()
3357 object_class_property_set_description(oc, "dtb-randomness", in virt_machine_class_init()
3359 "non-deterministic dtb nodes to guest"); in virt_machine_class_init()
3361 object_class_property_add_bool(oc, "dtb-kaslr-seed", in virt_machine_class_init()
3364 object_class_property_set_description(oc, "dtb-kaslr-seed", in virt_machine_class_init()
3365 "Deprecated synonym of dtb-randomness"); in virt_machine_class_init()
3367 object_class_property_add_str(oc, "x-oem-id", in virt_machine_class_init()
3370 object_class_property_set_description(oc, "x-oem-id", in virt_machine_class_init()
3376 object_class_property_add_str(oc, "x-oem-table-id", in virt_machine_class_init()
3379 object_class_property_set_description(oc, "x-oem-table-id", in virt_machine_class_init()
3391 /* EL3 is disabled by default on virt: this makes us consistent in virt_instance_init()
3392 * between KVM and TCG for this board, and it also allows us to in virt_instance_init()
3395 vms->secure = false; in virt_instance_init()
3397 /* EL2 is also disabled by default, for similar reasons */ in virt_instance_init()
3398 vms->virt = false; in virt_instance_init()
3401 vms->highmem = true; in virt_instance_init()
3402 vms->highmem_compact = !vmc->no_highmem_compact; in virt_instance_init()
3403 vms->gic_version = VIRT_GIC_VERSION_NOSEL; in virt_instance_init()
3405 vms->highmem_ecam = true; in virt_instance_init()
3406 vms->highmem_mmio = true; in virt_instance_init()
3407 vms->highmem_redists = true; in virt_instance_init()
3410 vms->its = true; in virt_instance_init()
3412 vms->tcg_its = !vmc->no_tcg_its; in virt_instance_init()
3415 vms->iommu = VIRT_IOMMU_NONE; in virt_instance_init()
3418 vms->default_bus_bypass_iommu = false; in virt_instance_init()
3421 vms->ras = false; in virt_instance_init()
3423 /* MTE is disabled by default. */ in virt_instance_init()
3424 vms->mte = false; in virt_instance_init()
3426 /* Supply kaslr-seed and rng-seed by default */ in virt_instance_init()
3427 vms->dtb_randomness = true; in virt_instance_init()
3429 vms->irqmap = a15irqmap; in virt_instance_init()
3433 vms->oem_id = g_strndup(ACPI_BUILD_APPNAME6, 6); in virt_instance_init()
3434 vms->oem_table_id = g_strndup(ACPI_BUILD_APPNAME8, 8); in virt_instance_init()
3435 cxl_machine_init(obj, &vms->cxl_devices_state); in virt_instance_init()
3466 compat_props_add(mc->compat_props, hw_compat_10_0, hw_compat_10_0_len); in virt_machine_10_0_options()
3473 compat_props_add(mc->compat_props, hw_compat_9_2, hw_compat_9_2_len); in virt_machine_9_2_options()
3482 compat_props_add(mc->compat_props, hw_compat_9_1, hw_compat_9_1_len); in virt_machine_9_1_options()
3483 /* 9.1 and earlier have only a stage-1 SMMU, not a nested s1+2 one */ in virt_machine_9_1_options()
3484 vmc->no_nested_smmu = true; in virt_machine_9_1_options()
3491 mc->smbios_memory_device_size = 16 * GiB; in virt_machine_9_0_options()
3492 compat_props_add(mc->compat_props, hw_compat_9_0, hw_compat_9_0_len); in virt_machine_9_0_options()
3501 compat_props_add(mc->compat_props, hw_compat_8_2, hw_compat_8_2_len); in virt_machine_8_2_options()
3507 vmc->no_ns_el2_virt_timer_irq = true; in virt_machine_8_2_options()
3514 compat_props_add(mc->compat_props, hw_compat_8_1, hw_compat_8_1_len); in virt_machine_8_1_options()
3521 compat_props_add(mc->compat_props, hw_compat_8_0, hw_compat_8_0_len); in virt_machine_8_0_options()
3528 compat_props_add(mc->compat_props, hw_compat_7_2, hw_compat_7_2_len); in virt_machine_7_2_options()
3537 compat_props_add(mc->compat_props, hw_compat_7_1, hw_compat_7_1_len); in virt_machine_7_1_options()
3539 vmc->no_highmem_compact = true; in virt_machine_7_1_options()
3546 compat_props_add(mc->compat_props, hw_compat_7_0, hw_compat_7_0_len); in virt_machine_7_0_options()
3555 compat_props_add(mc->compat_props, hw_compat_6_2, hw_compat_6_2_len); in virt_machine_6_2_options()
3556 vmc->no_tcg_lpa2 = true; in virt_machine_6_2_options()
3565 compat_props_add(mc->compat_props, hw_compat_6_1, hw_compat_6_1_len); in virt_machine_6_1_options()
3566 mc->smp_props.prefer_sockets = true; in virt_machine_6_1_options()
3567 vmc->no_cpu_topology = true; in virt_machine_6_1_options()
3570 vmc->no_tcg_its = true; in virt_machine_6_1_options()
3577 compat_props_add(mc->compat_props, hw_compat_6_0, hw_compat_6_0_len); in virt_machine_6_0_options()
3586 compat_props_add(mc->compat_props, hw_compat_5_2, hw_compat_5_2_len); in virt_machine_5_2_options()
3587 vmc->no_secure_gpio = true; in virt_machine_5_2_options()
3596 compat_props_add(mc->compat_props, hw_compat_5_1, hw_compat_5_1_len); in virt_machine_5_1_options()
3597 vmc->no_kvm_steal_time = true; in virt_machine_5_1_options()
3606 compat_props_add(mc->compat_props, hw_compat_5_0, hw_compat_5_0_len); in virt_machine_5_0_options()
3607 mc->numa_mem_supported = true; in virt_machine_5_0_options()
3608 vmc->acpi_expose_flash = true; in virt_machine_5_0_options()
3609 mc->auto_enable_numa_with_memdev = false; in virt_machine_5_0_options()
3618 compat_props_add(mc->compat_props, hw_compat_4_2, hw_compat_4_2_len); in virt_machine_4_2_options()
3619 vmc->kvm_no_adjvtime = true; in virt_machine_4_2_options()
3628 compat_props_add(mc->compat_props, hw_compat_4_1, hw_compat_4_1_len); in virt_machine_4_1_options()
3629 vmc->no_ged = true; in virt_machine_4_1_options()
3630 mc->auto_enable_numa_with_memhp = false; in virt_machine_4_1_options()