/* * QEMU ARM Xen PVH Machine * * SPDX-License-Identifier: MIT */ #include "qemu/osdep.h" #include "qemu/error-report.h" #include "qapi/qapi-commands-migration.h" #include "qapi/visitor.h" #include "hw/boards.h" #include "hw/irq.h" #include "hw/sysbus.h" #include "sysemu/block-backend.h" #include "sysemu/tpm_backend.h" #include "sysemu/sysemu.h" #include "hw/xen/xen-hvm-common.h" #include "sysemu/tpm.h" #include "hw/xen/arch_hvm.h" #include "trace.h" #define TYPE_XEN_ARM MACHINE_TYPE_NAME("xenpvh") OBJECT_DECLARE_SIMPLE_TYPE(XenArmState, XEN_ARM) static const MemoryListener xen_memory_listener = { .region_add = xen_region_add, .region_del = xen_region_del, .log_start = NULL, .log_stop = NULL, .log_sync = NULL, .log_global_start = NULL, .log_global_stop = NULL, .priority = MEMORY_LISTENER_PRIORITY_ACCEL, }; struct XenArmState { /*< private >*/ MachineState parent; XenIOState *state; struct { uint64_t tpm_base_addr; } cfg; }; static MemoryRegion ram_lo, ram_hi; /* * VIRTIO_MMIO_DEV_SIZE is imported from tools/libs/light/libxl_arm.c under Xen * repository. * * Origin: git://xenbits.xen.org/xen.git 2128143c114c */ #define VIRTIO_MMIO_DEV_SIZE 0x200 #define NR_VIRTIO_MMIO_DEVICES \ (GUEST_VIRTIO_MMIO_SPI_LAST - GUEST_VIRTIO_MMIO_SPI_FIRST) static void xen_set_irq(void *opaque, int irq, int level) { if (xendevicemodel_set_irq_level(xen_dmod, xen_domid, irq, level)) { error_report("xendevicemodel_set_irq_level failed"); } } static void xen_create_virtio_mmio_devices(XenArmState *xam) { int i; for (i = 0; i < NR_VIRTIO_MMIO_DEVICES; i++) { hwaddr base = GUEST_VIRTIO_MMIO_BASE + i * VIRTIO_MMIO_DEV_SIZE; qemu_irq irq = qemu_allocate_irq(xen_set_irq, NULL, GUEST_VIRTIO_MMIO_SPI_FIRST + i); sysbus_create_simple("virtio-mmio", base, irq); trace_xen_create_virtio_mmio_devices(i, GUEST_VIRTIO_MMIO_SPI_FIRST + i, base); } } static void xen_init_ram(MachineState *machine) { MemoryRegion *sysmem = get_system_memory(); ram_addr_t block_len, ram_size[GUEST_RAM_BANKS]; trace_xen_init_ram(machine->ram_size); if (machine->ram_size <= GUEST_RAM0_SIZE) { ram_size[0] = machine->ram_size; ram_size[1] = 0; block_len = GUEST_RAM0_BASE + ram_size[0]; } else { ram_size[0] = GUEST_RAM0_SIZE; ram_size[1] = machine->ram_size - GUEST_RAM0_SIZE; block_len = GUEST_RAM1_BASE + ram_size[1]; } memory_region_init_ram(&xen_memory, NULL, "xen.ram", block_len, &error_fatal); memory_region_init_alias(&ram_lo, NULL, "xen.ram.lo", &xen_memory, GUEST_RAM0_BASE, ram_size[0]); memory_region_add_subregion(sysmem, GUEST_RAM0_BASE, &ram_lo); if (ram_size[1] > 0) { memory_region_init_alias(&ram_hi, NULL, "xen.ram.hi", &xen_memory, GUEST_RAM1_BASE, ram_size[1]); memory_region_add_subregion(sysmem, GUEST_RAM1_BASE, &ram_hi); } /* Setup support for grants. */ memory_region_init_ram(&xen_grants, NULL, "xen.grants", block_len, &error_fatal); memory_region_add_subregion(sysmem, XEN_GRANT_ADDR_OFF, &xen_grants); } #ifdef CONFIG_TPM static void xen_enable_tpm(XenArmState *xam) { Error *errp = NULL; DeviceState *dev; SysBusDevice *busdev; TPMBackend *be = qemu_find_tpm_be("tpm0"); if (be == NULL) { error_report("Couldn't find tmp0 backend"); return; } dev = qdev_new(TYPE_TPM_TIS_SYSBUS); object_property_set_link(OBJECT(dev), "tpmdev", OBJECT(be), &errp); object_property_set_str(OBJECT(dev), "tpmdev", be->id, &errp); busdev = SYS_BUS_DEVICE(dev); sysbus_realize_and_unref(busdev, &error_fatal); sysbus_mmio_map(busdev, 0, xam->cfg.tpm_base_addr); trace_xen_enable_tpm(xam->cfg.tpm_base_addr); } #endif static void xen_arm_init(MachineState *machine) { XenArmState *xam = XEN_ARM(machine); xam->state = g_new0(XenIOState, 1); if (machine->ram_size == 0) { warn_report("%s: ram size not specified. QEMU machine started" " without IOREQ (no emulated devices including virtio)", MACHINE_CLASS(object_get_class(OBJECT(machine)))->desc); return; } xen_init_ram(machine); xen_register_ioreq(xam->state, machine->smp.max_cpus, &xen_memory_listener); xen_create_virtio_mmio_devices(xam); #ifdef CONFIG_TPM if (xam->cfg.tpm_base_addr) { xen_enable_tpm(xam); } else { warn_report("tpm-base-addr is not provided. TPM will not be enabled"); } #endif } #ifdef CONFIG_TPM static void xen_arm_get_tpm_base_addr(Object *obj, Visitor *v, const char *name, void *opaque, Error **errp) { XenArmState *xam = XEN_ARM(obj); uint64_t value = xam->cfg.tpm_base_addr; visit_type_uint64(v, name, &value, errp); } static void xen_arm_set_tpm_base_addr(Object *obj, Visitor *v, const char *name, void *opaque, Error **errp) { XenArmState *xam = XEN_ARM(obj); uint64_t value; if (!visit_type_uint64(v, name, &value, errp)) { return; } xam->cfg.tpm_base_addr = value; } #endif static void xen_arm_machine_class_init(ObjectClass *oc, void *data) { MachineClass *mc = MACHINE_CLASS(oc); mc->desc = "Xen PVH ARM machine"; mc->init = xen_arm_init; /* * mc->max_cpus holds the MAX value allowed in the -smp command-line opts. * * 1. If users don't pass any -smp option: * ms->smp.cpus will default to 1. * ms->smp.max_cpus will default to 1. * * 2. If users pass -smp X: * ms->smp.cpus will be set to X. * ms->smp.max_cpus will also be set to X. * * 3. If users pass -smp X,maxcpus=Y: * ms->smp.cpus will be set to X. * ms->smp.max_cpus will be set to Y. * * In scenarios 2 and 3, if X or Y are set to something larger than * mc->max_cpus, QEMU will bail out with an error message. */ mc->max_cpus = GUEST_MAX_VCPUS; mc->default_machine_opts = "accel=xen"; /* Set explicitly here to make sure that real ram_size is passed */ mc->default_ram_size = 0; #ifdef CONFIG_TPM object_class_property_add(oc, "tpm-base-addr", "uint64_t", xen_arm_get_tpm_base_addr, xen_arm_set_tpm_base_addr, NULL, NULL); object_class_property_set_description(oc, "tpm-base-addr", "Set Base address for TPM device."); machine_class_allow_dynamic_sysbus_dev(mc, TYPE_TPM_TIS_SYSBUS); #endif } static const TypeInfo xen_arm_machine_type = { .name = TYPE_XEN_ARM, .parent = TYPE_MACHINE, .class_init = xen_arm_machine_class_init, .instance_size = sizeof(XenArmState), }; static void xen_arm_machine_register_types(void) { type_register_static(&xen_arm_machine_type); } type_init(xen_arm_machine_register_types)