| /* |
| * 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); |
| } |
| |
| void arch_handle_ioreq(XenIOState *state, ioreq_t *req) |
| { |
| hw_error("Invalid ioreq type 0x%x\n", req->type); |
| |
| return; |
| } |
| |
| void arch_xen_set_memory(XenIOState *state, MemoryRegionSection *section, |
| bool add) |
| { |
| } |
| |
| void xen_hvm_modified_memory(ram_addr_t start, ram_addr_t length) |
| { |
| } |
| |
| void qmp_xen_set_global_dirty_log(bool enable, Error **errp) |
| { |
| } |
| |
| #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) |
