153018216SPaolo Bonzini /* 253018216SPaolo Bonzini * QEMU PowerPC pSeries Logical Partition (aka sPAPR) hardware System Emulator 353018216SPaolo Bonzini * 453018216SPaolo Bonzini * Copyright (c) 2004-2007 Fabrice Bellard 553018216SPaolo Bonzini * Copyright (c) 2007 Jocelyn Mayer 653018216SPaolo Bonzini * Copyright (c) 2010 David Gibson, IBM Corporation. 753018216SPaolo Bonzini * 853018216SPaolo Bonzini * Permission is hereby granted, free of charge, to any person obtaining a copy 953018216SPaolo Bonzini * of this software and associated documentation files (the "Software"), to deal 1053018216SPaolo Bonzini * in the Software without restriction, including without limitation the rights 1153018216SPaolo Bonzini * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 1253018216SPaolo Bonzini * copies of the Software, and to permit persons to whom the Software is 1353018216SPaolo Bonzini * furnished to do so, subject to the following conditions: 1453018216SPaolo Bonzini * 1553018216SPaolo Bonzini * The above copyright notice and this permission notice shall be included in 1653018216SPaolo Bonzini * all copies or substantial portions of the Software. 1753018216SPaolo Bonzini * 1853018216SPaolo Bonzini * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 1953018216SPaolo Bonzini * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 2053018216SPaolo Bonzini * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 2153018216SPaolo Bonzini * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 2253018216SPaolo Bonzini * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 2353018216SPaolo Bonzini * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 2453018216SPaolo Bonzini * THE SOFTWARE. 2553018216SPaolo Bonzini * 2653018216SPaolo Bonzini */ 270d75590dSPeter Maydell #include "qemu/osdep.h" 28da34e65cSMarkus Armbruster #include "qapi/error.h" 2953018216SPaolo Bonzini #include "sysemu/sysemu.h" 30e35704baSEduardo Habkost #include "sysemu/numa.h" 3153018216SPaolo Bonzini #include "hw/hw.h" 3203dd024fSPaolo Bonzini #include "qemu/log.h" 3371461b0fSAlexey Kardashevskiy #include "hw/fw-path-provider.h" 3453018216SPaolo Bonzini #include "elf.h" 3553018216SPaolo Bonzini #include "net/net.h" 36ad440b4aSAndrew Jones #include "sysemu/device_tree.h" 37fa1d36dfSMarkus Armbruster #include "sysemu/block-backend.h" 3853018216SPaolo Bonzini #include "sysemu/cpus.h" 39b3946626SVincent Palatin #include "sysemu/hw_accel.h" 4053018216SPaolo Bonzini #include "kvm_ppc.h" 41c4b63b7cSJuan Quintela #include "migration/misc.h" 4284a899deSJuan Quintela #include "migration/global_state.h" 43f2a8f0a6SJuan Quintela #include "migration/register.h" 444be21d56SDavid Gibson #include "mmu-hash64.h" 45b4db5413SSuraj Jitindar Singh #include "mmu-book3s-v3.h" 463794d548SAlexey Kardashevskiy #include "qom/cpu.h" 4753018216SPaolo Bonzini 4853018216SPaolo Bonzini #include "hw/boards.h" 490d09e41aSPaolo Bonzini #include "hw/ppc/ppc.h" 5053018216SPaolo Bonzini #include "hw/loader.h" 5153018216SPaolo Bonzini 527804c353SCédric Le Goater #include "hw/ppc/fdt.h" 530d09e41aSPaolo Bonzini #include "hw/ppc/spapr.h" 540d09e41aSPaolo Bonzini #include "hw/ppc/spapr_vio.h" 550d09e41aSPaolo Bonzini #include "hw/pci-host/spapr.h" 560d09e41aSPaolo Bonzini #include "hw/ppc/xics.h" 5753018216SPaolo Bonzini #include "hw/pci/msi.h" 5853018216SPaolo Bonzini 5953018216SPaolo Bonzini #include "hw/pci/pci.h" 6071461b0fSAlexey Kardashevskiy #include "hw/scsi/scsi.h" 6171461b0fSAlexey Kardashevskiy #include "hw/virtio/virtio-scsi.h" 62c4e13492SFelipe Franciosi #include "hw/virtio/vhost-scsi-common.h" 6353018216SPaolo Bonzini 6453018216SPaolo Bonzini #include "exec/address-spaces.h" 6553018216SPaolo Bonzini #include "hw/usb.h" 6653018216SPaolo Bonzini #include "qemu/config-file.h" 67135a129aSAneesh Kumar K.V #include "qemu/error-report.h" 682a6593cbSAlexey Kardashevskiy #include "trace.h" 6934316482SAlexey Kardashevskiy #include "hw/nmi.h" 706449da45SCédric Le Goater #include "hw/intc/intc.h" 7153018216SPaolo Bonzini 7268a27b20SMichael S. Tsirkin #include "hw/compat.h" 73f348b6d1SVeronia Bahaa #include "qemu/cutils.h" 7494a94e4cSBharata B Rao #include "hw/ppc/spapr_cpu_core.h" 752474bfd4SIgor Mammedov #include "qmp-commands.h" 7668a27b20SMichael S. Tsirkin 7753018216SPaolo Bonzini #include <libfdt.h> 7853018216SPaolo Bonzini 7953018216SPaolo Bonzini /* SLOF memory layout: 8053018216SPaolo Bonzini * 8153018216SPaolo Bonzini * SLOF raw image loaded at 0, copies its romfs right below the flat 8253018216SPaolo Bonzini * device-tree, then position SLOF itself 31M below that 8353018216SPaolo Bonzini * 8453018216SPaolo Bonzini * So we set FW_OVERHEAD to 40MB which should account for all of that 8553018216SPaolo Bonzini * and more 8653018216SPaolo Bonzini * 8753018216SPaolo Bonzini * We load our kernel at 4M, leaving space for SLOF initial image 8853018216SPaolo Bonzini */ 8938b02bd8SAlexey Kardashevskiy #define FDT_MAX_SIZE 0x100000 9053018216SPaolo Bonzini #define RTAS_MAX_SIZE 0x10000 91b7d1f77aSBenjamin Herrenschmidt #define RTAS_MAX_ADDR 0x80000000 /* RTAS must stay below that */ 9253018216SPaolo Bonzini #define FW_MAX_SIZE 0x400000 9353018216SPaolo Bonzini #define FW_FILE_NAME "slof.bin" 9453018216SPaolo Bonzini #define FW_OVERHEAD 0x2800000 9553018216SPaolo Bonzini #define KERNEL_LOAD_ADDR FW_MAX_SIZE 9653018216SPaolo Bonzini 9753018216SPaolo Bonzini #define MIN_RMA_SLOF 128UL 9853018216SPaolo Bonzini 9953018216SPaolo Bonzini #define PHANDLE_XICP 0x00001111 10053018216SPaolo Bonzini 10153018216SPaolo Bonzini #define HTAB_SIZE(spapr) (1ULL << ((spapr)->htab_shift)) 10253018216SPaolo Bonzini 10371cd4dacSCédric Le Goater static ICSState *spapr_ics_create(sPAPRMachineState *spapr, 10471cd4dacSCédric Le Goater const char *type_ics, 105817bb6a4SCédric Le Goater int nr_irqs, Error **errp) 106c04d6cfaSAnthony Liguori { 107175d2aa0SGreg Kurz Error *local_err = NULL; 10871cd4dacSCédric Le Goater Object *obj; 109c04d6cfaSAnthony Liguori 11071cd4dacSCédric Le Goater obj = object_new(type_ics); 111175d2aa0SGreg Kurz object_property_add_child(OBJECT(spapr), "ics", obj, &error_abort); 112ad265631SGreg Kurz object_property_add_const_link(obj, ICS_PROP_XICS, OBJECT(spapr), 113ad265631SGreg Kurz &error_abort); 114175d2aa0SGreg Kurz object_property_set_int(obj, nr_irqs, "nr-irqs", &local_err); 115175d2aa0SGreg Kurz if (local_err) { 116175d2aa0SGreg Kurz goto error; 117175d2aa0SGreg Kurz } 11871cd4dacSCédric Le Goater object_property_set_bool(obj, true, "realized", &local_err); 119175d2aa0SGreg Kurz if (local_err) { 120175d2aa0SGreg Kurz goto error; 121c04d6cfaSAnthony Liguori } 122c04d6cfaSAnthony Liguori 12371cd4dacSCédric Le Goater return ICS_SIMPLE(obj); 124175d2aa0SGreg Kurz 125175d2aa0SGreg Kurz error: 126175d2aa0SGreg Kurz error_propagate(errp, local_err); 127175d2aa0SGreg Kurz return NULL; 1285bc8d26dSCédric Le Goater } 1295bc8d26dSCédric Le Goater 13046f7afa3SGreg Kurz static bool pre_2_10_vmstate_dummy_icp_needed(void *opaque) 13146f7afa3SGreg Kurz { 13246f7afa3SGreg Kurz /* Dummy entries correspond to unused ICPState objects in older QEMUs, 13346f7afa3SGreg Kurz * and newer QEMUs don't even have them. In both cases, we don't want 13446f7afa3SGreg Kurz * to send anything on the wire. 13546f7afa3SGreg Kurz */ 13646f7afa3SGreg Kurz return false; 13746f7afa3SGreg Kurz } 13846f7afa3SGreg Kurz 13946f7afa3SGreg Kurz static const VMStateDescription pre_2_10_vmstate_dummy_icp = { 14046f7afa3SGreg Kurz .name = "icp/server", 14146f7afa3SGreg Kurz .version_id = 1, 14246f7afa3SGreg Kurz .minimum_version_id = 1, 14346f7afa3SGreg Kurz .needed = pre_2_10_vmstate_dummy_icp_needed, 14446f7afa3SGreg Kurz .fields = (VMStateField[]) { 14546f7afa3SGreg Kurz VMSTATE_UNUSED(4), /* uint32_t xirr */ 14646f7afa3SGreg Kurz VMSTATE_UNUSED(1), /* uint8_t pending_priority */ 14746f7afa3SGreg Kurz VMSTATE_UNUSED(1), /* uint8_t mfrr */ 14846f7afa3SGreg Kurz VMSTATE_END_OF_LIST() 14946f7afa3SGreg Kurz }, 15046f7afa3SGreg Kurz }; 15146f7afa3SGreg Kurz 15246f7afa3SGreg Kurz static void pre_2_10_vmstate_register_dummy_icp(int i) 15346f7afa3SGreg Kurz { 15446f7afa3SGreg Kurz vmstate_register(NULL, i, &pre_2_10_vmstate_dummy_icp, 15546f7afa3SGreg Kurz (void *)(uintptr_t) i); 15646f7afa3SGreg Kurz } 15746f7afa3SGreg Kurz 15846f7afa3SGreg Kurz static void pre_2_10_vmstate_unregister_dummy_icp(int i) 15946f7afa3SGreg Kurz { 16046f7afa3SGreg Kurz vmstate_unregister(NULL, &pre_2_10_vmstate_dummy_icp, 16146f7afa3SGreg Kurz (void *)(uintptr_t) i); 16246f7afa3SGreg Kurz } 16346f7afa3SGreg Kurz 16446f7afa3SGreg Kurz static inline int xics_max_server_number(void) 16546f7afa3SGreg Kurz { 16646f7afa3SGreg Kurz return DIV_ROUND_UP(max_cpus * kvmppc_smt_threads(), smp_threads); 16746f7afa3SGreg Kurz } 16846f7afa3SGreg Kurz 16971cd4dacSCédric Le Goater static void xics_system_init(MachineState *machine, int nr_irqs, Error **errp) 170c04d6cfaSAnthony Liguori { 17171cd4dacSCédric Le Goater sPAPRMachineState *spapr = SPAPR_MACHINE(machine); 17246f7afa3SGreg Kurz sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(machine); 173c04d6cfaSAnthony Liguori 17411ad93f6SDavid Gibson if (kvm_enabled()) { 1752192a930SCédric Le Goater if (machine_kernel_irqchip_allowed(machine) && 17671cd4dacSCédric Le Goater !xics_kvm_init(spapr, errp)) { 17771cd4dacSCédric Le Goater spapr->icp_type = TYPE_KVM_ICP; 1783d85885aSGreg Kurz spapr->ics = spapr_ics_create(spapr, TYPE_ICS_KVM, nr_irqs, errp); 17911ad93f6SDavid Gibson } 18071cd4dacSCédric Le Goater if (machine_kernel_irqchip_required(machine) && !spapr->ics) { 1813d85885aSGreg Kurz error_prepend(errp, "kernel_irqchip requested but unavailable: "); 1823d85885aSGreg Kurz return; 18311ad93f6SDavid Gibson } 184b83baa60SMarkus Armbruster } 18511ad93f6SDavid Gibson 18671cd4dacSCédric Le Goater if (!spapr->ics) { 187f63ebfe0SGreg Kurz xics_spapr_init(spapr); 18871cd4dacSCédric Le Goater spapr->icp_type = TYPE_ICP; 18971cd4dacSCédric Le Goater spapr->ics = spapr_ics_create(spapr, TYPE_ICS_SIMPLE, nr_irqs, errp); 1903d85885aSGreg Kurz if (!spapr->ics) { 1913d85885aSGreg Kurz return; 1923d85885aSGreg Kurz } 193c04d6cfaSAnthony Liguori } 19446f7afa3SGreg Kurz 19546f7afa3SGreg Kurz if (smc->pre_2_10_has_unused_icps) { 19646f7afa3SGreg Kurz int i; 19746f7afa3SGreg Kurz 19846f7afa3SGreg Kurz for (i = 0; i < xics_max_server_number(); i++) { 19946f7afa3SGreg Kurz /* Dummy entries get deregistered when real ICPState objects 20046f7afa3SGreg Kurz * are registered during CPU core hotplug. 20146f7afa3SGreg Kurz */ 20246f7afa3SGreg Kurz pre_2_10_vmstate_register_dummy_icp(i); 20346f7afa3SGreg Kurz } 20446f7afa3SGreg Kurz } 205c04d6cfaSAnthony Liguori } 206c04d6cfaSAnthony Liguori 207833d4668SAlexey Kardashevskiy static int spapr_fixup_cpu_smt_dt(void *fdt, int offset, PowerPCCPU *cpu, 208833d4668SAlexey Kardashevskiy int smt_threads) 209833d4668SAlexey Kardashevskiy { 210833d4668SAlexey Kardashevskiy int i, ret = 0; 211833d4668SAlexey Kardashevskiy uint32_t servers_prop[smt_threads]; 212833d4668SAlexey Kardashevskiy uint32_t gservers_prop[smt_threads * 2]; 213833d4668SAlexey Kardashevskiy int index = ppc_get_vcpu_dt_id(cpu); 214833d4668SAlexey Kardashevskiy 215d6e166c0SDavid Gibson if (cpu->compat_pvr) { 216d6e166c0SDavid Gibson ret = fdt_setprop_cell(fdt, offset, "cpu-version", cpu->compat_pvr); 2176d9412eaSAlexey Kardashevskiy if (ret < 0) { 2186d9412eaSAlexey Kardashevskiy return ret; 2196d9412eaSAlexey Kardashevskiy } 2206d9412eaSAlexey Kardashevskiy } 2216d9412eaSAlexey Kardashevskiy 222833d4668SAlexey Kardashevskiy /* Build interrupt servers and gservers properties */ 223833d4668SAlexey Kardashevskiy for (i = 0; i < smt_threads; i++) { 224833d4668SAlexey Kardashevskiy servers_prop[i] = cpu_to_be32(index + i); 225833d4668SAlexey Kardashevskiy /* Hack, direct the group queues back to cpu 0 */ 226833d4668SAlexey Kardashevskiy gservers_prop[i*2] = cpu_to_be32(index + i); 227833d4668SAlexey Kardashevskiy gservers_prop[i*2 + 1] = 0; 228833d4668SAlexey Kardashevskiy } 229833d4668SAlexey Kardashevskiy ret = fdt_setprop(fdt, offset, "ibm,ppc-interrupt-server#s", 230833d4668SAlexey Kardashevskiy servers_prop, sizeof(servers_prop)); 231833d4668SAlexey Kardashevskiy if (ret < 0) { 232833d4668SAlexey Kardashevskiy return ret; 233833d4668SAlexey Kardashevskiy } 234833d4668SAlexey Kardashevskiy ret = fdt_setprop(fdt, offset, "ibm,ppc-interrupt-gserver#s", 235833d4668SAlexey Kardashevskiy gservers_prop, sizeof(gservers_prop)); 236833d4668SAlexey Kardashevskiy 237833d4668SAlexey Kardashevskiy return ret; 238833d4668SAlexey Kardashevskiy } 239833d4668SAlexey Kardashevskiy 24099861ecbSIgor Mammedov static int spapr_fixup_cpu_numa_dt(void *fdt, int offset, PowerPCCPU *cpu) 2410da6f3feSBharata B Rao { 2420da6f3feSBharata B Rao int index = ppc_get_vcpu_dt_id(cpu); 2430da6f3feSBharata B Rao uint32_t associativity[] = {cpu_to_be32(0x5), 2440da6f3feSBharata B Rao cpu_to_be32(0x0), 2450da6f3feSBharata B Rao cpu_to_be32(0x0), 2460da6f3feSBharata B Rao cpu_to_be32(0x0), 24715f8b142SIgor Mammedov cpu_to_be32(cpu->node_id), 2480da6f3feSBharata B Rao cpu_to_be32(index)}; 2490da6f3feSBharata B Rao 2500da6f3feSBharata B Rao /* Advertise NUMA via ibm,associativity */ 25199861ecbSIgor Mammedov return fdt_setprop(fdt, offset, "ibm,associativity", associativity, 2520da6f3feSBharata B Rao sizeof(associativity)); 2530da6f3feSBharata B Rao } 2540da6f3feSBharata B Rao 25586d5771aSSam Bobroff /* Populate the "ibm,pa-features" property */ 256e957f6a9SSam Bobroff static void spapr_populate_pa_features(CPUPPCState *env, void *fdt, int offset, 257e957f6a9SSam Bobroff bool legacy_guest) 25886d5771aSSam Bobroff { 25986d5771aSSam Bobroff uint8_t pa_features_206[] = { 6, 0, 26086d5771aSSam Bobroff 0xf6, 0x1f, 0xc7, 0x00, 0x80, 0xc0 }; 26186d5771aSSam Bobroff uint8_t pa_features_207[] = { 24, 0, 26286d5771aSSam Bobroff 0xf6, 0x1f, 0xc7, 0xc0, 0x80, 0xf0, 26386d5771aSSam Bobroff 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 26486d5771aSSam Bobroff 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 26586d5771aSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x00, 0x00 }; 2669fb4541fSSam Bobroff uint8_t pa_features_300[] = { 66, 0, 2679fb4541fSSam Bobroff /* 0: MMU|FPU|SLB|RUN|DABR|NX, 1: fri[nzpm]|DABRX|SPRG3|SLB0|PP110 */ 2689fb4541fSSam Bobroff /* 2: VPM|DS205|PPR|DS202|DS206, 3: LSD|URG, SSO, 5: LE|CFAR|EB|LSQ */ 26986d5771aSSam Bobroff 0xf6, 0x1f, 0xc7, 0xc0, 0x80, 0xf0, /* 0 - 5 */ 2709fb4541fSSam Bobroff /* 6: DS207 */ 27186d5771aSSam Bobroff 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, /* 6 - 11 */ 2729fb4541fSSam Bobroff /* 16: Vector */ 27386d5771aSSam Bobroff 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, /* 12 - 17 */ 2749fb4541fSSam Bobroff /* 18: Vec. Scalar, 20: Vec. XOR, 22: HTM */ 2759bf502feSDavid Gibson 0x80, 0x00, 0x80, 0x00, 0x00, 0x00, /* 18 - 23 */ 2769fb4541fSSam Bobroff /* 24: Ext. Dec, 26: 64 bit ftrs, 28: PM ftrs */ 2779fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, /* 24 - 29 */ 2789fb4541fSSam Bobroff /* 30: MMR, 32: LE atomic, 34: EBB + ext EBB */ 2799fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0xC0, 0x00, /* 30 - 35 */ 2809fb4541fSSam Bobroff /* 36: SPR SO, 38: Copy/Paste, 40: Radix MMU */ 2819fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, /* 36 - 41 */ 2829fb4541fSSam Bobroff /* 42: PM, 44: PC RA, 46: SC vec'd */ 2839fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, /* 42 - 47 */ 2849fb4541fSSam Bobroff /* 48: SIMD, 50: QP BFP, 52: String */ 2859fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, /* 48 - 53 */ 2869fb4541fSSam Bobroff /* 54: DecFP, 56: DecI, 58: SHA */ 2879fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, /* 54 - 59 */ 2889fb4541fSSam Bobroff /* 60: NM atomic, 62: RNG */ 2899fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x00, 0x00, /* 60 - 65 */ 2909fb4541fSSam Bobroff }; 29186d5771aSSam Bobroff uint8_t *pa_features; 29286d5771aSSam Bobroff size_t pa_size; 29386d5771aSSam Bobroff 29486d5771aSSam Bobroff switch (POWERPC_MMU_VER(env->mmu_model)) { 29586d5771aSSam Bobroff case POWERPC_MMU_VER_2_06: 29686d5771aSSam Bobroff pa_features = pa_features_206; 29786d5771aSSam Bobroff pa_size = sizeof(pa_features_206); 29886d5771aSSam Bobroff break; 29986d5771aSSam Bobroff case POWERPC_MMU_VER_2_07: 30086d5771aSSam Bobroff pa_features = pa_features_207; 30186d5771aSSam Bobroff pa_size = sizeof(pa_features_207); 30286d5771aSSam Bobroff break; 30386d5771aSSam Bobroff case POWERPC_MMU_VER_3_00: 30486d5771aSSam Bobroff pa_features = pa_features_300; 30586d5771aSSam Bobroff pa_size = sizeof(pa_features_300); 30686d5771aSSam Bobroff break; 30786d5771aSSam Bobroff default: 30886d5771aSSam Bobroff return; 30986d5771aSSam Bobroff } 31086d5771aSSam Bobroff 31186d5771aSSam Bobroff if (env->ci_large_pages) { 31286d5771aSSam Bobroff /* 31386d5771aSSam Bobroff * Note: we keep CI large pages off by default because a 64K capable 31486d5771aSSam Bobroff * guest provisioned with large pages might otherwise try to map a qemu 31586d5771aSSam Bobroff * framebuffer (or other kind of memory mapped PCI BAR) using 64K pages 31686d5771aSSam Bobroff * even if that qemu runs on a 4k host. 31786d5771aSSam Bobroff * We dd this bit back here if we are confident this is not an issue 31886d5771aSSam Bobroff */ 31986d5771aSSam Bobroff pa_features[3] |= 0x20; 32086d5771aSSam Bobroff } 32186d5771aSSam Bobroff if (kvmppc_has_cap_htm() && pa_size > 24) { 32286d5771aSSam Bobroff pa_features[24] |= 0x80; /* Transactional memory support */ 32386d5771aSSam Bobroff } 324e957f6a9SSam Bobroff if (legacy_guest && pa_size > 40) { 325e957f6a9SSam Bobroff /* Workaround for broken kernels that attempt (guest) radix 326e957f6a9SSam Bobroff * mode when they can't handle it, if they see the radix bit set 327e957f6a9SSam Bobroff * in pa-features. So hide it from them. */ 328e957f6a9SSam Bobroff pa_features[40 + 2] &= ~0x80; /* Radix MMU */ 329e957f6a9SSam Bobroff } 33086d5771aSSam Bobroff 33186d5771aSSam Bobroff _FDT((fdt_setprop(fdt, offset, "ibm,pa-features", pa_features, pa_size))); 33286d5771aSSam Bobroff } 33386d5771aSSam Bobroff 33428e02042SDavid Gibson static int spapr_fixup_cpu_dt(void *fdt, sPAPRMachineState *spapr) 33553018216SPaolo Bonzini { 33682677ed2SAlexey Kardashevskiy int ret = 0, offset, cpus_offset; 33782677ed2SAlexey Kardashevskiy CPUState *cs; 33853018216SPaolo Bonzini char cpu_model[32]; 33953018216SPaolo Bonzini int smt = kvmppc_smt_threads(); 34053018216SPaolo Bonzini uint32_t pft_size_prop[] = {0, cpu_to_be32(spapr->htab_shift)}; 34153018216SPaolo Bonzini 34282677ed2SAlexey Kardashevskiy CPU_FOREACH(cs) { 34382677ed2SAlexey Kardashevskiy PowerPCCPU *cpu = POWERPC_CPU(cs); 344e957f6a9SSam Bobroff CPUPPCState *env = &cpu->env; 34582677ed2SAlexey Kardashevskiy DeviceClass *dc = DEVICE_GET_CLASS(cs); 34682677ed2SAlexey Kardashevskiy int index = ppc_get_vcpu_dt_id(cpu); 34712dbeb16SDavid Gibson int compat_smt = MIN(smp_threads, ppc_compat_max_threads(cpu)); 34853018216SPaolo Bonzini 3490f20ba62SAlexey Kardashevskiy if ((index % smt) != 0) { 35053018216SPaolo Bonzini continue; 35153018216SPaolo Bonzini } 35253018216SPaolo Bonzini 35382677ed2SAlexey Kardashevskiy snprintf(cpu_model, 32, "%s@%x", dc->fw_name, index); 35453018216SPaolo Bonzini 35582677ed2SAlexey Kardashevskiy cpus_offset = fdt_path_offset(fdt, "/cpus"); 35682677ed2SAlexey Kardashevskiy if (cpus_offset < 0) { 35782677ed2SAlexey Kardashevskiy cpus_offset = fdt_add_subnode(fdt, fdt_path_offset(fdt, "/"), 35882677ed2SAlexey Kardashevskiy "cpus"); 35982677ed2SAlexey Kardashevskiy if (cpus_offset < 0) { 36082677ed2SAlexey Kardashevskiy return cpus_offset; 36182677ed2SAlexey Kardashevskiy } 36282677ed2SAlexey Kardashevskiy } 36382677ed2SAlexey Kardashevskiy offset = fdt_subnode_offset(fdt, cpus_offset, cpu_model); 36482677ed2SAlexey Kardashevskiy if (offset < 0) { 36582677ed2SAlexey Kardashevskiy offset = fdt_add_subnode(fdt, cpus_offset, cpu_model); 36653018216SPaolo Bonzini if (offset < 0) { 36753018216SPaolo Bonzini return offset; 36853018216SPaolo Bonzini } 36982677ed2SAlexey Kardashevskiy } 37053018216SPaolo Bonzini 3710da6f3feSBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,pft-size", 3720da6f3feSBharata B Rao pft_size_prop, sizeof(pft_size_prop)); 37353018216SPaolo Bonzini if (ret < 0) { 37453018216SPaolo Bonzini return ret; 37553018216SPaolo Bonzini } 37653018216SPaolo Bonzini 37799861ecbSIgor Mammedov if (nb_numa_nodes > 1) { 37899861ecbSIgor Mammedov ret = spapr_fixup_cpu_numa_dt(fdt, offset, cpu); 37953018216SPaolo Bonzini if (ret < 0) { 38053018216SPaolo Bonzini return ret; 38153018216SPaolo Bonzini } 38299861ecbSIgor Mammedov } 383833d4668SAlexey Kardashevskiy 38412dbeb16SDavid Gibson ret = spapr_fixup_cpu_smt_dt(fdt, offset, cpu, compat_smt); 385833d4668SAlexey Kardashevskiy if (ret < 0) { 386833d4668SAlexey Kardashevskiy return ret; 387833d4668SAlexey Kardashevskiy } 388e957f6a9SSam Bobroff 389e957f6a9SSam Bobroff spapr_populate_pa_features(env, fdt, offset, 390e957f6a9SSam Bobroff spapr->cas_legacy_guest_workaround); 39153018216SPaolo Bonzini } 39253018216SPaolo Bonzini return ret; 39353018216SPaolo Bonzini } 39453018216SPaolo Bonzini 395b082d65aSAlexey Kardashevskiy static hwaddr spapr_node0_size(void) 396b082d65aSAlexey Kardashevskiy { 397fb164994SDavid Gibson MachineState *machine = MACHINE(qdev_get_machine()); 398fb164994SDavid Gibson 399b082d65aSAlexey Kardashevskiy if (nb_numa_nodes) { 400b082d65aSAlexey Kardashevskiy int i; 401b082d65aSAlexey Kardashevskiy for (i = 0; i < nb_numa_nodes; ++i) { 402b082d65aSAlexey Kardashevskiy if (numa_info[i].node_mem) { 403fb164994SDavid Gibson return MIN(pow2floor(numa_info[i].node_mem), 404fb164994SDavid Gibson machine->ram_size); 405b082d65aSAlexey Kardashevskiy } 406b082d65aSAlexey Kardashevskiy } 407b082d65aSAlexey Kardashevskiy } 408fb164994SDavid Gibson return machine->ram_size; 409b082d65aSAlexey Kardashevskiy } 410b082d65aSAlexey Kardashevskiy 411a1d59c0fSAlexey Kardashevskiy static void add_str(GString *s, const gchar *s1) 412a1d59c0fSAlexey Kardashevskiy { 413a1d59c0fSAlexey Kardashevskiy g_string_append_len(s, s1, strlen(s1) + 1); 414a1d59c0fSAlexey Kardashevskiy } 41553018216SPaolo Bonzini 41603d196b7SBharata B Rao static int spapr_populate_memory_node(void *fdt, int nodeid, hwaddr start, 41726a8c353SAlexey Kardashevskiy hwaddr size) 41826a8c353SAlexey Kardashevskiy { 41926a8c353SAlexey Kardashevskiy uint32_t associativity[] = { 42026a8c353SAlexey Kardashevskiy cpu_to_be32(0x4), /* length */ 42126a8c353SAlexey Kardashevskiy cpu_to_be32(0x0), cpu_to_be32(0x0), 422c3b4f589SAlexey Kardashevskiy cpu_to_be32(0x0), cpu_to_be32(nodeid) 42326a8c353SAlexey Kardashevskiy }; 42426a8c353SAlexey Kardashevskiy char mem_name[32]; 42526a8c353SAlexey Kardashevskiy uint64_t mem_reg_property[2]; 42626a8c353SAlexey Kardashevskiy int off; 42726a8c353SAlexey Kardashevskiy 42826a8c353SAlexey Kardashevskiy mem_reg_property[0] = cpu_to_be64(start); 42926a8c353SAlexey Kardashevskiy mem_reg_property[1] = cpu_to_be64(size); 43026a8c353SAlexey Kardashevskiy 43126a8c353SAlexey Kardashevskiy sprintf(mem_name, "memory@" TARGET_FMT_lx, start); 43226a8c353SAlexey Kardashevskiy off = fdt_add_subnode(fdt, 0, mem_name); 43326a8c353SAlexey Kardashevskiy _FDT(off); 43426a8c353SAlexey Kardashevskiy _FDT((fdt_setprop_string(fdt, off, "device_type", "memory"))); 43526a8c353SAlexey Kardashevskiy _FDT((fdt_setprop(fdt, off, "reg", mem_reg_property, 43626a8c353SAlexey Kardashevskiy sizeof(mem_reg_property)))); 43726a8c353SAlexey Kardashevskiy _FDT((fdt_setprop(fdt, off, "ibm,associativity", associativity, 43826a8c353SAlexey Kardashevskiy sizeof(associativity)))); 43903d196b7SBharata B Rao return off; 44026a8c353SAlexey Kardashevskiy } 44126a8c353SAlexey Kardashevskiy 44228e02042SDavid Gibson static int spapr_populate_memory(sPAPRMachineState *spapr, void *fdt) 44353018216SPaolo Bonzini { 444fb164994SDavid Gibson MachineState *machine = MACHINE(spapr); 4457db8a127SAlexey Kardashevskiy hwaddr mem_start, node_size; 4467db8a127SAlexey Kardashevskiy int i, nb_nodes = nb_numa_nodes; 4477db8a127SAlexey Kardashevskiy NodeInfo *nodes = numa_info; 4487db8a127SAlexey Kardashevskiy NodeInfo ramnode; 44953018216SPaolo Bonzini 4507db8a127SAlexey Kardashevskiy /* No NUMA nodes, assume there is just one node with whole RAM */ 4517db8a127SAlexey Kardashevskiy if (!nb_numa_nodes) { 4527db8a127SAlexey Kardashevskiy nb_nodes = 1; 453fb164994SDavid Gibson ramnode.node_mem = machine->ram_size; 4547db8a127SAlexey Kardashevskiy nodes = &ramnode; 4555fe269b1SPaul Mackerras } 45653018216SPaolo Bonzini 4577db8a127SAlexey Kardashevskiy for (i = 0, mem_start = 0; i < nb_nodes; ++i) { 4587db8a127SAlexey Kardashevskiy if (!nodes[i].node_mem) { 4597db8a127SAlexey Kardashevskiy continue; 46053018216SPaolo Bonzini } 461fb164994SDavid Gibson if (mem_start >= machine->ram_size) { 4625fe269b1SPaul Mackerras node_size = 0; 4635fe269b1SPaul Mackerras } else { 4647db8a127SAlexey Kardashevskiy node_size = nodes[i].node_mem; 465fb164994SDavid Gibson if (node_size > machine->ram_size - mem_start) { 466fb164994SDavid Gibson node_size = machine->ram_size - mem_start; 4675fe269b1SPaul Mackerras } 4685fe269b1SPaul Mackerras } 4697db8a127SAlexey Kardashevskiy if (!mem_start) { 4707db8a127SAlexey Kardashevskiy /* ppc_spapr_init() checks for rma_size <= node0_size already */ 471e8f986fcSBharata B Rao spapr_populate_memory_node(fdt, i, 0, spapr->rma_size); 4727db8a127SAlexey Kardashevskiy mem_start += spapr->rma_size; 4737db8a127SAlexey Kardashevskiy node_size -= spapr->rma_size; 4747db8a127SAlexey Kardashevskiy } 4756010818cSAlexey Kardashevskiy for ( ; node_size; ) { 4766010818cSAlexey Kardashevskiy hwaddr sizetmp = pow2floor(node_size); 4776010818cSAlexey Kardashevskiy 4786010818cSAlexey Kardashevskiy /* mem_start != 0 here */ 4796010818cSAlexey Kardashevskiy if (ctzl(mem_start) < ctzl(sizetmp)) { 4806010818cSAlexey Kardashevskiy sizetmp = 1ULL << ctzl(mem_start); 4816010818cSAlexey Kardashevskiy } 4826010818cSAlexey Kardashevskiy 4836010818cSAlexey Kardashevskiy spapr_populate_memory_node(fdt, i, mem_start, sizetmp); 4846010818cSAlexey Kardashevskiy node_size -= sizetmp; 4856010818cSAlexey Kardashevskiy mem_start += sizetmp; 4866010818cSAlexey Kardashevskiy } 48753018216SPaolo Bonzini } 48853018216SPaolo Bonzini 48953018216SPaolo Bonzini return 0; 49053018216SPaolo Bonzini } 49153018216SPaolo Bonzini 4920da6f3feSBharata B Rao static void spapr_populate_cpu_dt(CPUState *cs, void *fdt, int offset, 4930da6f3feSBharata B Rao sPAPRMachineState *spapr) 4940da6f3feSBharata B Rao { 4950da6f3feSBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(cs); 4960da6f3feSBharata B Rao CPUPPCState *env = &cpu->env; 4970da6f3feSBharata B Rao PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(cs); 4980da6f3feSBharata B Rao int index = ppc_get_vcpu_dt_id(cpu); 4990da6f3feSBharata B Rao uint32_t segs[] = {cpu_to_be32(28), cpu_to_be32(40), 5000da6f3feSBharata B Rao 0xffffffff, 0xffffffff}; 501afd10a0fSBharata B Rao uint32_t tbfreq = kvm_enabled() ? kvmppc_get_tbfreq() 502afd10a0fSBharata B Rao : SPAPR_TIMEBASE_FREQ; 5030da6f3feSBharata B Rao uint32_t cpufreq = kvm_enabled() ? kvmppc_get_clockfreq() : 1000000000; 5040da6f3feSBharata B Rao uint32_t page_sizes_prop[64]; 5050da6f3feSBharata B Rao size_t page_sizes_prop_size; 50622419c2aSDavid Gibson uint32_t vcpus_per_socket = smp_threads * smp_cores; 5070da6f3feSBharata B Rao uint32_t pft_size_prop[] = {0, cpu_to_be32(spapr->htab_shift)}; 50812dbeb16SDavid Gibson int compat_smt = MIN(smp_threads, ppc_compat_max_threads(cpu)); 509af81cf32SBharata B Rao sPAPRDRConnector *drc; 510af81cf32SBharata B Rao int drc_index; 511c64abd1fSSam Bobroff uint32_t radix_AP_encodings[PPC_PAGE_SIZES_MAX_SZ]; 512c64abd1fSSam Bobroff int i; 513af81cf32SBharata B Rao 514fbf55397SDavid Gibson drc = spapr_drc_by_id(TYPE_SPAPR_DRC_CPU, index); 515af81cf32SBharata B Rao if (drc) { 5160b55aa91SDavid Gibson drc_index = spapr_drc_index(drc); 517af81cf32SBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,my-drc-index", drc_index))); 518af81cf32SBharata B Rao } 5190da6f3feSBharata B Rao 5200da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "reg", index))); 5210da6f3feSBharata B Rao _FDT((fdt_setprop_string(fdt, offset, "device_type", "cpu"))); 5220da6f3feSBharata B Rao 5230da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "cpu-version", env->spr[SPR_PVR]))); 5240da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "d-cache-block-size", 5250da6f3feSBharata B Rao env->dcache_line_size))); 5260da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "d-cache-line-size", 5270da6f3feSBharata B Rao env->dcache_line_size))); 5280da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "i-cache-block-size", 5290da6f3feSBharata B Rao env->icache_line_size))); 5300da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "i-cache-line-size", 5310da6f3feSBharata B Rao env->icache_line_size))); 5320da6f3feSBharata B Rao 5330da6f3feSBharata B Rao if (pcc->l1_dcache_size) { 5340da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "d-cache-size", 5350da6f3feSBharata B Rao pcc->l1_dcache_size))); 5360da6f3feSBharata B Rao } else { 5373dc6f869SAlistair Francis warn_report("Unknown L1 dcache size for cpu"); 5380da6f3feSBharata B Rao } 5390da6f3feSBharata B Rao if (pcc->l1_icache_size) { 5400da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "i-cache-size", 5410da6f3feSBharata B Rao pcc->l1_icache_size))); 5420da6f3feSBharata B Rao } else { 5433dc6f869SAlistair Francis warn_report("Unknown L1 icache size for cpu"); 5440da6f3feSBharata B Rao } 5450da6f3feSBharata B Rao 5460da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "timebase-frequency", tbfreq))); 5470da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "clock-frequency", cpufreq))); 548fd5da5c4SThomas Huth _FDT((fdt_setprop_cell(fdt, offset, "slb-size", env->slb_nr))); 5490da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,slb-size", env->slb_nr))); 5500da6f3feSBharata B Rao _FDT((fdt_setprop_string(fdt, offset, "status", "okay"))); 5510da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "64-bit", NULL, 0))); 5520da6f3feSBharata B Rao 5530da6f3feSBharata B Rao if (env->spr_cb[SPR_PURR].oea_read) { 5540da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,purr", NULL, 0))); 5550da6f3feSBharata B Rao } 5560da6f3feSBharata B Rao 5570da6f3feSBharata B Rao if (env->mmu_model & POWERPC_MMU_1TSEG) { 5580da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,processor-segment-sizes", 5590da6f3feSBharata B Rao segs, sizeof(segs)))); 5600da6f3feSBharata B Rao } 5610da6f3feSBharata B Rao 5620da6f3feSBharata B Rao /* Advertise VMX/VSX (vector extensions) if available 5630da6f3feSBharata B Rao * 0 / no property == no vector extensions 5640da6f3feSBharata B Rao * 1 == VMX / Altivec available 5650da6f3feSBharata B Rao * 2 == VSX available */ 5660da6f3feSBharata B Rao if (env->insns_flags & PPC_ALTIVEC) { 5670da6f3feSBharata B Rao uint32_t vmx = (env->insns_flags2 & PPC2_VSX) ? 2 : 1; 5680da6f3feSBharata B Rao 5690da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,vmx", vmx))); 5700da6f3feSBharata B Rao } 5710da6f3feSBharata B Rao 5720da6f3feSBharata B Rao /* Advertise DFP (Decimal Floating Point) if available 5730da6f3feSBharata B Rao * 0 / no property == no DFP 5740da6f3feSBharata B Rao * 1 == DFP available */ 5750da6f3feSBharata B Rao if (env->insns_flags2 & PPC2_DFP) { 5760da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,dfp", 1))); 5770da6f3feSBharata B Rao } 5780da6f3feSBharata B Rao 5793654fa95SCédric Le Goater page_sizes_prop_size = ppc_create_page_sizes_prop(env, page_sizes_prop, 5800da6f3feSBharata B Rao sizeof(page_sizes_prop)); 5810da6f3feSBharata B Rao if (page_sizes_prop_size) { 5820da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,segment-page-sizes", 5830da6f3feSBharata B Rao page_sizes_prop, page_sizes_prop_size))); 5840da6f3feSBharata B Rao } 5850da6f3feSBharata B Rao 586e957f6a9SSam Bobroff spapr_populate_pa_features(env, fdt, offset, false); 58790da0d5aSBenjamin Herrenschmidt 5880da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,chip-id", 58922419c2aSDavid Gibson cs->cpu_index / vcpus_per_socket))); 5900da6f3feSBharata B Rao 5910da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,pft-size", 5920da6f3feSBharata B Rao pft_size_prop, sizeof(pft_size_prop)))); 5930da6f3feSBharata B Rao 59499861ecbSIgor Mammedov if (nb_numa_nodes > 1) { 59599861ecbSIgor Mammedov _FDT(spapr_fixup_cpu_numa_dt(fdt, offset, cpu)); 59699861ecbSIgor Mammedov } 5970da6f3feSBharata B Rao 59812dbeb16SDavid Gibson _FDT(spapr_fixup_cpu_smt_dt(fdt, offset, cpu, compat_smt)); 599c64abd1fSSam Bobroff 600c64abd1fSSam Bobroff if (pcc->radix_page_info) { 601c64abd1fSSam Bobroff for (i = 0; i < pcc->radix_page_info->count; i++) { 602c64abd1fSSam Bobroff radix_AP_encodings[i] = 603c64abd1fSSam Bobroff cpu_to_be32(pcc->radix_page_info->entries[i]); 604c64abd1fSSam Bobroff } 605c64abd1fSSam Bobroff _FDT((fdt_setprop(fdt, offset, "ibm,processor-radix-AP-encodings", 606c64abd1fSSam Bobroff radix_AP_encodings, 607c64abd1fSSam Bobroff pcc->radix_page_info->count * 608c64abd1fSSam Bobroff sizeof(radix_AP_encodings[0])))); 609c64abd1fSSam Bobroff } 6100da6f3feSBharata B Rao } 6110da6f3feSBharata B Rao 6120da6f3feSBharata B Rao static void spapr_populate_cpus_dt_node(void *fdt, sPAPRMachineState *spapr) 6130da6f3feSBharata B Rao { 6140da6f3feSBharata B Rao CPUState *cs; 6150da6f3feSBharata B Rao int cpus_offset; 6160da6f3feSBharata B Rao char *nodename; 6170da6f3feSBharata B Rao int smt = kvmppc_smt_threads(); 6180da6f3feSBharata B Rao 6190da6f3feSBharata B Rao cpus_offset = fdt_add_subnode(fdt, 0, "cpus"); 6200da6f3feSBharata B Rao _FDT(cpus_offset); 6210da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, cpus_offset, "#address-cells", 0x1))); 6220da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, cpus_offset, "#size-cells", 0x0))); 6230da6f3feSBharata B Rao 6240da6f3feSBharata B Rao /* 6250da6f3feSBharata B Rao * We walk the CPUs in reverse order to ensure that CPU DT nodes 6260da6f3feSBharata B Rao * created by fdt_add_subnode() end up in the right order in FDT 6270da6f3feSBharata B Rao * for the guest kernel the enumerate the CPUs correctly. 6280da6f3feSBharata B Rao */ 6290da6f3feSBharata B Rao CPU_FOREACH_REVERSE(cs) { 6300da6f3feSBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(cs); 6310da6f3feSBharata B Rao int index = ppc_get_vcpu_dt_id(cpu); 6320da6f3feSBharata B Rao DeviceClass *dc = DEVICE_GET_CLASS(cs); 6330da6f3feSBharata B Rao int offset; 6340da6f3feSBharata B Rao 6350da6f3feSBharata B Rao if ((index % smt) != 0) { 6360da6f3feSBharata B Rao continue; 6370da6f3feSBharata B Rao } 6380da6f3feSBharata B Rao 6390da6f3feSBharata B Rao nodename = g_strdup_printf("%s@%x", dc->fw_name, index); 6400da6f3feSBharata B Rao offset = fdt_add_subnode(fdt, cpus_offset, nodename); 6410da6f3feSBharata B Rao g_free(nodename); 6420da6f3feSBharata B Rao _FDT(offset); 6430da6f3feSBharata B Rao spapr_populate_cpu_dt(cs, fdt, offset, spapr); 6440da6f3feSBharata B Rao } 6450da6f3feSBharata B Rao 6460da6f3feSBharata B Rao } 6470da6f3feSBharata B Rao 64803d196b7SBharata B Rao /* 64903d196b7SBharata B Rao * Adds ibm,dynamic-reconfiguration-memory node. 65003d196b7SBharata B Rao * Refer to docs/specs/ppc-spapr-hotplug.txt for the documentation 65103d196b7SBharata B Rao * of this device tree node. 65203d196b7SBharata B Rao */ 65303d196b7SBharata B Rao static int spapr_populate_drconf_memory(sPAPRMachineState *spapr, void *fdt) 65403d196b7SBharata B Rao { 65503d196b7SBharata B Rao MachineState *machine = MACHINE(spapr); 65603d196b7SBharata B Rao int ret, i, offset; 65703d196b7SBharata B Rao uint64_t lmb_size = SPAPR_MEMORY_BLOCK_SIZE; 65803d196b7SBharata B Rao uint32_t prop_lmb_size[] = {0, cpu_to_be32(lmb_size)}; 659d0e5a8f2SBharata B Rao uint32_t hotplug_lmb_start = spapr->hotplug_memory.base / lmb_size; 660d0e5a8f2SBharata B Rao uint32_t nr_lmbs = (spapr->hotplug_memory.base + 661d0e5a8f2SBharata B Rao memory_region_size(&spapr->hotplug_memory.mr)) / 662d0e5a8f2SBharata B Rao lmb_size; 66303d196b7SBharata B Rao uint32_t *int_buf, *cur_index, buf_len; 6646663864eSBharata B Rao int nr_nodes = nb_numa_nodes ? nb_numa_nodes : 1; 66503d196b7SBharata B Rao 666ef001f06SThomas Huth /* 667d0e5a8f2SBharata B Rao * Don't create the node if there is no hotpluggable memory 66816c25aefSBharata B Rao */ 669d0e5a8f2SBharata B Rao if (machine->ram_size == machine->maxram_size) { 67016c25aefSBharata B Rao return 0; 67116c25aefSBharata B Rao } 67216c25aefSBharata B Rao 67316c25aefSBharata B Rao /* 674ef001f06SThomas Huth * Allocate enough buffer size to fit in ibm,dynamic-memory 675ef001f06SThomas Huth * or ibm,associativity-lookup-arrays 676ef001f06SThomas Huth */ 677ef001f06SThomas Huth buf_len = MAX(nr_lmbs * SPAPR_DR_LMB_LIST_ENTRY_SIZE + 1, nr_nodes * 4 + 2) 678ef001f06SThomas Huth * sizeof(uint32_t); 67903d196b7SBharata B Rao cur_index = int_buf = g_malloc0(buf_len); 68003d196b7SBharata B Rao 68103d196b7SBharata B Rao offset = fdt_add_subnode(fdt, 0, "ibm,dynamic-reconfiguration-memory"); 68203d196b7SBharata B Rao 68303d196b7SBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,lmb-size", prop_lmb_size, 68403d196b7SBharata B Rao sizeof(prop_lmb_size)); 68503d196b7SBharata B Rao if (ret < 0) { 68603d196b7SBharata B Rao goto out; 68703d196b7SBharata B Rao } 68803d196b7SBharata B Rao 68903d196b7SBharata B Rao ret = fdt_setprop_cell(fdt, offset, "ibm,memory-flags-mask", 0xff); 69003d196b7SBharata B Rao if (ret < 0) { 69103d196b7SBharata B Rao goto out; 69203d196b7SBharata B Rao } 69303d196b7SBharata B Rao 69403d196b7SBharata B Rao ret = fdt_setprop_cell(fdt, offset, "ibm,memory-preservation-time", 0x0); 69503d196b7SBharata B Rao if (ret < 0) { 69603d196b7SBharata B Rao goto out; 69703d196b7SBharata B Rao } 69803d196b7SBharata B Rao 69903d196b7SBharata B Rao /* ibm,dynamic-memory */ 70003d196b7SBharata B Rao int_buf[0] = cpu_to_be32(nr_lmbs); 70103d196b7SBharata B Rao cur_index++; 70203d196b7SBharata B Rao for (i = 0; i < nr_lmbs; i++) { 703d0e5a8f2SBharata B Rao uint64_t addr = i * lmb_size; 70403d196b7SBharata B Rao uint32_t *dynamic_memory = cur_index; 70503d196b7SBharata B Rao 706d0e5a8f2SBharata B Rao if (i >= hotplug_lmb_start) { 707d0e5a8f2SBharata B Rao sPAPRDRConnector *drc; 708d0e5a8f2SBharata B Rao 709fbf55397SDavid Gibson drc = spapr_drc_by_id(TYPE_SPAPR_DRC_LMB, i); 71003d196b7SBharata B Rao g_assert(drc); 71103d196b7SBharata B Rao 71203d196b7SBharata B Rao dynamic_memory[0] = cpu_to_be32(addr >> 32); 71303d196b7SBharata B Rao dynamic_memory[1] = cpu_to_be32(addr & 0xffffffff); 7140b55aa91SDavid Gibson dynamic_memory[2] = cpu_to_be32(spapr_drc_index(drc)); 71503d196b7SBharata B Rao dynamic_memory[3] = cpu_to_be32(0); /* reserved */ 71603d196b7SBharata B Rao dynamic_memory[4] = cpu_to_be32(numa_get_node(addr, NULL)); 717d0e5a8f2SBharata B Rao if (memory_region_present(get_system_memory(), addr)) { 71803d196b7SBharata B Rao dynamic_memory[5] = cpu_to_be32(SPAPR_LMB_FLAGS_ASSIGNED); 71903d196b7SBharata B Rao } else { 72003d196b7SBharata B Rao dynamic_memory[5] = cpu_to_be32(0); 72103d196b7SBharata B Rao } 722d0e5a8f2SBharata B Rao } else { 723d0e5a8f2SBharata B Rao /* 724d0e5a8f2SBharata B Rao * LMB information for RMA, boot time RAM and gap b/n RAM and 725d0e5a8f2SBharata B Rao * hotplug memory region -- all these are marked as reserved 726d0e5a8f2SBharata B Rao * and as having no valid DRC. 727d0e5a8f2SBharata B Rao */ 728d0e5a8f2SBharata B Rao dynamic_memory[0] = cpu_to_be32(addr >> 32); 729d0e5a8f2SBharata B Rao dynamic_memory[1] = cpu_to_be32(addr & 0xffffffff); 730d0e5a8f2SBharata B Rao dynamic_memory[2] = cpu_to_be32(0); 731d0e5a8f2SBharata B Rao dynamic_memory[3] = cpu_to_be32(0); /* reserved */ 732d0e5a8f2SBharata B Rao dynamic_memory[4] = cpu_to_be32(-1); 733d0e5a8f2SBharata B Rao dynamic_memory[5] = cpu_to_be32(SPAPR_LMB_FLAGS_RESERVED | 734d0e5a8f2SBharata B Rao SPAPR_LMB_FLAGS_DRC_INVALID); 735d0e5a8f2SBharata B Rao } 73603d196b7SBharata B Rao 73703d196b7SBharata B Rao cur_index += SPAPR_DR_LMB_LIST_ENTRY_SIZE; 73803d196b7SBharata B Rao } 73903d196b7SBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,dynamic-memory", int_buf, buf_len); 74003d196b7SBharata B Rao if (ret < 0) { 74103d196b7SBharata B Rao goto out; 74203d196b7SBharata B Rao } 74303d196b7SBharata B Rao 74403d196b7SBharata B Rao /* ibm,associativity-lookup-arrays */ 74503d196b7SBharata B Rao cur_index = int_buf; 7466663864eSBharata B Rao int_buf[0] = cpu_to_be32(nr_nodes); 74703d196b7SBharata B Rao int_buf[1] = cpu_to_be32(4); /* Number of entries per associativity list */ 74803d196b7SBharata B Rao cur_index += 2; 7496663864eSBharata B Rao for (i = 0; i < nr_nodes; i++) { 75003d196b7SBharata B Rao uint32_t associativity[] = { 75103d196b7SBharata B Rao cpu_to_be32(0x0), 75203d196b7SBharata B Rao cpu_to_be32(0x0), 75303d196b7SBharata B Rao cpu_to_be32(0x0), 75403d196b7SBharata B Rao cpu_to_be32(i) 75503d196b7SBharata B Rao }; 75603d196b7SBharata B Rao memcpy(cur_index, associativity, sizeof(associativity)); 75703d196b7SBharata B Rao cur_index += 4; 75803d196b7SBharata B Rao } 75903d196b7SBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,associativity-lookup-arrays", int_buf, 76003d196b7SBharata B Rao (cur_index - int_buf) * sizeof(uint32_t)); 76103d196b7SBharata B Rao out: 76203d196b7SBharata B Rao g_free(int_buf); 76303d196b7SBharata B Rao return ret; 76403d196b7SBharata B Rao } 76503d196b7SBharata B Rao 7666787d27bSMichael Roth static int spapr_dt_cas_updates(sPAPRMachineState *spapr, void *fdt, 7676787d27bSMichael Roth sPAPROptionVector *ov5_updates) 7686787d27bSMichael Roth { 7696787d27bSMichael Roth sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(spapr); 770417ece33SMichael Roth int ret = 0, offset; 7716787d27bSMichael Roth 7726787d27bSMichael Roth /* Generate ibm,dynamic-reconfiguration-memory node if required */ 7736787d27bSMichael Roth if (spapr_ovec_test(ov5_updates, OV5_DRCONF_MEMORY)) { 7746787d27bSMichael Roth g_assert(smc->dr_lmb_enabled); 7756787d27bSMichael Roth ret = spapr_populate_drconf_memory(spapr, fdt); 776417ece33SMichael Roth if (ret) { 777417ece33SMichael Roth goto out; 778417ece33SMichael Roth } 7796787d27bSMichael Roth } 7806787d27bSMichael Roth 781b8768042SCédric Le Goater /* /interrupt controller */ 782b8768042SCédric Le Goater if (!spapr_ovec_test(ov5_updates, OV5_XIVE_EXPLOIT)) { 783b8768042SCédric Le Goater spapr_dt_xics(xics_max_server_number(), fdt, PHANDLE_XICP); 784b8768042SCédric Le Goater } 785b8768042SCédric Le Goater 786417ece33SMichael Roth offset = fdt_path_offset(fdt, "/chosen"); 787417ece33SMichael Roth if (offset < 0) { 788417ece33SMichael Roth offset = fdt_add_subnode(fdt, 0, "chosen"); 789417ece33SMichael Roth if (offset < 0) { 790417ece33SMichael Roth return offset; 791417ece33SMichael Roth } 792417ece33SMichael Roth } 793417ece33SMichael Roth ret = spapr_ovec_populate_dt(fdt, offset, spapr->ov5_cas, 794417ece33SMichael Roth "ibm,architecture-vec-5"); 795417ece33SMichael Roth 796417ece33SMichael Roth out: 7976787d27bSMichael Roth return ret; 7986787d27bSMichael Roth } 7996787d27bSMichael Roth 80003d196b7SBharata B Rao int spapr_h_cas_compose_response(sPAPRMachineState *spapr, 80103d196b7SBharata B Rao target_ulong addr, target_ulong size, 8026787d27bSMichael Roth sPAPROptionVector *ov5_updates) 80303d196b7SBharata B Rao { 80403d196b7SBharata B Rao void *fdt, *fdt_skel; 80503d196b7SBharata B Rao sPAPRDeviceTreeUpdateHeader hdr = { .version_id = 1 }; 80603d196b7SBharata B Rao 80703d196b7SBharata B Rao size -= sizeof(hdr); 80803d196b7SBharata B Rao 809b8768042SCédric Le Goater /* Create skeleton */ 81003d196b7SBharata B Rao fdt_skel = g_malloc0(size); 81103d196b7SBharata B Rao _FDT((fdt_create(fdt_skel, size))); 81203d196b7SBharata B Rao _FDT((fdt_begin_node(fdt_skel, ""))); 81303d196b7SBharata B Rao _FDT((fdt_end_node(fdt_skel))); 81403d196b7SBharata B Rao _FDT((fdt_finish(fdt_skel))); 81503d196b7SBharata B Rao fdt = g_malloc0(size); 81603d196b7SBharata B Rao _FDT((fdt_open_into(fdt_skel, fdt, size))); 81703d196b7SBharata B Rao g_free(fdt_skel); 81803d196b7SBharata B Rao 81903d196b7SBharata B Rao /* Fixup cpu nodes */ 82003d196b7SBharata B Rao _FDT((spapr_fixup_cpu_dt(fdt, spapr))); 82103d196b7SBharata B Rao 8226787d27bSMichael Roth if (spapr_dt_cas_updates(spapr, fdt, ov5_updates)) { 8236787d27bSMichael Roth return -1; 82403d196b7SBharata B Rao } 82503d196b7SBharata B Rao 82603d196b7SBharata B Rao /* Pack resulting tree */ 82703d196b7SBharata B Rao _FDT((fdt_pack(fdt))); 82803d196b7SBharata B Rao 82903d196b7SBharata B Rao if (fdt_totalsize(fdt) + sizeof(hdr) > size) { 83003d196b7SBharata B Rao trace_spapr_cas_failed(size); 83103d196b7SBharata B Rao return -1; 83203d196b7SBharata B Rao } 83303d196b7SBharata B Rao 83403d196b7SBharata B Rao cpu_physical_memory_write(addr, &hdr, sizeof(hdr)); 83503d196b7SBharata B Rao cpu_physical_memory_write(addr + sizeof(hdr), fdt, fdt_totalsize(fdt)); 83603d196b7SBharata B Rao trace_spapr_cas_continue(fdt_totalsize(fdt) + sizeof(hdr)); 83703d196b7SBharata B Rao g_free(fdt); 83803d196b7SBharata B Rao 83903d196b7SBharata B Rao return 0; 84003d196b7SBharata B Rao } 84103d196b7SBharata B Rao 8423f5dabceSDavid Gibson static void spapr_dt_rtas(sPAPRMachineState *spapr, void *fdt) 8433f5dabceSDavid Gibson { 8443f5dabceSDavid Gibson int rtas; 8453f5dabceSDavid Gibson GString *hypertas = g_string_sized_new(256); 8463f5dabceSDavid Gibson GString *qemu_hypertas = g_string_sized_new(256); 8473f5dabceSDavid Gibson uint32_t refpoints[] = { cpu_to_be32(0x4), cpu_to_be32(0x4) }; 8483f5dabceSDavid Gibson uint64_t max_hotplug_addr = spapr->hotplug_memory.base + 8493f5dabceSDavid Gibson memory_region_size(&spapr->hotplug_memory.mr); 8503f5dabceSDavid Gibson uint32_t lrdr_capacity[] = { 8513f5dabceSDavid Gibson cpu_to_be32(max_hotplug_addr >> 32), 8523f5dabceSDavid Gibson cpu_to_be32(max_hotplug_addr & 0xffffffff), 8533f5dabceSDavid Gibson 0, cpu_to_be32(SPAPR_MEMORY_BLOCK_SIZE), 8543f5dabceSDavid Gibson cpu_to_be32(max_cpus / smp_threads), 8553f5dabceSDavid Gibson }; 8563f5dabceSDavid Gibson 8573f5dabceSDavid Gibson _FDT(rtas = fdt_add_subnode(fdt, 0, "rtas")); 8583f5dabceSDavid Gibson 8593f5dabceSDavid Gibson /* hypertas */ 8603f5dabceSDavid Gibson add_str(hypertas, "hcall-pft"); 8613f5dabceSDavid Gibson add_str(hypertas, "hcall-term"); 8623f5dabceSDavid Gibson add_str(hypertas, "hcall-dabr"); 8633f5dabceSDavid Gibson add_str(hypertas, "hcall-interrupt"); 8643f5dabceSDavid Gibson add_str(hypertas, "hcall-tce"); 8653f5dabceSDavid Gibson add_str(hypertas, "hcall-vio"); 8663f5dabceSDavid Gibson add_str(hypertas, "hcall-splpar"); 8673f5dabceSDavid Gibson add_str(hypertas, "hcall-bulk"); 8683f5dabceSDavid Gibson add_str(hypertas, "hcall-set-mode"); 8693f5dabceSDavid Gibson add_str(hypertas, "hcall-sprg0"); 8703f5dabceSDavid Gibson add_str(hypertas, "hcall-copy"); 8713f5dabceSDavid Gibson add_str(hypertas, "hcall-debug"); 8723f5dabceSDavid Gibson add_str(qemu_hypertas, "hcall-memop1"); 8733f5dabceSDavid Gibson 8743f5dabceSDavid Gibson if (!kvm_enabled() || kvmppc_spapr_use_multitce()) { 8753f5dabceSDavid Gibson add_str(hypertas, "hcall-multi-tce"); 8763f5dabceSDavid Gibson } 8773f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,hypertas-functions", 8783f5dabceSDavid Gibson hypertas->str, hypertas->len)); 8793f5dabceSDavid Gibson g_string_free(hypertas, TRUE); 8803f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "qemu,hypertas-functions", 8813f5dabceSDavid Gibson qemu_hypertas->str, qemu_hypertas->len)); 8823f5dabceSDavid Gibson g_string_free(qemu_hypertas, TRUE); 8833f5dabceSDavid Gibson 8843f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,associativity-reference-points", 8853f5dabceSDavid Gibson refpoints, sizeof(refpoints))); 8863f5dabceSDavid Gibson 8873f5dabceSDavid Gibson _FDT(fdt_setprop_cell(fdt, rtas, "rtas-error-log-max", 8883f5dabceSDavid Gibson RTAS_ERROR_LOG_MAX)); 8893f5dabceSDavid Gibson _FDT(fdt_setprop_cell(fdt, rtas, "rtas-event-scan-rate", 8903f5dabceSDavid Gibson RTAS_EVENT_SCAN_RATE)); 8913f5dabceSDavid Gibson 8923f5dabceSDavid Gibson if (msi_nonbroken) { 8933f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,change-msix-capable", NULL, 0)); 8943f5dabceSDavid Gibson } 8953f5dabceSDavid Gibson 8963f5dabceSDavid Gibson /* 8973f5dabceSDavid Gibson * According to PAPR, rtas ibm,os-term does not guarantee a return 8983f5dabceSDavid Gibson * back to the guest cpu. 8993f5dabceSDavid Gibson * 9003f5dabceSDavid Gibson * While an additional ibm,extended-os-term property indicates 9013f5dabceSDavid Gibson * that rtas call return will always occur. Set this property. 9023f5dabceSDavid Gibson */ 9033f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,extended-os-term", NULL, 0)); 9043f5dabceSDavid Gibson 9053f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,lrdr-capacity", 9063f5dabceSDavid Gibson lrdr_capacity, sizeof(lrdr_capacity))); 9073f5dabceSDavid Gibson 9083f5dabceSDavid Gibson spapr_dt_rtas_tokens(fdt, rtas); 9093f5dabceSDavid Gibson } 9103f5dabceSDavid Gibson 9119fb4541fSSam Bobroff /* Prepare ibm,arch-vec-5-platform-support, which indicates the MMU features 9129fb4541fSSam Bobroff * that the guest may request and thus the valid values for bytes 24..26 of 9139fb4541fSSam Bobroff * option vector 5: */ 9149fb4541fSSam Bobroff static void spapr_dt_ov5_platform_support(void *fdt, int chosen) 9159fb4541fSSam Bobroff { 916545d6e2bSSuraj Jitindar Singh PowerPCCPU *first_ppc_cpu = POWERPC_CPU(first_cpu); 917545d6e2bSSuraj Jitindar Singh 918f2b14e3aSCédric Le Goater char val[2 * 4] = { 919f2b14e3aSCédric Le Goater 23, 0x00, /* Xive mode: 0 = legacy (as in ISA 2.7), 1 = Exploitation */ 9209fb4541fSSam Bobroff 24, 0x00, /* Hash/Radix, filled in below. */ 9219fb4541fSSam Bobroff 25, 0x00, /* Hash options: Segment Tables == no, GTSE == no. */ 9229fb4541fSSam Bobroff 26, 0x40, /* Radix options: GTSE == yes. */ 9239fb4541fSSam Bobroff }; 9249fb4541fSSam Bobroff 9259fb4541fSSam Bobroff if (kvm_enabled()) { 9269fb4541fSSam Bobroff if (kvmppc_has_cap_mmu_radix() && kvmppc_has_cap_mmu_hash_v3()) { 927f2b14e3aSCédric Le Goater val[3] = 0x80; /* OV5_MMU_BOTH */ 9289fb4541fSSam Bobroff } else if (kvmppc_has_cap_mmu_radix()) { 929f2b14e3aSCédric Le Goater val[3] = 0x40; /* OV5_MMU_RADIX_300 */ 9309fb4541fSSam Bobroff } else { 931f2b14e3aSCédric Le Goater val[3] = 0x00; /* Hash */ 9329fb4541fSSam Bobroff } 9339fb4541fSSam Bobroff } else { 934545d6e2bSSuraj Jitindar Singh if (first_ppc_cpu->env.mmu_model & POWERPC_MMU_V3) { 935545d6e2bSSuraj Jitindar Singh /* V3 MMU supports both hash and radix (with dynamic switching) */ 936f2b14e3aSCédric Le Goater val[3] = 0xC0; 937545d6e2bSSuraj Jitindar Singh } else { 938545d6e2bSSuraj Jitindar Singh /* Otherwise we can only do hash */ 939f2b14e3aSCédric Le Goater val[3] = 0x00; 9409fb4541fSSam Bobroff } 941545d6e2bSSuraj Jitindar Singh } 9429fb4541fSSam Bobroff _FDT(fdt_setprop(fdt, chosen, "ibm,arch-vec-5-platform-support", 9439fb4541fSSam Bobroff val, sizeof(val))); 9449fb4541fSSam Bobroff } 9459fb4541fSSam Bobroff 9467c866c6aSDavid Gibson static void spapr_dt_chosen(sPAPRMachineState *spapr, void *fdt) 9477c866c6aSDavid Gibson { 9487c866c6aSDavid Gibson MachineState *machine = MACHINE(spapr); 9497c866c6aSDavid Gibson int chosen; 9507c866c6aSDavid Gibson const char *boot_device = machine->boot_order; 9517c866c6aSDavid Gibson char *stdout_path = spapr_vio_stdout_path(spapr->vio_bus); 9527c866c6aSDavid Gibson size_t cb = 0; 9537c866c6aSDavid Gibson char *bootlist = get_boot_devices_list(&cb, true); 9547c866c6aSDavid Gibson 9557c866c6aSDavid Gibson _FDT(chosen = fdt_add_subnode(fdt, 0, "chosen")); 9567c866c6aSDavid Gibson 9577c866c6aSDavid Gibson _FDT(fdt_setprop_string(fdt, chosen, "bootargs", machine->kernel_cmdline)); 9587c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "linux,initrd-start", 9597c866c6aSDavid Gibson spapr->initrd_base)); 9607c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "linux,initrd-end", 9617c866c6aSDavid Gibson spapr->initrd_base + spapr->initrd_size)); 9627c866c6aSDavid Gibson 9637c866c6aSDavid Gibson if (spapr->kernel_size) { 9647c866c6aSDavid Gibson uint64_t kprop[2] = { cpu_to_be64(KERNEL_LOAD_ADDR), 9657c866c6aSDavid Gibson cpu_to_be64(spapr->kernel_size) }; 9667c866c6aSDavid Gibson 9677c866c6aSDavid Gibson _FDT(fdt_setprop(fdt, chosen, "qemu,boot-kernel", 9687c866c6aSDavid Gibson &kprop, sizeof(kprop))); 9697c866c6aSDavid Gibson if (spapr->kernel_le) { 9707c866c6aSDavid Gibson _FDT(fdt_setprop(fdt, chosen, "qemu,boot-kernel-le", NULL, 0)); 9717c866c6aSDavid Gibson } 9727c866c6aSDavid Gibson } 9737c866c6aSDavid Gibson if (boot_menu) { 9747c866c6aSDavid Gibson _FDT((fdt_setprop_cell(fdt, chosen, "qemu,boot-menu", boot_menu))); 9757c866c6aSDavid Gibson } 9767c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "qemu,graphic-width", graphic_width)); 9777c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "qemu,graphic-height", graphic_height)); 9787c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "qemu,graphic-depth", graphic_depth)); 9797c866c6aSDavid Gibson 9807c866c6aSDavid Gibson if (cb && bootlist) { 9817c866c6aSDavid Gibson int i; 9827c866c6aSDavid Gibson 9837c866c6aSDavid Gibson for (i = 0; i < cb; i++) { 9847c866c6aSDavid Gibson if (bootlist[i] == '\n') { 9857c866c6aSDavid Gibson bootlist[i] = ' '; 9867c866c6aSDavid Gibson } 9877c866c6aSDavid Gibson } 9887c866c6aSDavid Gibson _FDT(fdt_setprop_string(fdt, chosen, "qemu,boot-list", bootlist)); 9897c866c6aSDavid Gibson } 9907c866c6aSDavid Gibson 9917c866c6aSDavid Gibson if (boot_device && strlen(boot_device)) { 9927c866c6aSDavid Gibson _FDT(fdt_setprop_string(fdt, chosen, "qemu,boot-device", boot_device)); 9937c866c6aSDavid Gibson } 9947c866c6aSDavid Gibson 9957c866c6aSDavid Gibson if (!spapr->has_graphics && stdout_path) { 9967c866c6aSDavid Gibson _FDT(fdt_setprop_string(fdt, chosen, "linux,stdout-path", stdout_path)); 9977c866c6aSDavid Gibson } 9987c866c6aSDavid Gibson 9999fb4541fSSam Bobroff spapr_dt_ov5_platform_support(fdt, chosen); 10009fb4541fSSam Bobroff 10017c866c6aSDavid Gibson g_free(stdout_path); 10027c866c6aSDavid Gibson g_free(bootlist); 10037c866c6aSDavid Gibson } 10047c866c6aSDavid Gibson 1005fca5f2dcSDavid Gibson static void spapr_dt_hypervisor(sPAPRMachineState *spapr, void *fdt) 1006fca5f2dcSDavid Gibson { 1007fca5f2dcSDavid Gibson /* The /hypervisor node isn't in PAPR - this is a hack to allow PR 1008fca5f2dcSDavid Gibson * KVM to work under pHyp with some guest co-operation */ 1009fca5f2dcSDavid Gibson int hypervisor; 1010fca5f2dcSDavid Gibson uint8_t hypercall[16]; 1011fca5f2dcSDavid Gibson 1012fca5f2dcSDavid Gibson _FDT(hypervisor = fdt_add_subnode(fdt, 0, "hypervisor")); 1013fca5f2dcSDavid Gibson /* indicate KVM hypercall interface */ 1014fca5f2dcSDavid Gibson _FDT(fdt_setprop_string(fdt, hypervisor, "compatible", "linux,kvm")); 1015fca5f2dcSDavid Gibson if (kvmppc_has_cap_fixup_hcalls()) { 1016fca5f2dcSDavid Gibson /* 1017fca5f2dcSDavid Gibson * Older KVM versions with older guest kernels were broken 1018fca5f2dcSDavid Gibson * with the magic page, don't allow the guest to map it. 1019fca5f2dcSDavid Gibson */ 1020fca5f2dcSDavid Gibson if (!kvmppc_get_hypercall(first_cpu->env_ptr, hypercall, 1021fca5f2dcSDavid Gibson sizeof(hypercall))) { 1022fca5f2dcSDavid Gibson _FDT(fdt_setprop(fdt, hypervisor, "hcall-instructions", 1023fca5f2dcSDavid Gibson hypercall, sizeof(hypercall))); 1024fca5f2dcSDavid Gibson } 1025fca5f2dcSDavid Gibson } 1026fca5f2dcSDavid Gibson } 1027fca5f2dcSDavid Gibson 1028997b6cfcSDavid Gibson static void *spapr_build_fdt(sPAPRMachineState *spapr, 102953018216SPaolo Bonzini hwaddr rtas_addr, 103053018216SPaolo Bonzini hwaddr rtas_size) 103153018216SPaolo Bonzini { 10325b2128d2SAlexander Graf MachineState *machine = MACHINE(qdev_get_machine()); 10333c0c47e3SDavid Gibson MachineClass *mc = MACHINE_GET_CLASS(machine); 1034c20d332aSBharata B Rao sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(machine); 10357c866c6aSDavid Gibson int ret; 103653018216SPaolo Bonzini void *fdt; 103753018216SPaolo Bonzini sPAPRPHBState *phb; 1038398a0bd5SDavid Gibson char *buf; 103953018216SPaolo Bonzini 1040398a0bd5SDavid Gibson fdt = g_malloc0(FDT_MAX_SIZE); 1041398a0bd5SDavid Gibson _FDT((fdt_create_empty_tree(fdt, FDT_MAX_SIZE))); 104253018216SPaolo Bonzini 1043398a0bd5SDavid Gibson /* Root node */ 1044398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "device_type", "chrp")); 1045398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "model", "IBM pSeries (emulated by qemu)")); 1046398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "compatible", "qemu,pseries")); 1047398a0bd5SDavid Gibson 1048398a0bd5SDavid Gibson /* 1049398a0bd5SDavid Gibson * Add info to guest to indentify which host is it being run on 1050398a0bd5SDavid Gibson * and what is the uuid of the guest 1051398a0bd5SDavid Gibson */ 1052398a0bd5SDavid Gibson if (kvmppc_get_host_model(&buf)) { 1053398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "host-model", buf)); 1054398a0bd5SDavid Gibson g_free(buf); 1055398a0bd5SDavid Gibson } 1056398a0bd5SDavid Gibson if (kvmppc_get_host_serial(&buf)) { 1057398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "host-serial", buf)); 1058398a0bd5SDavid Gibson g_free(buf); 1059398a0bd5SDavid Gibson } 1060398a0bd5SDavid Gibson 1061398a0bd5SDavid Gibson buf = qemu_uuid_unparse_strdup(&qemu_uuid); 1062398a0bd5SDavid Gibson 1063398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "vm,uuid", buf)); 1064398a0bd5SDavid Gibson if (qemu_uuid_set) { 1065398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "system-id", buf)); 1066398a0bd5SDavid Gibson } 1067398a0bd5SDavid Gibson g_free(buf); 1068398a0bd5SDavid Gibson 1069398a0bd5SDavid Gibson if (qemu_get_vm_name()) { 1070398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "ibm,partition-name", 1071398a0bd5SDavid Gibson qemu_get_vm_name())); 1072398a0bd5SDavid Gibson } 1073398a0bd5SDavid Gibson 1074398a0bd5SDavid Gibson _FDT(fdt_setprop_cell(fdt, 0, "#address-cells", 2)); 1075398a0bd5SDavid Gibson _FDT(fdt_setprop_cell(fdt, 0, "#size-cells", 2)); 107653018216SPaolo Bonzini 1077e8f986fcSBharata B Rao ret = spapr_populate_memory(spapr, fdt); 1078e8f986fcSBharata B Rao if (ret < 0) { 1079ce9863b7SCédric Le Goater error_report("couldn't setup memory nodes in fdt"); 1080e8f986fcSBharata B Rao exit(1); 108153018216SPaolo Bonzini } 108253018216SPaolo Bonzini 1083bf5a6696SDavid Gibson /* /vdevice */ 1084bf5a6696SDavid Gibson spapr_dt_vdevice(spapr->vio_bus, fdt); 108553018216SPaolo Bonzini 10864d9392beSThomas Huth if (object_resolve_path_type("", TYPE_SPAPR_RNG, NULL)) { 10874d9392beSThomas Huth ret = spapr_rng_populate_dt(fdt); 10884d9392beSThomas Huth if (ret < 0) { 1089ce9863b7SCédric Le Goater error_report("could not set up rng device in the fdt"); 10904d9392beSThomas Huth exit(1); 10914d9392beSThomas Huth } 10924d9392beSThomas Huth } 10934d9392beSThomas Huth 109453018216SPaolo Bonzini QLIST_FOREACH(phb, &spapr->phbs, list) { 109553018216SPaolo Bonzini ret = spapr_populate_pci_dt(phb, PHANDLE_XICP, fdt); 109653018216SPaolo Bonzini if (ret < 0) { 1097da34fed7SThomas Huth error_report("couldn't setup PCI devices in fdt"); 109853018216SPaolo Bonzini exit(1); 109953018216SPaolo Bonzini } 1100da34fed7SThomas Huth } 110153018216SPaolo Bonzini 11020da6f3feSBharata B Rao /* cpus */ 11030da6f3feSBharata B Rao spapr_populate_cpus_dt_node(fdt, spapr); 110453018216SPaolo Bonzini 1105c20d332aSBharata B Rao if (smc->dr_lmb_enabled) { 1106c20d332aSBharata B Rao _FDT(spapr_drc_populate_dt(fdt, 0, NULL, SPAPR_DR_CONNECTOR_TYPE_LMB)); 1107c20d332aSBharata B Rao } 1108c20d332aSBharata B Rao 1109c5514d0eSIgor Mammedov if (mc->has_hotpluggable_cpus) { 1110af81cf32SBharata B Rao int offset = fdt_path_offset(fdt, "/cpus"); 1111af81cf32SBharata B Rao ret = spapr_drc_populate_dt(fdt, offset, NULL, 1112af81cf32SBharata B Rao SPAPR_DR_CONNECTOR_TYPE_CPU); 1113af81cf32SBharata B Rao if (ret < 0) { 1114af81cf32SBharata B Rao error_report("Couldn't set up CPU DR device tree properties"); 1115af81cf32SBharata B Rao exit(1); 1116af81cf32SBharata B Rao } 1117af81cf32SBharata B Rao } 1118af81cf32SBharata B Rao 1119ffb1e275SDavid Gibson /* /event-sources */ 1120ffbb1705SMichael Roth spapr_dt_events(spapr, fdt); 1121ffb1e275SDavid Gibson 11223f5dabceSDavid Gibson /* /rtas */ 11233f5dabceSDavid Gibson spapr_dt_rtas(spapr, fdt); 11243f5dabceSDavid Gibson 11257c866c6aSDavid Gibson /* /chosen */ 11267c866c6aSDavid Gibson spapr_dt_chosen(spapr, fdt); 1127cf6e5223SDavid Gibson 1128fca5f2dcSDavid Gibson /* /hypervisor */ 1129fca5f2dcSDavid Gibson if (kvm_enabled()) { 1130fca5f2dcSDavid Gibson spapr_dt_hypervisor(spapr, fdt); 1131fca5f2dcSDavid Gibson } 1132fca5f2dcSDavid Gibson 1133cf6e5223SDavid Gibson /* Build memory reserve map */ 1134cf6e5223SDavid Gibson if (spapr->kernel_size) { 1135cf6e5223SDavid Gibson _FDT((fdt_add_mem_rsv(fdt, KERNEL_LOAD_ADDR, spapr->kernel_size))); 1136cf6e5223SDavid Gibson } 1137cf6e5223SDavid Gibson if (spapr->initrd_size) { 1138cf6e5223SDavid Gibson _FDT((fdt_add_mem_rsv(fdt, spapr->initrd_base, spapr->initrd_size))); 1139cf6e5223SDavid Gibson } 1140cf6e5223SDavid Gibson 11416787d27bSMichael Roth /* ibm,client-architecture-support updates */ 11426787d27bSMichael Roth ret = spapr_dt_cas_updates(spapr, fdt, spapr->ov5_cas); 11436787d27bSMichael Roth if (ret < 0) { 11446787d27bSMichael Roth error_report("couldn't setup CAS properties fdt"); 11456787d27bSMichael Roth exit(1); 11466787d27bSMichael Roth } 11476787d27bSMichael Roth 1148997b6cfcSDavid Gibson return fdt; 114953018216SPaolo Bonzini } 115053018216SPaolo Bonzini 115153018216SPaolo Bonzini static uint64_t translate_kernel_address(void *opaque, uint64_t addr) 115253018216SPaolo Bonzini { 115353018216SPaolo Bonzini return (addr & 0x0fffffff) + KERNEL_LOAD_ADDR; 115453018216SPaolo Bonzini } 115553018216SPaolo Bonzini 11561d1be34dSDavid Gibson static void emulate_spapr_hypercall(PPCVirtualHypervisor *vhyp, 11571d1be34dSDavid Gibson PowerPCCPU *cpu) 115853018216SPaolo Bonzini { 115953018216SPaolo Bonzini CPUPPCState *env = &cpu->env; 116053018216SPaolo Bonzini 11618d04fb55SJan Kiszka /* The TCG path should also be holding the BQL at this point */ 11628d04fb55SJan Kiszka g_assert(qemu_mutex_iothread_locked()); 11638d04fb55SJan Kiszka 116453018216SPaolo Bonzini if (msr_pr) { 116553018216SPaolo Bonzini hcall_dprintf("Hypercall made with MSR[PR]=1\n"); 116653018216SPaolo Bonzini env->gpr[3] = H_PRIVILEGE; 116753018216SPaolo Bonzini } else { 116853018216SPaolo Bonzini env->gpr[3] = spapr_hypercall(cpu, env->gpr[3], &env->gpr[4]); 116953018216SPaolo Bonzini } 117053018216SPaolo Bonzini } 117153018216SPaolo Bonzini 11729861bb3eSSuraj Jitindar Singh static uint64_t spapr_get_patbe(PPCVirtualHypervisor *vhyp) 11739861bb3eSSuraj Jitindar Singh { 11749861bb3eSSuraj Jitindar Singh sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 11759861bb3eSSuraj Jitindar Singh 11769861bb3eSSuraj Jitindar Singh return spapr->patb_entry; 11779861bb3eSSuraj Jitindar Singh } 11789861bb3eSSuraj Jitindar Singh 1179e6b8fd24SSamuel Mendoza-Jonas #define HPTE(_table, _i) (void *)(((uint64_t *)(_table)) + ((_i) * 2)) 1180e6b8fd24SSamuel Mendoza-Jonas #define HPTE_VALID(_hpte) (tswap64(*((uint64_t *)(_hpte))) & HPTE64_V_VALID) 1181e6b8fd24SSamuel Mendoza-Jonas #define HPTE_DIRTY(_hpte) (tswap64(*((uint64_t *)(_hpte))) & HPTE64_V_HPTE_DIRTY) 1182e6b8fd24SSamuel Mendoza-Jonas #define CLEAN_HPTE(_hpte) ((*(uint64_t *)(_hpte)) &= tswap64(~HPTE64_V_HPTE_DIRTY)) 1183e6b8fd24SSamuel Mendoza-Jonas #define DIRTY_HPTE(_hpte) ((*(uint64_t *)(_hpte)) |= tswap64(HPTE64_V_HPTE_DIRTY)) 1184e6b8fd24SSamuel Mendoza-Jonas 1185715c5407SDavid Gibson /* 1186715c5407SDavid Gibson * Get the fd to access the kernel htab, re-opening it if necessary 1187715c5407SDavid Gibson */ 1188715c5407SDavid Gibson static int get_htab_fd(sPAPRMachineState *spapr) 1189715c5407SDavid Gibson { 1190715c5407SDavid Gibson if (spapr->htab_fd >= 0) { 1191715c5407SDavid Gibson return spapr->htab_fd; 1192715c5407SDavid Gibson } 1193715c5407SDavid Gibson 1194715c5407SDavid Gibson spapr->htab_fd = kvmppc_get_htab_fd(false); 1195715c5407SDavid Gibson if (spapr->htab_fd < 0) { 1196715c5407SDavid Gibson error_report("Unable to open fd for reading hash table from KVM: %s", 1197715c5407SDavid Gibson strerror(errno)); 1198715c5407SDavid Gibson } 1199715c5407SDavid Gibson 1200715c5407SDavid Gibson return spapr->htab_fd; 1201715c5407SDavid Gibson } 1202715c5407SDavid Gibson 1203b4db5413SSuraj Jitindar Singh void close_htab_fd(sPAPRMachineState *spapr) 1204715c5407SDavid Gibson { 1205715c5407SDavid Gibson if (spapr->htab_fd >= 0) { 1206715c5407SDavid Gibson close(spapr->htab_fd); 1207715c5407SDavid Gibson } 1208715c5407SDavid Gibson spapr->htab_fd = -1; 1209715c5407SDavid Gibson } 1210715c5407SDavid Gibson 1211e57ca75cSDavid Gibson static hwaddr spapr_hpt_mask(PPCVirtualHypervisor *vhyp) 1212e57ca75cSDavid Gibson { 1213e57ca75cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 1214e57ca75cSDavid Gibson 1215e57ca75cSDavid Gibson return HTAB_SIZE(spapr) / HASH_PTEG_SIZE_64 - 1; 1216e57ca75cSDavid Gibson } 1217e57ca75cSDavid Gibson 1218e57ca75cSDavid Gibson static const ppc_hash_pte64_t *spapr_map_hptes(PPCVirtualHypervisor *vhyp, 1219e57ca75cSDavid Gibson hwaddr ptex, int n) 1220e57ca75cSDavid Gibson { 1221e57ca75cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 1222e57ca75cSDavid Gibson hwaddr pte_offset = ptex * HASH_PTE_SIZE_64; 1223e57ca75cSDavid Gibson 1224e57ca75cSDavid Gibson if (!spapr->htab) { 1225e57ca75cSDavid Gibson /* 1226e57ca75cSDavid Gibson * HTAB is controlled by KVM. Fetch into temporary buffer 1227e57ca75cSDavid Gibson */ 1228e57ca75cSDavid Gibson ppc_hash_pte64_t *hptes = g_malloc(n * HASH_PTE_SIZE_64); 1229e57ca75cSDavid Gibson kvmppc_read_hptes(hptes, ptex, n); 1230e57ca75cSDavid Gibson return hptes; 1231e57ca75cSDavid Gibson } 1232e57ca75cSDavid Gibson 1233e57ca75cSDavid Gibson /* 1234e57ca75cSDavid Gibson * HTAB is controlled by QEMU. Just point to the internally 1235e57ca75cSDavid Gibson * accessible PTEG. 1236e57ca75cSDavid Gibson */ 1237e57ca75cSDavid Gibson return (const ppc_hash_pte64_t *)(spapr->htab + pte_offset); 1238e57ca75cSDavid Gibson } 1239e57ca75cSDavid Gibson 1240e57ca75cSDavid Gibson static void spapr_unmap_hptes(PPCVirtualHypervisor *vhyp, 1241e57ca75cSDavid Gibson const ppc_hash_pte64_t *hptes, 1242e57ca75cSDavid Gibson hwaddr ptex, int n) 1243e57ca75cSDavid Gibson { 1244e57ca75cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 1245e57ca75cSDavid Gibson 1246e57ca75cSDavid Gibson if (!spapr->htab) { 1247e57ca75cSDavid Gibson g_free((void *)hptes); 1248e57ca75cSDavid Gibson } 1249e57ca75cSDavid Gibson 1250e57ca75cSDavid Gibson /* Nothing to do for qemu managed HPT */ 1251e57ca75cSDavid Gibson } 1252e57ca75cSDavid Gibson 1253e57ca75cSDavid Gibson static void spapr_store_hpte(PPCVirtualHypervisor *vhyp, hwaddr ptex, 1254e57ca75cSDavid Gibson uint64_t pte0, uint64_t pte1) 1255e57ca75cSDavid Gibson { 1256e57ca75cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 1257e57ca75cSDavid Gibson hwaddr offset = ptex * HASH_PTE_SIZE_64; 1258e57ca75cSDavid Gibson 1259e57ca75cSDavid Gibson if (!spapr->htab) { 1260e57ca75cSDavid Gibson kvmppc_write_hpte(ptex, pte0, pte1); 1261e57ca75cSDavid Gibson } else { 1262e57ca75cSDavid Gibson stq_p(spapr->htab + offset, pte0); 1263e57ca75cSDavid Gibson stq_p(spapr->htab + offset + HASH_PTE_SIZE_64 / 2, pte1); 1264e57ca75cSDavid Gibson } 1265e57ca75cSDavid Gibson } 1266e57ca75cSDavid Gibson 12678dfe8e7fSDavid Gibson static int spapr_hpt_shift_for_ramsize(uint64_t ramsize) 12688dfe8e7fSDavid Gibson { 12698dfe8e7fSDavid Gibson int shift; 12708dfe8e7fSDavid Gibson 12718dfe8e7fSDavid Gibson /* We aim for a hash table of size 1/128 the size of RAM (rounded 12728dfe8e7fSDavid Gibson * up). The PAPR recommendation is actually 1/64 of RAM size, but 12738dfe8e7fSDavid Gibson * that's much more than is needed for Linux guests */ 12748dfe8e7fSDavid Gibson shift = ctz64(pow2ceil(ramsize)) - 7; 12758dfe8e7fSDavid Gibson shift = MAX(shift, 18); /* Minimum architected size */ 12768dfe8e7fSDavid Gibson shift = MIN(shift, 46); /* Maximum architected size */ 12778dfe8e7fSDavid Gibson return shift; 12788dfe8e7fSDavid Gibson } 12798dfe8e7fSDavid Gibson 128006ec79e8SBharata B Rao void spapr_free_hpt(sPAPRMachineState *spapr) 128106ec79e8SBharata B Rao { 128206ec79e8SBharata B Rao g_free(spapr->htab); 128306ec79e8SBharata B Rao spapr->htab = NULL; 128406ec79e8SBharata B Rao spapr->htab_shift = 0; 128506ec79e8SBharata B Rao close_htab_fd(spapr); 128606ec79e8SBharata B Rao } 128706ec79e8SBharata B Rao 1288c5f54f3eSDavid Gibson static void spapr_reallocate_hpt(sPAPRMachineState *spapr, int shift, 1289c5f54f3eSDavid Gibson Error **errp) 129053018216SPaolo Bonzini { 1291c5f54f3eSDavid Gibson long rc; 129253018216SPaolo Bonzini 1293c5f54f3eSDavid Gibson /* Clean up any HPT info from a previous boot */ 129406ec79e8SBharata B Rao spapr_free_hpt(spapr); 129553018216SPaolo Bonzini 1296c5f54f3eSDavid Gibson rc = kvmppc_reset_htab(shift); 1297c5f54f3eSDavid Gibson if (rc < 0) { 1298c5f54f3eSDavid Gibson /* kernel-side HPT needed, but couldn't allocate one */ 1299c5f54f3eSDavid Gibson error_setg_errno(errp, errno, 1300c5f54f3eSDavid Gibson "Failed to allocate KVM HPT of order %d (try smaller maxmem?)", 1301c5f54f3eSDavid Gibson shift); 1302c5f54f3eSDavid Gibson /* This is almost certainly fatal, but if the caller really 1303c5f54f3eSDavid Gibson * wants to carry on with shift == 0, it's welcome to try */ 1304c5f54f3eSDavid Gibson } else if (rc > 0) { 1305c5f54f3eSDavid Gibson /* kernel-side HPT allocated */ 1306c5f54f3eSDavid Gibson if (rc != shift) { 1307c5f54f3eSDavid Gibson error_setg(errp, 1308c5f54f3eSDavid Gibson "Requested order %d HPT, but kernel allocated order %ld (try smaller maxmem?)", 1309c5f54f3eSDavid Gibson shift, rc); 13107735fedaSBharata B Rao } 13117735fedaSBharata B Rao 131253018216SPaolo Bonzini spapr->htab_shift = shift; 1313c18ad9a5SDavid Gibson spapr->htab = NULL; 1314b817772aSBharata B Rao } else { 1315c5f54f3eSDavid Gibson /* kernel-side HPT not needed, allocate in userspace instead */ 1316c5f54f3eSDavid Gibson size_t size = 1ULL << shift; 1317c5f54f3eSDavid Gibson int i; 131801a57972SSamuel Mendoza-Jonas 1319c5f54f3eSDavid Gibson spapr->htab = qemu_memalign(size, size); 1320c5f54f3eSDavid Gibson if (!spapr->htab) { 1321c5f54f3eSDavid Gibson error_setg_errno(errp, errno, 1322c5f54f3eSDavid Gibson "Could not allocate HPT of order %d", shift); 1323c5f54f3eSDavid Gibson return; 1324b817772aSBharata B Rao } 1325b817772aSBharata B Rao 1326c5f54f3eSDavid Gibson memset(spapr->htab, 0, size); 1327c5f54f3eSDavid Gibson spapr->htab_shift = shift; 1328b817772aSBharata B Rao 1329c5f54f3eSDavid Gibson for (i = 0; i < size / HASH_PTE_SIZE_64; i++) { 1330c5f54f3eSDavid Gibson DIRTY_HPTE(HPTE(spapr->htab, i)); 13317735fedaSBharata B Rao } 133253018216SPaolo Bonzini } 133353018216SPaolo Bonzini } 133453018216SPaolo Bonzini 1335b4db5413SSuraj Jitindar Singh void spapr_setup_hpt_and_vrma(sPAPRMachineState *spapr) 1336b4db5413SSuraj Jitindar Singh { 1337b4db5413SSuraj Jitindar Singh spapr_reallocate_hpt(spapr, 1338b4db5413SSuraj Jitindar Singh spapr_hpt_shift_for_ramsize(MACHINE(spapr)->maxram_size), 1339b4db5413SSuraj Jitindar Singh &error_fatal); 1340b4db5413SSuraj Jitindar Singh if (spapr->vrma_adjust) { 1341b4db5413SSuraj Jitindar Singh spapr->rma_size = kvmppc_rma_size(spapr_node0_size(), 1342b4db5413SSuraj Jitindar Singh spapr->htab_shift); 1343b4db5413SSuraj Jitindar Singh } 1344b4db5413SSuraj Jitindar Singh /* We're setting up a hash table, so that means we're not radix */ 1345b4db5413SSuraj Jitindar Singh spapr->patb_entry = 0; 1346b4db5413SSuraj Jitindar Singh } 1347b4db5413SSuraj Jitindar Singh 13484f01a637SDavid Gibson static void find_unknown_sysbus_device(SysBusDevice *sbdev, void *opaque) 13499e3f9733SAlexander Graf { 13509e3f9733SAlexander Graf bool matched = false; 13519e3f9733SAlexander Graf 13529e3f9733SAlexander Graf if (object_dynamic_cast(OBJECT(sbdev), TYPE_SPAPR_PCI_HOST_BRIDGE)) { 13539e3f9733SAlexander Graf matched = true; 13549e3f9733SAlexander Graf } 13559e3f9733SAlexander Graf 13569e3f9733SAlexander Graf if (!matched) { 13579e3f9733SAlexander Graf error_report("Device %s is not supported by this machine yet.", 13589e3f9733SAlexander Graf qdev_fw_name(DEVICE(sbdev))); 13599e3f9733SAlexander Graf exit(1); 13609e3f9733SAlexander Graf } 13619e3f9733SAlexander Graf } 13629e3f9733SAlexander Graf 136353018216SPaolo Bonzini static void ppc_spapr_reset(void) 136453018216SPaolo Bonzini { 1365c5f54f3eSDavid Gibson MachineState *machine = MACHINE(qdev_get_machine()); 1366c5f54f3eSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(machine); 1367182735efSAndreas Färber PowerPCCPU *first_ppc_cpu; 1368b7d1f77aSBenjamin Herrenschmidt uint32_t rtas_limit; 1369cae172abSDavid Gibson hwaddr rtas_addr, fdt_addr; 1370997b6cfcSDavid Gibson void *fdt; 1371997b6cfcSDavid Gibson int rc; 1372259186a7SAndreas Färber 13739e3f9733SAlexander Graf /* Check for unknown sysbus devices */ 13749e3f9733SAlexander Graf foreach_dynamic_sysbus_device(find_unknown_sysbus_device, NULL); 13759e3f9733SAlexander Graf 1376b4db5413SSuraj Jitindar Singh if (kvm_enabled() && kvmppc_has_cap_mmu_radix()) { 1377b4db5413SSuraj Jitindar Singh /* If using KVM with radix mode available, VCPUs can be started 1378b4db5413SSuraj Jitindar Singh * without a HPT because KVM will start them in radix mode. 1379b4db5413SSuraj Jitindar Singh * Set the GR bit in PATB so that we know there is no HPT. */ 1380b4db5413SSuraj Jitindar Singh spapr->patb_entry = PATBE1_GR; 1381b4db5413SSuraj Jitindar Singh } else { 1382b4db5413SSuraj Jitindar Singh spapr_setup_hpt_and_vrma(spapr); 1383c5f54f3eSDavid Gibson } 138453018216SPaolo Bonzini 138553018216SPaolo Bonzini qemu_devices_reset(); 138653018216SPaolo Bonzini 1387b7d1f77aSBenjamin Herrenschmidt /* 1388b7d1f77aSBenjamin Herrenschmidt * We place the device tree and RTAS just below either the top of the RMA, 1389b7d1f77aSBenjamin Herrenschmidt * or just below 2GB, whichever is lowere, so that it can be 1390b7d1f77aSBenjamin Herrenschmidt * processed with 32-bit real mode code if necessary 1391b7d1f77aSBenjamin Herrenschmidt */ 1392b7d1f77aSBenjamin Herrenschmidt rtas_limit = MIN(spapr->rma_size, RTAS_MAX_ADDR); 1393cae172abSDavid Gibson rtas_addr = rtas_limit - RTAS_MAX_SIZE; 1394cae172abSDavid Gibson fdt_addr = rtas_addr - FDT_MAX_SIZE; 1395b7d1f77aSBenjamin Herrenschmidt 13966787d27bSMichael Roth /* if this reset wasn't generated by CAS, we should reset our 13976787d27bSMichael Roth * negotiated options and start from scratch */ 13986787d27bSMichael Roth if (!spapr->cas_reboot) { 13996787d27bSMichael Roth spapr_ovec_cleanup(spapr->ov5_cas); 14006787d27bSMichael Roth spapr->ov5_cas = spapr_ovec_new(); 140166d5c492SDavid Gibson 140266d5c492SDavid Gibson ppc_set_compat_all(spapr->max_compat_pvr, &error_fatal); 14036787d27bSMichael Roth } 14046787d27bSMichael Roth 1405cae172abSDavid Gibson fdt = spapr_build_fdt(spapr, rtas_addr, spapr->rtas_size); 140653018216SPaolo Bonzini 14072cac78c1SDavid Gibson spapr_load_rtas(spapr, fdt, rtas_addr); 1408b7d1f77aSBenjamin Herrenschmidt 1409997b6cfcSDavid Gibson rc = fdt_pack(fdt); 1410997b6cfcSDavid Gibson 1411997b6cfcSDavid Gibson /* Should only fail if we've built a corrupted tree */ 1412997b6cfcSDavid Gibson assert(rc == 0); 1413997b6cfcSDavid Gibson 1414997b6cfcSDavid Gibson if (fdt_totalsize(fdt) > FDT_MAX_SIZE) { 1415997b6cfcSDavid Gibson error_report("FDT too big ! 0x%x bytes (max is 0x%x)", 1416997b6cfcSDavid Gibson fdt_totalsize(fdt), FDT_MAX_SIZE); 1417997b6cfcSDavid Gibson exit(1); 1418997b6cfcSDavid Gibson } 1419997b6cfcSDavid Gibson 1420997b6cfcSDavid Gibson /* Load the fdt */ 1421997b6cfcSDavid Gibson qemu_fdt_dumpdtb(fdt, fdt_totalsize(fdt)); 1422cae172abSDavid Gibson cpu_physical_memory_write(fdt_addr, fdt, fdt_totalsize(fdt)); 1423997b6cfcSDavid Gibson g_free(fdt); 1424997b6cfcSDavid Gibson 142553018216SPaolo Bonzini /* Set up the entry state */ 1426182735efSAndreas Färber first_ppc_cpu = POWERPC_CPU(first_cpu); 1427cae172abSDavid Gibson first_ppc_cpu->env.gpr[3] = fdt_addr; 1428182735efSAndreas Färber first_ppc_cpu->env.gpr[5] = 0; 1429182735efSAndreas Färber first_cpu->halted = 0; 14301b718907SDavid Gibson first_ppc_cpu->env.nip = SPAPR_ENTRY_POINT; 143153018216SPaolo Bonzini 14326787d27bSMichael Roth spapr->cas_reboot = false; 143353018216SPaolo Bonzini } 143453018216SPaolo Bonzini 143528e02042SDavid Gibson static void spapr_create_nvram(sPAPRMachineState *spapr) 143653018216SPaolo Bonzini { 14372ff3de68SMarkus Armbruster DeviceState *dev = qdev_create(&spapr->vio_bus->bus, "spapr-nvram"); 14383978b863SPaolo Bonzini DriveInfo *dinfo = drive_get(IF_PFLASH, 0, 0); 143953018216SPaolo Bonzini 14403978b863SPaolo Bonzini if (dinfo) { 14416231a6daSMarkus Armbruster qdev_prop_set_drive(dev, "drive", blk_by_legacy_dinfo(dinfo), 14426231a6daSMarkus Armbruster &error_fatal); 144353018216SPaolo Bonzini } 144453018216SPaolo Bonzini 144553018216SPaolo Bonzini qdev_init_nofail(dev); 144653018216SPaolo Bonzini 144753018216SPaolo Bonzini spapr->nvram = (struct sPAPRNVRAM *)dev; 144853018216SPaolo Bonzini } 144953018216SPaolo Bonzini 145028e02042SDavid Gibson static void spapr_rtc_create(sPAPRMachineState *spapr) 145128df36a1SDavid Gibson { 1452147ff807SCédric Le Goater object_initialize(&spapr->rtc, sizeof(spapr->rtc), TYPE_SPAPR_RTC); 1453147ff807SCédric Le Goater object_property_add_child(OBJECT(spapr), "rtc", OBJECT(&spapr->rtc), 1454147ff807SCédric Le Goater &error_fatal); 1455147ff807SCédric Le Goater object_property_set_bool(OBJECT(&spapr->rtc), true, "realized", 1456147ff807SCédric Le Goater &error_fatal); 1457147ff807SCédric Le Goater object_property_add_alias(OBJECT(spapr), "rtc-time", OBJECT(&spapr->rtc), 1458147ff807SCédric Le Goater "date", &error_fatal); 145928df36a1SDavid Gibson } 146028df36a1SDavid Gibson 146153018216SPaolo Bonzini /* Returns whether we want to use VGA or not */ 146214c6a894SDavid Gibson static bool spapr_vga_init(PCIBus *pci_bus, Error **errp) 146353018216SPaolo Bonzini { 146453018216SPaolo Bonzini switch (vga_interface_type) { 146553018216SPaolo Bonzini case VGA_NONE: 14667effdaa3SMark Wu return false; 14677effdaa3SMark Wu case VGA_DEVICE: 14687effdaa3SMark Wu return true; 146953018216SPaolo Bonzini case VGA_STD: 1470b798c190SBenjamin Herrenschmidt case VGA_VIRTIO: 147153018216SPaolo Bonzini return pci_vga_init(pci_bus) != NULL; 147253018216SPaolo Bonzini default: 147314c6a894SDavid Gibson error_setg(errp, 147414c6a894SDavid Gibson "Unsupported VGA mode, only -vga std or -vga virtio is supported"); 147514c6a894SDavid Gibson return false; 147653018216SPaolo Bonzini } 147753018216SPaolo Bonzini } 147853018216SPaolo Bonzini 1479880ae7deSDavid Gibson static int spapr_post_load(void *opaque, int version_id) 1480880ae7deSDavid Gibson { 148128e02042SDavid Gibson sPAPRMachineState *spapr = (sPAPRMachineState *)opaque; 1482880ae7deSDavid Gibson int err = 0; 1483880ae7deSDavid Gibson 1484a7ff1212SCédric Le Goater if (!object_dynamic_cast(OBJECT(spapr->ics), TYPE_ICS_KVM)) { 14855bc8d26dSCédric Le Goater CPUState *cs; 14865bc8d26dSCédric Le Goater CPU_FOREACH(cs) { 14875bc8d26dSCédric Le Goater PowerPCCPU *cpu = POWERPC_CPU(cs); 14885bc8d26dSCédric Le Goater icp_resend(ICP(cpu->intc)); 1489a7ff1212SCédric Le Goater } 1490a7ff1212SCédric Le Goater } 1491a7ff1212SCédric Le Goater 1492631b22eaSStefan Weil /* In earlier versions, there was no separate qdev for the PAPR 1493880ae7deSDavid Gibson * RTC, so the RTC offset was stored directly in sPAPREnvironment. 1494880ae7deSDavid Gibson * So when migrating from those versions, poke the incoming offset 1495880ae7deSDavid Gibson * value into the RTC device */ 1496880ae7deSDavid Gibson if (version_id < 3) { 1497147ff807SCédric Le Goater err = spapr_rtc_import_offset(&spapr->rtc, spapr->rtc_offset); 1498880ae7deSDavid Gibson } 1499880ae7deSDavid Gibson 1500d39c90f5SBharata B Rao if (spapr->patb_entry) { 1501d39c90f5SBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(first_cpu); 1502d39c90f5SBharata B Rao bool radix = !!(spapr->patb_entry & PATBE1_GR); 1503d39c90f5SBharata B Rao bool gtse = !!(cpu->env.spr[SPR_LPCR] & LPCR_GTSE); 1504d39c90f5SBharata B Rao 1505d39c90f5SBharata B Rao err = kvmppc_configure_v3_mmu(cpu, radix, gtse, spapr->patb_entry); 1506d39c90f5SBharata B Rao if (err) { 1507d39c90f5SBharata B Rao error_report("Process table config unsupported by the host"); 1508d39c90f5SBharata B Rao return -EINVAL; 1509d39c90f5SBharata B Rao } 1510d39c90f5SBharata B Rao } 1511d39c90f5SBharata B Rao 1512880ae7deSDavid Gibson return err; 1513880ae7deSDavid Gibson } 1514880ae7deSDavid Gibson 1515880ae7deSDavid Gibson static bool version_before_3(void *opaque, int version_id) 1516880ae7deSDavid Gibson { 1517880ae7deSDavid Gibson return version_id < 3; 1518880ae7deSDavid Gibson } 1519880ae7deSDavid Gibson 1520fd38804bSDaniel Henrique Barboza static bool spapr_pending_events_needed(void *opaque) 1521fd38804bSDaniel Henrique Barboza { 1522fd38804bSDaniel Henrique Barboza sPAPRMachineState *spapr = (sPAPRMachineState *)opaque; 1523fd38804bSDaniel Henrique Barboza return !QTAILQ_EMPTY(&spapr->pending_events); 1524fd38804bSDaniel Henrique Barboza } 1525fd38804bSDaniel Henrique Barboza 1526fd38804bSDaniel Henrique Barboza static const VMStateDescription vmstate_spapr_event_entry = { 1527fd38804bSDaniel Henrique Barboza .name = "spapr_event_log_entry", 1528fd38804bSDaniel Henrique Barboza .version_id = 1, 1529fd38804bSDaniel Henrique Barboza .minimum_version_id = 1, 1530fd38804bSDaniel Henrique Barboza .fields = (VMStateField[]) { 15315341258eSDavid Gibson VMSTATE_UINT32(summary, sPAPREventLogEntry), 15325341258eSDavid Gibson VMSTATE_UINT32(extended_length, sPAPREventLogEntry), 1533fd38804bSDaniel Henrique Barboza VMSTATE_VBUFFER_ALLOC_UINT32(extended_log, sPAPREventLogEntry, 0, 15345341258eSDavid Gibson NULL, extended_length), 1535fd38804bSDaniel Henrique Barboza VMSTATE_END_OF_LIST() 1536fd38804bSDaniel Henrique Barboza }, 1537fd38804bSDaniel Henrique Barboza }; 1538fd38804bSDaniel Henrique Barboza 1539fd38804bSDaniel Henrique Barboza static const VMStateDescription vmstate_spapr_pending_events = { 1540fd38804bSDaniel Henrique Barboza .name = "spapr_pending_events", 1541fd38804bSDaniel Henrique Barboza .version_id = 1, 1542fd38804bSDaniel Henrique Barboza .minimum_version_id = 1, 1543fd38804bSDaniel Henrique Barboza .needed = spapr_pending_events_needed, 1544fd38804bSDaniel Henrique Barboza .fields = (VMStateField[]) { 1545fd38804bSDaniel Henrique Barboza VMSTATE_QTAILQ_V(pending_events, sPAPRMachineState, 1, 1546fd38804bSDaniel Henrique Barboza vmstate_spapr_event_entry, sPAPREventLogEntry, next), 1547fd38804bSDaniel Henrique Barboza VMSTATE_END_OF_LIST() 1548fd38804bSDaniel Henrique Barboza }, 1549fd38804bSDaniel Henrique Barboza }; 1550fd38804bSDaniel Henrique Barboza 155162ef3760SMichael Roth static bool spapr_ov5_cas_needed(void *opaque) 155262ef3760SMichael Roth { 155362ef3760SMichael Roth sPAPRMachineState *spapr = opaque; 155462ef3760SMichael Roth sPAPROptionVector *ov5_mask = spapr_ovec_new(); 155562ef3760SMichael Roth sPAPROptionVector *ov5_legacy = spapr_ovec_new(); 155662ef3760SMichael Roth sPAPROptionVector *ov5_removed = spapr_ovec_new(); 155762ef3760SMichael Roth bool cas_needed; 155862ef3760SMichael Roth 155962ef3760SMichael Roth /* Prior to the introduction of sPAPROptionVector, we had two option 156062ef3760SMichael Roth * vectors we dealt with: OV5_FORM1_AFFINITY, and OV5_DRCONF_MEMORY. 156162ef3760SMichael Roth * Both of these options encode machine topology into the device-tree 156262ef3760SMichael Roth * in such a way that the now-booted OS should still be able to interact 156362ef3760SMichael Roth * appropriately with QEMU regardless of what options were actually 156462ef3760SMichael Roth * negotiatied on the source side. 156562ef3760SMichael Roth * 156662ef3760SMichael Roth * As such, we can avoid migrating the CAS-negotiated options if these 156762ef3760SMichael Roth * are the only options available on the current machine/platform. 156862ef3760SMichael Roth * Since these are the only options available for pseries-2.7 and 156962ef3760SMichael Roth * earlier, this allows us to maintain old->new/new->old migration 157062ef3760SMichael Roth * compatibility. 157162ef3760SMichael Roth * 157262ef3760SMichael Roth * For QEMU 2.8+, there are additional CAS-negotiatable options available 157362ef3760SMichael Roth * via default pseries-2.8 machines and explicit command-line parameters. 157462ef3760SMichael Roth * Some of these options, like OV5_HP_EVT, *do* require QEMU to be aware 157562ef3760SMichael Roth * of the actual CAS-negotiated values to continue working properly. For 157662ef3760SMichael Roth * example, availability of memory unplug depends on knowing whether 157762ef3760SMichael Roth * OV5_HP_EVT was negotiated via CAS. 157862ef3760SMichael Roth * 157962ef3760SMichael Roth * Thus, for any cases where the set of available CAS-negotiatable 158062ef3760SMichael Roth * options extends beyond OV5_FORM1_AFFINITY and OV5_DRCONF_MEMORY, we 158162ef3760SMichael Roth * include the CAS-negotiated options in the migration stream. 158262ef3760SMichael Roth */ 158362ef3760SMichael Roth spapr_ovec_set(ov5_mask, OV5_FORM1_AFFINITY); 158462ef3760SMichael Roth spapr_ovec_set(ov5_mask, OV5_DRCONF_MEMORY); 158562ef3760SMichael Roth 158662ef3760SMichael Roth /* spapr_ovec_diff returns true if bits were removed. we avoid using 158762ef3760SMichael Roth * the mask itself since in the future it's possible "legacy" bits may be 158862ef3760SMichael Roth * removed via machine options, which could generate a false positive 158962ef3760SMichael Roth * that breaks migration. 159062ef3760SMichael Roth */ 159162ef3760SMichael Roth spapr_ovec_intersect(ov5_legacy, spapr->ov5, ov5_mask); 159262ef3760SMichael Roth cas_needed = spapr_ovec_diff(ov5_removed, spapr->ov5, ov5_legacy); 159362ef3760SMichael Roth 159462ef3760SMichael Roth spapr_ovec_cleanup(ov5_mask); 159562ef3760SMichael Roth spapr_ovec_cleanup(ov5_legacy); 159662ef3760SMichael Roth spapr_ovec_cleanup(ov5_removed); 159762ef3760SMichael Roth 159862ef3760SMichael Roth return cas_needed; 159962ef3760SMichael Roth } 160062ef3760SMichael Roth 160162ef3760SMichael Roth static const VMStateDescription vmstate_spapr_ov5_cas = { 160262ef3760SMichael Roth .name = "spapr_option_vector_ov5_cas", 160362ef3760SMichael Roth .version_id = 1, 160462ef3760SMichael Roth .minimum_version_id = 1, 160562ef3760SMichael Roth .needed = spapr_ov5_cas_needed, 160662ef3760SMichael Roth .fields = (VMStateField[]) { 160762ef3760SMichael Roth VMSTATE_STRUCT_POINTER_V(ov5_cas, sPAPRMachineState, 1, 160862ef3760SMichael Roth vmstate_spapr_ovec, sPAPROptionVector), 160962ef3760SMichael Roth VMSTATE_END_OF_LIST() 161062ef3760SMichael Roth }, 161162ef3760SMichael Roth }; 161262ef3760SMichael Roth 16139861bb3eSSuraj Jitindar Singh static bool spapr_patb_entry_needed(void *opaque) 16149861bb3eSSuraj Jitindar Singh { 16159861bb3eSSuraj Jitindar Singh sPAPRMachineState *spapr = opaque; 16169861bb3eSSuraj Jitindar Singh 16179861bb3eSSuraj Jitindar Singh return !!spapr->patb_entry; 16189861bb3eSSuraj Jitindar Singh } 16199861bb3eSSuraj Jitindar Singh 16209861bb3eSSuraj Jitindar Singh static const VMStateDescription vmstate_spapr_patb_entry = { 16219861bb3eSSuraj Jitindar Singh .name = "spapr_patb_entry", 16229861bb3eSSuraj Jitindar Singh .version_id = 1, 16239861bb3eSSuraj Jitindar Singh .minimum_version_id = 1, 16249861bb3eSSuraj Jitindar Singh .needed = spapr_patb_entry_needed, 16259861bb3eSSuraj Jitindar Singh .fields = (VMStateField[]) { 16269861bb3eSSuraj Jitindar Singh VMSTATE_UINT64(patb_entry, sPAPRMachineState), 16279861bb3eSSuraj Jitindar Singh VMSTATE_END_OF_LIST() 16289861bb3eSSuraj Jitindar Singh }, 16299861bb3eSSuraj Jitindar Singh }; 16309861bb3eSSuraj Jitindar Singh 16314be21d56SDavid Gibson static const VMStateDescription vmstate_spapr = { 16324be21d56SDavid Gibson .name = "spapr", 1633880ae7deSDavid Gibson .version_id = 3, 16344be21d56SDavid Gibson .minimum_version_id = 1, 1635880ae7deSDavid Gibson .post_load = spapr_post_load, 16364be21d56SDavid Gibson .fields = (VMStateField[]) { 1637880ae7deSDavid Gibson /* used to be @next_irq */ 1638880ae7deSDavid Gibson VMSTATE_UNUSED_BUFFER(version_before_3, 0, 4), 16394be21d56SDavid Gibson 16404be21d56SDavid Gibson /* RTC offset */ 164128e02042SDavid Gibson VMSTATE_UINT64_TEST(rtc_offset, sPAPRMachineState, version_before_3), 1642880ae7deSDavid Gibson 164328e02042SDavid Gibson VMSTATE_PPC_TIMEBASE_V(tb, sPAPRMachineState, 2), 16444be21d56SDavid Gibson VMSTATE_END_OF_LIST() 16454be21d56SDavid Gibson }, 164662ef3760SMichael Roth .subsections = (const VMStateDescription*[]) { 164762ef3760SMichael Roth &vmstate_spapr_ov5_cas, 16489861bb3eSSuraj Jitindar Singh &vmstate_spapr_patb_entry, 1649fd38804bSDaniel Henrique Barboza &vmstate_spapr_pending_events, 165062ef3760SMichael Roth NULL 165162ef3760SMichael Roth } 16524be21d56SDavid Gibson }; 16534be21d56SDavid Gibson 16544be21d56SDavid Gibson static int htab_save_setup(QEMUFile *f, void *opaque) 16554be21d56SDavid Gibson { 165628e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 16574be21d56SDavid Gibson 16584be21d56SDavid Gibson /* "Iteration" header */ 16593a384297SBharata B Rao if (!spapr->htab_shift) { 16603a384297SBharata B Rao qemu_put_be32(f, -1); 16613a384297SBharata B Rao } else { 16624be21d56SDavid Gibson qemu_put_be32(f, spapr->htab_shift); 16633a384297SBharata B Rao } 16644be21d56SDavid Gibson 1665e68cb8b4SAlexey Kardashevskiy if (spapr->htab) { 1666e68cb8b4SAlexey Kardashevskiy spapr->htab_save_index = 0; 1667e68cb8b4SAlexey Kardashevskiy spapr->htab_first_pass = true; 1668e68cb8b4SAlexey Kardashevskiy } else { 16693a384297SBharata B Rao if (spapr->htab_shift) { 1670e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 16714be21d56SDavid Gibson } 16723a384297SBharata B Rao } 16734be21d56SDavid Gibson 1674e68cb8b4SAlexey Kardashevskiy 1675e68cb8b4SAlexey Kardashevskiy return 0; 1676e68cb8b4SAlexey Kardashevskiy } 16774be21d56SDavid Gibson 167828e02042SDavid Gibson static void htab_save_first_pass(QEMUFile *f, sPAPRMachineState *spapr, 16794be21d56SDavid Gibson int64_t max_ns) 16804be21d56SDavid Gibson { 1681378bc217SDavid Gibson bool has_timeout = max_ns != -1; 16824be21d56SDavid Gibson int htabslots = HTAB_SIZE(spapr) / HASH_PTE_SIZE_64; 16834be21d56SDavid Gibson int index = spapr->htab_save_index; 1684bc72ad67SAlex Bligh int64_t starttime = qemu_clock_get_ns(QEMU_CLOCK_REALTIME); 16854be21d56SDavid Gibson 16864be21d56SDavid Gibson assert(spapr->htab_first_pass); 16874be21d56SDavid Gibson 16884be21d56SDavid Gibson do { 16894be21d56SDavid Gibson int chunkstart; 16904be21d56SDavid Gibson 16914be21d56SDavid Gibson /* Consume invalid HPTEs */ 16924be21d56SDavid Gibson while ((index < htabslots) 16934be21d56SDavid Gibson && !HPTE_VALID(HPTE(spapr->htab, index))) { 16944be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 169524ec2863SMarc-André Lureau index++; 16964be21d56SDavid Gibson } 16974be21d56SDavid Gibson 16984be21d56SDavid Gibson /* Consume valid HPTEs */ 16994be21d56SDavid Gibson chunkstart = index; 1700338c25b6SSamuel Mendoza-Jonas while ((index < htabslots) && (index - chunkstart < USHRT_MAX) 17014be21d56SDavid Gibson && HPTE_VALID(HPTE(spapr->htab, index))) { 17024be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 170324ec2863SMarc-André Lureau index++; 17044be21d56SDavid Gibson } 17054be21d56SDavid Gibson 17064be21d56SDavid Gibson if (index > chunkstart) { 17074be21d56SDavid Gibson int n_valid = index - chunkstart; 17084be21d56SDavid Gibson 17094be21d56SDavid Gibson qemu_put_be32(f, chunkstart); 17104be21d56SDavid Gibson qemu_put_be16(f, n_valid); 17114be21d56SDavid Gibson qemu_put_be16(f, 0); 17124be21d56SDavid Gibson qemu_put_buffer(f, HPTE(spapr->htab, chunkstart), 17134be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_valid); 17144be21d56SDavid Gibson 1715378bc217SDavid Gibson if (has_timeout && 1716378bc217SDavid Gibson (qemu_clock_get_ns(QEMU_CLOCK_REALTIME) - starttime) > max_ns) { 17174be21d56SDavid Gibson break; 17184be21d56SDavid Gibson } 17194be21d56SDavid Gibson } 17204be21d56SDavid Gibson } while ((index < htabslots) && !qemu_file_rate_limit(f)); 17214be21d56SDavid Gibson 17224be21d56SDavid Gibson if (index >= htabslots) { 17234be21d56SDavid Gibson assert(index == htabslots); 17244be21d56SDavid Gibson index = 0; 17254be21d56SDavid Gibson spapr->htab_first_pass = false; 17264be21d56SDavid Gibson } 17274be21d56SDavid Gibson spapr->htab_save_index = index; 17284be21d56SDavid Gibson } 17294be21d56SDavid Gibson 173028e02042SDavid Gibson static int htab_save_later_pass(QEMUFile *f, sPAPRMachineState *spapr, 17314be21d56SDavid Gibson int64_t max_ns) 17324be21d56SDavid Gibson { 17334be21d56SDavid Gibson bool final = max_ns < 0; 17344be21d56SDavid Gibson int htabslots = HTAB_SIZE(spapr) / HASH_PTE_SIZE_64; 17354be21d56SDavid Gibson int examined = 0, sent = 0; 17364be21d56SDavid Gibson int index = spapr->htab_save_index; 1737bc72ad67SAlex Bligh int64_t starttime = qemu_clock_get_ns(QEMU_CLOCK_REALTIME); 17384be21d56SDavid Gibson 17394be21d56SDavid Gibson assert(!spapr->htab_first_pass); 17404be21d56SDavid Gibson 17414be21d56SDavid Gibson do { 17424be21d56SDavid Gibson int chunkstart, invalidstart; 17434be21d56SDavid Gibson 17444be21d56SDavid Gibson /* Consume non-dirty HPTEs */ 17454be21d56SDavid Gibson while ((index < htabslots) 17464be21d56SDavid Gibson && !HPTE_DIRTY(HPTE(spapr->htab, index))) { 17474be21d56SDavid Gibson index++; 17484be21d56SDavid Gibson examined++; 17494be21d56SDavid Gibson } 17504be21d56SDavid Gibson 17514be21d56SDavid Gibson chunkstart = index; 17524be21d56SDavid Gibson /* Consume valid dirty HPTEs */ 1753338c25b6SSamuel Mendoza-Jonas while ((index < htabslots) && (index - chunkstart < USHRT_MAX) 17544be21d56SDavid Gibson && HPTE_DIRTY(HPTE(spapr->htab, index)) 17554be21d56SDavid Gibson && HPTE_VALID(HPTE(spapr->htab, index))) { 17564be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 17574be21d56SDavid Gibson index++; 17584be21d56SDavid Gibson examined++; 17594be21d56SDavid Gibson } 17604be21d56SDavid Gibson 17614be21d56SDavid Gibson invalidstart = index; 17624be21d56SDavid Gibson /* Consume invalid dirty HPTEs */ 1763338c25b6SSamuel Mendoza-Jonas while ((index < htabslots) && (index - invalidstart < USHRT_MAX) 17644be21d56SDavid Gibson && HPTE_DIRTY(HPTE(spapr->htab, index)) 17654be21d56SDavid Gibson && !HPTE_VALID(HPTE(spapr->htab, index))) { 17664be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 17674be21d56SDavid Gibson index++; 17684be21d56SDavid Gibson examined++; 17694be21d56SDavid Gibson } 17704be21d56SDavid Gibson 17714be21d56SDavid Gibson if (index > chunkstart) { 17724be21d56SDavid Gibson int n_valid = invalidstart - chunkstart; 17734be21d56SDavid Gibson int n_invalid = index - invalidstart; 17744be21d56SDavid Gibson 17754be21d56SDavid Gibson qemu_put_be32(f, chunkstart); 17764be21d56SDavid Gibson qemu_put_be16(f, n_valid); 17774be21d56SDavid Gibson qemu_put_be16(f, n_invalid); 17784be21d56SDavid Gibson qemu_put_buffer(f, HPTE(spapr->htab, chunkstart), 17794be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_valid); 17804be21d56SDavid Gibson sent += index - chunkstart; 17814be21d56SDavid Gibson 1782bc72ad67SAlex Bligh if (!final && (qemu_clock_get_ns(QEMU_CLOCK_REALTIME) - starttime) > max_ns) { 17834be21d56SDavid Gibson break; 17844be21d56SDavid Gibson } 17854be21d56SDavid Gibson } 17864be21d56SDavid Gibson 17874be21d56SDavid Gibson if (examined >= htabslots) { 17884be21d56SDavid Gibson break; 17894be21d56SDavid Gibson } 17904be21d56SDavid Gibson 17914be21d56SDavid Gibson if (index >= htabslots) { 17924be21d56SDavid Gibson assert(index == htabslots); 17934be21d56SDavid Gibson index = 0; 17944be21d56SDavid Gibson } 17954be21d56SDavid Gibson } while ((examined < htabslots) && (!qemu_file_rate_limit(f) || final)); 17964be21d56SDavid Gibson 17974be21d56SDavid Gibson if (index >= htabslots) { 17984be21d56SDavid Gibson assert(index == htabslots); 17994be21d56SDavid Gibson index = 0; 18004be21d56SDavid Gibson } 18014be21d56SDavid Gibson 18024be21d56SDavid Gibson spapr->htab_save_index = index; 18034be21d56SDavid Gibson 1804e68cb8b4SAlexey Kardashevskiy return (examined >= htabslots) && (sent == 0) ? 1 : 0; 18054be21d56SDavid Gibson } 18064be21d56SDavid Gibson 1807e68cb8b4SAlexey Kardashevskiy #define MAX_ITERATION_NS 5000000 /* 5 ms */ 1808e68cb8b4SAlexey Kardashevskiy #define MAX_KVM_BUF_SIZE 2048 1809e68cb8b4SAlexey Kardashevskiy 18104be21d56SDavid Gibson static int htab_save_iterate(QEMUFile *f, void *opaque) 18114be21d56SDavid Gibson { 181228e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 1813715c5407SDavid Gibson int fd; 1814e68cb8b4SAlexey Kardashevskiy int rc = 0; 18154be21d56SDavid Gibson 18164be21d56SDavid Gibson /* Iteration header */ 18173a384297SBharata B Rao if (!spapr->htab_shift) { 18183a384297SBharata B Rao qemu_put_be32(f, -1); 18193a384297SBharata B Rao return 0; 18203a384297SBharata B Rao } else { 18214be21d56SDavid Gibson qemu_put_be32(f, 0); 18223a384297SBharata B Rao } 18234be21d56SDavid Gibson 1824e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1825e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 1826e68cb8b4SAlexey Kardashevskiy 1827715c5407SDavid Gibson fd = get_htab_fd(spapr); 1828715c5407SDavid Gibson if (fd < 0) { 1829715c5407SDavid Gibson return fd; 183001a57972SSamuel Mendoza-Jonas } 183101a57972SSamuel Mendoza-Jonas 1832715c5407SDavid Gibson rc = kvmppc_save_htab(f, fd, MAX_KVM_BUF_SIZE, MAX_ITERATION_NS); 1833e68cb8b4SAlexey Kardashevskiy if (rc < 0) { 1834e68cb8b4SAlexey Kardashevskiy return rc; 1835e68cb8b4SAlexey Kardashevskiy } 1836e68cb8b4SAlexey Kardashevskiy } else if (spapr->htab_first_pass) { 18374be21d56SDavid Gibson htab_save_first_pass(f, spapr, MAX_ITERATION_NS); 18384be21d56SDavid Gibson } else { 1839e68cb8b4SAlexey Kardashevskiy rc = htab_save_later_pass(f, spapr, MAX_ITERATION_NS); 18404be21d56SDavid Gibson } 18414be21d56SDavid Gibson 18424be21d56SDavid Gibson /* End marker */ 18434be21d56SDavid Gibson qemu_put_be32(f, 0); 18444be21d56SDavid Gibson qemu_put_be16(f, 0); 18454be21d56SDavid Gibson qemu_put_be16(f, 0); 18464be21d56SDavid Gibson 1847e68cb8b4SAlexey Kardashevskiy return rc; 18484be21d56SDavid Gibson } 18494be21d56SDavid Gibson 18504be21d56SDavid Gibson static int htab_save_complete(QEMUFile *f, void *opaque) 18514be21d56SDavid Gibson { 185228e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 1853715c5407SDavid Gibson int fd; 18544be21d56SDavid Gibson 18554be21d56SDavid Gibson /* Iteration header */ 18563a384297SBharata B Rao if (!spapr->htab_shift) { 18573a384297SBharata B Rao qemu_put_be32(f, -1); 18583a384297SBharata B Rao return 0; 18593a384297SBharata B Rao } else { 18604be21d56SDavid Gibson qemu_put_be32(f, 0); 18613a384297SBharata B Rao } 18624be21d56SDavid Gibson 1863e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1864e68cb8b4SAlexey Kardashevskiy int rc; 1865e68cb8b4SAlexey Kardashevskiy 1866e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 1867e68cb8b4SAlexey Kardashevskiy 1868715c5407SDavid Gibson fd = get_htab_fd(spapr); 1869715c5407SDavid Gibson if (fd < 0) { 1870715c5407SDavid Gibson return fd; 187101a57972SSamuel Mendoza-Jonas } 187201a57972SSamuel Mendoza-Jonas 1873715c5407SDavid Gibson rc = kvmppc_save_htab(f, fd, MAX_KVM_BUF_SIZE, -1); 1874e68cb8b4SAlexey Kardashevskiy if (rc < 0) { 1875e68cb8b4SAlexey Kardashevskiy return rc; 1876e68cb8b4SAlexey Kardashevskiy } 1877e68cb8b4SAlexey Kardashevskiy } else { 1878378bc217SDavid Gibson if (spapr->htab_first_pass) { 1879378bc217SDavid Gibson htab_save_first_pass(f, spapr, -1); 1880378bc217SDavid Gibson } 18814be21d56SDavid Gibson htab_save_later_pass(f, spapr, -1); 1882e68cb8b4SAlexey Kardashevskiy } 18834be21d56SDavid Gibson 18844be21d56SDavid Gibson /* End marker */ 18854be21d56SDavid Gibson qemu_put_be32(f, 0); 18864be21d56SDavid Gibson qemu_put_be16(f, 0); 18874be21d56SDavid Gibson qemu_put_be16(f, 0); 18884be21d56SDavid Gibson 18894be21d56SDavid Gibson return 0; 18904be21d56SDavid Gibson } 18914be21d56SDavid Gibson 18924be21d56SDavid Gibson static int htab_load(QEMUFile *f, void *opaque, int version_id) 18934be21d56SDavid Gibson { 189428e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 18954be21d56SDavid Gibson uint32_t section_hdr; 1896e68cb8b4SAlexey Kardashevskiy int fd = -1; 18974be21d56SDavid Gibson 18984be21d56SDavid Gibson if (version_id < 1 || version_id > 1) { 189998a5d100SDavid Gibson error_report("htab_load() bad version"); 19004be21d56SDavid Gibson return -EINVAL; 19014be21d56SDavid Gibson } 19024be21d56SDavid Gibson 19034be21d56SDavid Gibson section_hdr = qemu_get_be32(f); 19044be21d56SDavid Gibson 19053a384297SBharata B Rao if (section_hdr == -1) { 19063a384297SBharata B Rao spapr_free_hpt(spapr); 19073a384297SBharata B Rao return 0; 19083a384297SBharata B Rao } 19093a384297SBharata B Rao 19104be21d56SDavid Gibson if (section_hdr) { 19119897e462SGreg Kurz Error *local_err = NULL; 1912c5f54f3eSDavid Gibson 1913c5f54f3eSDavid Gibson /* First section gives the htab size */ 1914c5f54f3eSDavid Gibson spapr_reallocate_hpt(spapr, section_hdr, &local_err); 1915c5f54f3eSDavid Gibson if (local_err) { 1916c5f54f3eSDavid Gibson error_report_err(local_err); 19174be21d56SDavid Gibson return -EINVAL; 19184be21d56SDavid Gibson } 19194be21d56SDavid Gibson return 0; 19204be21d56SDavid Gibson } 19214be21d56SDavid Gibson 1922e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1923e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 1924e68cb8b4SAlexey Kardashevskiy 1925e68cb8b4SAlexey Kardashevskiy fd = kvmppc_get_htab_fd(true); 1926e68cb8b4SAlexey Kardashevskiy if (fd < 0) { 192798a5d100SDavid Gibson error_report("Unable to open fd to restore KVM hash table: %s", 1928e68cb8b4SAlexey Kardashevskiy strerror(errno)); 1929e68cb8b4SAlexey Kardashevskiy } 1930e68cb8b4SAlexey Kardashevskiy } 1931e68cb8b4SAlexey Kardashevskiy 19324be21d56SDavid Gibson while (true) { 19334be21d56SDavid Gibson uint32_t index; 19344be21d56SDavid Gibson uint16_t n_valid, n_invalid; 19354be21d56SDavid Gibson 19364be21d56SDavid Gibson index = qemu_get_be32(f); 19374be21d56SDavid Gibson n_valid = qemu_get_be16(f); 19384be21d56SDavid Gibson n_invalid = qemu_get_be16(f); 19394be21d56SDavid Gibson 19404be21d56SDavid Gibson if ((index == 0) && (n_valid == 0) && (n_invalid == 0)) { 19414be21d56SDavid Gibson /* End of Stream */ 19424be21d56SDavid Gibson break; 19434be21d56SDavid Gibson } 19444be21d56SDavid Gibson 1945e68cb8b4SAlexey Kardashevskiy if ((index + n_valid + n_invalid) > 19464be21d56SDavid Gibson (HTAB_SIZE(spapr) / HASH_PTE_SIZE_64)) { 19474be21d56SDavid Gibson /* Bad index in stream */ 194898a5d100SDavid Gibson error_report( 194998a5d100SDavid Gibson "htab_load() bad index %d (%hd+%hd entries) in htab stream (htab_shift=%d)", 195098a5d100SDavid Gibson index, n_valid, n_invalid, spapr->htab_shift); 19514be21d56SDavid Gibson return -EINVAL; 19524be21d56SDavid Gibson } 19534be21d56SDavid Gibson 1954e68cb8b4SAlexey Kardashevskiy if (spapr->htab) { 19554be21d56SDavid Gibson if (n_valid) { 19564be21d56SDavid Gibson qemu_get_buffer(f, HPTE(spapr->htab, index), 19574be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_valid); 19584be21d56SDavid Gibson } 19594be21d56SDavid Gibson if (n_invalid) { 19604be21d56SDavid Gibson memset(HPTE(spapr->htab, index + n_valid), 0, 19614be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_invalid); 19624be21d56SDavid Gibson } 1963e68cb8b4SAlexey Kardashevskiy } else { 1964e68cb8b4SAlexey Kardashevskiy int rc; 1965e68cb8b4SAlexey Kardashevskiy 1966e68cb8b4SAlexey Kardashevskiy assert(fd >= 0); 1967e68cb8b4SAlexey Kardashevskiy 1968e68cb8b4SAlexey Kardashevskiy rc = kvmppc_load_htab_chunk(f, fd, index, n_valid, n_invalid); 1969e68cb8b4SAlexey Kardashevskiy if (rc < 0) { 1970e68cb8b4SAlexey Kardashevskiy return rc; 1971e68cb8b4SAlexey Kardashevskiy } 1972e68cb8b4SAlexey Kardashevskiy } 1973e68cb8b4SAlexey Kardashevskiy } 1974e68cb8b4SAlexey Kardashevskiy 1975e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1976e68cb8b4SAlexey Kardashevskiy assert(fd >= 0); 1977e68cb8b4SAlexey Kardashevskiy close(fd); 19784be21d56SDavid Gibson } 19794be21d56SDavid Gibson 19804be21d56SDavid Gibson return 0; 19814be21d56SDavid Gibson } 19824be21d56SDavid Gibson 198370f794fcSJuan Quintela static void htab_save_cleanup(void *opaque) 1984c573fc03SThomas Huth { 1985c573fc03SThomas Huth sPAPRMachineState *spapr = opaque; 1986c573fc03SThomas Huth 1987c573fc03SThomas Huth close_htab_fd(spapr); 1988c573fc03SThomas Huth } 1989c573fc03SThomas Huth 19904be21d56SDavid Gibson static SaveVMHandlers savevm_htab_handlers = { 19919907e842SJuan Quintela .save_setup = htab_save_setup, 19924be21d56SDavid Gibson .save_live_iterate = htab_save_iterate, 1993a3e06c3dSDr. David Alan Gilbert .save_live_complete_precopy = htab_save_complete, 199470f794fcSJuan Quintela .save_cleanup = htab_save_cleanup, 19954be21d56SDavid Gibson .load_state = htab_load, 19964be21d56SDavid Gibson }; 19974be21d56SDavid Gibson 19985b2128d2SAlexander Graf static void spapr_boot_set(void *opaque, const char *boot_device, 19995b2128d2SAlexander Graf Error **errp) 20005b2128d2SAlexander Graf { 20015b2128d2SAlexander Graf MachineState *machine = MACHINE(qdev_get_machine()); 20025b2128d2SAlexander Graf machine->boot_order = g_strdup(boot_device); 20035b2128d2SAlexander Graf } 20045b2128d2SAlexander Graf 2005224245bfSDavid Gibson static void spapr_create_lmb_dr_connectors(sPAPRMachineState *spapr) 2006224245bfSDavid Gibson { 2007224245bfSDavid Gibson MachineState *machine = MACHINE(spapr); 2008224245bfSDavid Gibson uint64_t lmb_size = SPAPR_MEMORY_BLOCK_SIZE; 2009e8f986fcSBharata B Rao uint32_t nr_lmbs = (machine->maxram_size - machine->ram_size)/lmb_size; 2010224245bfSDavid Gibson int i; 2011224245bfSDavid Gibson 2012224245bfSDavid Gibson for (i = 0; i < nr_lmbs; i++) { 2013224245bfSDavid Gibson uint64_t addr; 2014224245bfSDavid Gibson 2015e8f986fcSBharata B Rao addr = i * lmb_size + spapr->hotplug_memory.base; 20166caf3ac6SDavid Gibson spapr_dr_connector_new(OBJECT(spapr), TYPE_SPAPR_DRC_LMB, 2017224245bfSDavid Gibson addr / lmb_size); 2018224245bfSDavid Gibson } 2019224245bfSDavid Gibson } 2020224245bfSDavid Gibson 2021224245bfSDavid Gibson /* 2022224245bfSDavid Gibson * If RAM size, maxmem size and individual node mem sizes aren't aligned 2023224245bfSDavid Gibson * to SPAPR_MEMORY_BLOCK_SIZE(256MB), then refuse to start the guest 2024224245bfSDavid Gibson * since we can't support such unaligned sizes with DRCONF_MEMORY. 2025224245bfSDavid Gibson */ 20267c150d6fSDavid Gibson static void spapr_validate_node_memory(MachineState *machine, Error **errp) 2027224245bfSDavid Gibson { 2028224245bfSDavid Gibson int i; 2029224245bfSDavid Gibson 20307c150d6fSDavid Gibson if (machine->ram_size % SPAPR_MEMORY_BLOCK_SIZE) { 20317c150d6fSDavid Gibson error_setg(errp, "Memory size 0x" RAM_ADDR_FMT 20327c150d6fSDavid Gibson " is not aligned to %llu MiB", 20337c150d6fSDavid Gibson machine->ram_size, 2034224245bfSDavid Gibson SPAPR_MEMORY_BLOCK_SIZE / M_BYTE); 20357c150d6fSDavid Gibson return; 20367c150d6fSDavid Gibson } 20377c150d6fSDavid Gibson 20387c150d6fSDavid Gibson if (machine->maxram_size % SPAPR_MEMORY_BLOCK_SIZE) { 20397c150d6fSDavid Gibson error_setg(errp, "Maximum memory size 0x" RAM_ADDR_FMT 20407c150d6fSDavid Gibson " is not aligned to %llu MiB", 20417c150d6fSDavid Gibson machine->ram_size, 20427c150d6fSDavid Gibson SPAPR_MEMORY_BLOCK_SIZE / M_BYTE); 20437c150d6fSDavid Gibson return; 2044224245bfSDavid Gibson } 2045224245bfSDavid Gibson 2046224245bfSDavid Gibson for (i = 0; i < nb_numa_nodes; i++) { 2047224245bfSDavid Gibson if (numa_info[i].node_mem % SPAPR_MEMORY_BLOCK_SIZE) { 20487c150d6fSDavid Gibson error_setg(errp, 20497c150d6fSDavid Gibson "Node %d memory size 0x%" PRIx64 20507c150d6fSDavid Gibson " is not aligned to %llu MiB", 20517c150d6fSDavid Gibson i, numa_info[i].node_mem, 2052224245bfSDavid Gibson SPAPR_MEMORY_BLOCK_SIZE / M_BYTE); 20537c150d6fSDavid Gibson return; 2054224245bfSDavid Gibson } 2055224245bfSDavid Gibson } 2056224245bfSDavid Gibson } 2057224245bfSDavid Gibson 2058535455fdSIgor Mammedov /* find cpu slot in machine->possible_cpus by core_id */ 2059535455fdSIgor Mammedov static CPUArchId *spapr_find_cpu_slot(MachineState *ms, uint32_t id, int *idx) 2060535455fdSIgor Mammedov { 2061535455fdSIgor Mammedov int index = id / smp_threads; 2062535455fdSIgor Mammedov 2063535455fdSIgor Mammedov if (index >= ms->possible_cpus->len) { 2064535455fdSIgor Mammedov return NULL; 2065535455fdSIgor Mammedov } 2066535455fdSIgor Mammedov if (idx) { 2067535455fdSIgor Mammedov *idx = index; 2068535455fdSIgor Mammedov } 2069535455fdSIgor Mammedov return &ms->possible_cpus->cpus[index]; 2070535455fdSIgor Mammedov } 2071535455fdSIgor Mammedov 20720c86d0fdSDavid Gibson static void spapr_init_cpus(sPAPRMachineState *spapr) 20730c86d0fdSDavid Gibson { 20740c86d0fdSDavid Gibson MachineState *machine = MACHINE(spapr); 20750c86d0fdSDavid Gibson MachineClass *mc = MACHINE_GET_CLASS(machine); 20760c86d0fdSDavid Gibson char *type = spapr_get_cpu_core_type(machine->cpu_model); 20770c86d0fdSDavid Gibson int smt = kvmppc_smt_threads(); 2078535455fdSIgor Mammedov const CPUArchIdList *possible_cpus; 2079535455fdSIgor Mammedov int boot_cores_nr = smp_cpus / smp_threads; 20800c86d0fdSDavid Gibson int i; 20810c86d0fdSDavid Gibson 20820c86d0fdSDavid Gibson if (!type) { 20830c86d0fdSDavid Gibson error_report("Unable to find sPAPR CPU Core definition"); 20840c86d0fdSDavid Gibson exit(1); 20850c86d0fdSDavid Gibson } 20860c86d0fdSDavid Gibson 2087535455fdSIgor Mammedov possible_cpus = mc->possible_cpu_arch_ids(machine); 2088c5514d0eSIgor Mammedov if (mc->has_hotpluggable_cpus) { 20890c86d0fdSDavid Gibson if (smp_cpus % smp_threads) { 20900c86d0fdSDavid Gibson error_report("smp_cpus (%u) must be multiple of threads (%u)", 20910c86d0fdSDavid Gibson smp_cpus, smp_threads); 20920c86d0fdSDavid Gibson exit(1); 20930c86d0fdSDavid Gibson } 20940c86d0fdSDavid Gibson if (max_cpus % smp_threads) { 20950c86d0fdSDavid Gibson error_report("max_cpus (%u) must be multiple of threads (%u)", 20960c86d0fdSDavid Gibson max_cpus, smp_threads); 20970c86d0fdSDavid Gibson exit(1); 20980c86d0fdSDavid Gibson } 20990c86d0fdSDavid Gibson } else { 21000c86d0fdSDavid Gibson if (max_cpus != smp_cpus) { 21010c86d0fdSDavid Gibson error_report("This machine version does not support CPU hotplug"); 21020c86d0fdSDavid Gibson exit(1); 21030c86d0fdSDavid Gibson } 2104535455fdSIgor Mammedov boot_cores_nr = possible_cpus->len; 21050c86d0fdSDavid Gibson } 21060c86d0fdSDavid Gibson 2107535455fdSIgor Mammedov for (i = 0; i < possible_cpus->len; i++) { 21080c86d0fdSDavid Gibson int core_id = i * smp_threads; 21090c86d0fdSDavid Gibson 2110c5514d0eSIgor Mammedov if (mc->has_hotpluggable_cpus) { 21112d335818SDavid Gibson spapr_dr_connector_new(OBJECT(spapr), TYPE_SPAPR_DRC_CPU, 21120c86d0fdSDavid Gibson (core_id / smp_threads) * smt); 21130c86d0fdSDavid Gibson } 21140c86d0fdSDavid Gibson 2115535455fdSIgor Mammedov if (i < boot_cores_nr) { 21160c86d0fdSDavid Gibson Object *core = object_new(type); 21170c86d0fdSDavid Gibson int nr_threads = smp_threads; 21180c86d0fdSDavid Gibson 21190c86d0fdSDavid Gibson /* Handle the partially filled core for older machine types */ 21200c86d0fdSDavid Gibson if ((i + 1) * smp_threads >= smp_cpus) { 21210c86d0fdSDavid Gibson nr_threads = smp_cpus - i * smp_threads; 21220c86d0fdSDavid Gibson } 21230c86d0fdSDavid Gibson 21240c86d0fdSDavid Gibson object_property_set_int(core, nr_threads, "nr-threads", 21250c86d0fdSDavid Gibson &error_fatal); 21260c86d0fdSDavid Gibson object_property_set_int(core, core_id, CPU_CORE_PROP_CORE_ID, 21270c86d0fdSDavid Gibson &error_fatal); 21280c86d0fdSDavid Gibson object_property_set_bool(core, true, "realized", &error_fatal); 21290c86d0fdSDavid Gibson } 21300c86d0fdSDavid Gibson } 21310c86d0fdSDavid Gibson g_free(type); 21320c86d0fdSDavid Gibson } 21330c86d0fdSDavid Gibson 213453018216SPaolo Bonzini /* pSeries LPAR / sPAPR hardware init */ 21353ef96221SMarcel Apfelbaum static void ppc_spapr_init(MachineState *machine) 213653018216SPaolo Bonzini { 213728e02042SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(machine); 2138224245bfSDavid Gibson sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(machine); 21393ef96221SMarcel Apfelbaum const char *kernel_filename = machine->kernel_filename; 21403ef96221SMarcel Apfelbaum const char *initrd_filename = machine->initrd_filename; 214153018216SPaolo Bonzini PCIHostState *phb; 214253018216SPaolo Bonzini int i; 214353018216SPaolo Bonzini MemoryRegion *sysmem = get_system_memory(); 214453018216SPaolo Bonzini MemoryRegion *ram = g_new(MemoryRegion, 1); 2145658fa66bSAlexey Kardashevskiy MemoryRegion *rma_region; 2146658fa66bSAlexey Kardashevskiy void *rma = NULL; 214753018216SPaolo Bonzini hwaddr rma_alloc_size; 2148b082d65aSAlexey Kardashevskiy hwaddr node0_size = spapr_node0_size(); 2149b7d1f77aSBenjamin Herrenschmidt long load_limit, fw_size; 215053018216SPaolo Bonzini char *filename; 215153018216SPaolo Bonzini 2152226419d6SMichael S. Tsirkin msi_nonbroken = true; 215353018216SPaolo Bonzini 215453018216SPaolo Bonzini QLIST_INIT(&spapr->phbs); 21550cffce56SDavid Gibson QTAILQ_INIT(&spapr->pending_dimm_unplugs); 215653018216SPaolo Bonzini 215753018216SPaolo Bonzini /* Allocate RMA if necessary */ 2158658fa66bSAlexey Kardashevskiy rma_alloc_size = kvmppc_alloc_rma(&rma); 215953018216SPaolo Bonzini 216053018216SPaolo Bonzini if (rma_alloc_size == -1) { 2161730fce59SThomas Huth error_report("Unable to create RMA"); 216253018216SPaolo Bonzini exit(1); 216353018216SPaolo Bonzini } 216453018216SPaolo Bonzini 2165c4177479SAlexey Kardashevskiy if (rma_alloc_size && (rma_alloc_size < node0_size)) { 216653018216SPaolo Bonzini spapr->rma_size = rma_alloc_size; 216753018216SPaolo Bonzini } else { 2168c4177479SAlexey Kardashevskiy spapr->rma_size = node0_size; 216953018216SPaolo Bonzini 217053018216SPaolo Bonzini /* With KVM, we don't actually know whether KVM supports an 217153018216SPaolo Bonzini * unbounded RMA (PR KVM) or is limited by the hash table size 217253018216SPaolo Bonzini * (HV KVM using VRMA), so we always assume the latter 217353018216SPaolo Bonzini * 217453018216SPaolo Bonzini * In that case, we also limit the initial allocations for RTAS 217553018216SPaolo Bonzini * etc... to 256M since we have no way to know what the VRMA size 217653018216SPaolo Bonzini * is going to be as it depends on the size of the hash table 217753018216SPaolo Bonzini * isn't determined yet. 217853018216SPaolo Bonzini */ 217953018216SPaolo Bonzini if (kvm_enabled()) { 218053018216SPaolo Bonzini spapr->vrma_adjust = 1; 218153018216SPaolo Bonzini spapr->rma_size = MIN(spapr->rma_size, 0x10000000); 218253018216SPaolo Bonzini } 2183912acdf4SBenjamin Herrenschmidt 2184912acdf4SBenjamin Herrenschmidt /* Actually we don't support unbounded RMA anymore since we 2185912acdf4SBenjamin Herrenschmidt * added proper emulation of HV mode. The max we can get is 2186912acdf4SBenjamin Herrenschmidt * 16G which also happens to be what we configure for PAPR 2187912acdf4SBenjamin Herrenschmidt * mode so make sure we don't do anything bigger than that 2188912acdf4SBenjamin Herrenschmidt */ 2189912acdf4SBenjamin Herrenschmidt spapr->rma_size = MIN(spapr->rma_size, 0x400000000ull); 219053018216SPaolo Bonzini } 219153018216SPaolo Bonzini 2192c4177479SAlexey Kardashevskiy if (spapr->rma_size > node0_size) { 2193d54e4d76SDavid Gibson error_report("Numa node 0 has to span the RMA (%#08"HWADDR_PRIx")", 2194c4177479SAlexey Kardashevskiy spapr->rma_size); 2195c4177479SAlexey Kardashevskiy exit(1); 2196c4177479SAlexey Kardashevskiy } 2197c4177479SAlexey Kardashevskiy 2198b7d1f77aSBenjamin Herrenschmidt /* Setup a load limit for the ramdisk leaving room for SLOF and FDT */ 2199b7d1f77aSBenjamin Herrenschmidt load_limit = MIN(spapr->rma_size, RTAS_MAX_ADDR) - FW_OVERHEAD; 220053018216SPaolo Bonzini 22017b565160SDavid Gibson /* Set up Interrupt Controller before we create the VCPUs */ 220271cd4dacSCédric Le Goater xics_system_init(machine, XICS_IRQS_SPAPR, &error_fatal); 22037b565160SDavid Gibson 2204facdb8b6SMichael Roth /* Set up containers for ibm,client-set-architecture negotiated options */ 2205facdb8b6SMichael Roth spapr->ov5 = spapr_ovec_new(); 2206facdb8b6SMichael Roth spapr->ov5_cas = spapr_ovec_new(); 2207facdb8b6SMichael Roth 2208224245bfSDavid Gibson if (smc->dr_lmb_enabled) { 2209facdb8b6SMichael Roth spapr_ovec_set(spapr->ov5, OV5_DRCONF_MEMORY); 22107c150d6fSDavid Gibson spapr_validate_node_memory(machine, &error_fatal); 2211224245bfSDavid Gibson } 2212224245bfSDavid Gibson 2213417ece33SMichael Roth spapr_ovec_set(spapr->ov5, OV5_FORM1_AFFINITY); 2214545d6e2bSSuraj Jitindar Singh if (!kvm_enabled() || kvmppc_has_cap_mmu_radix()) { 2215545d6e2bSSuraj Jitindar Singh /* KVM and TCG always allow GTSE with radix... */ 22169fb4541fSSam Bobroff spapr_ovec_set(spapr->ov5, OV5_MMU_RADIX_GTSE); 22179fb4541fSSam Bobroff } 22189fb4541fSSam Bobroff /* ... but not with hash (currently). */ 2219417ece33SMichael Roth 2220ffbb1705SMichael Roth /* advertise support for dedicated HP event source to guests */ 2221ffbb1705SMichael Roth if (spapr->use_hotplug_event_source) { 2222ffbb1705SMichael Roth spapr_ovec_set(spapr->ov5, OV5_HP_EVT); 2223ffbb1705SMichael Roth } 2224ffbb1705SMichael Roth 222553018216SPaolo Bonzini /* init CPUs */ 222619fb2c36SBharata B Rao if (machine->cpu_model == NULL) { 22273daa4a9fSThomas Huth machine->cpu_model = kvm_enabled() ? "host" : smc->tcg_default_cpu; 222853018216SPaolo Bonzini } 222994a94e4cSBharata B Rao 22307843c0d6SDavid Gibson spapr_cpu_parse_features(spapr); 2231e703d2f7SGreg Kurz 22320c86d0fdSDavid Gibson spapr_init_cpus(spapr); 223353018216SPaolo Bonzini 2234026bfd89SDavid Gibson if (kvm_enabled()) { 2235026bfd89SDavid Gibson /* Enable H_LOGICAL_CI_* so SLOF can talk to in-kernel devices */ 2236026bfd89SDavid Gibson kvmppc_enable_logical_ci_hcalls(); 2237ef9971ddSAlexey Kardashevskiy kvmppc_enable_set_mode_hcall(); 22385145ad4fSNathan Whitehorn 22395145ad4fSNathan Whitehorn /* H_CLEAR_MOD/_REF are mandatory in PAPR, but off by default */ 22405145ad4fSNathan Whitehorn kvmppc_enable_clear_ref_mod_hcalls(); 2241026bfd89SDavid Gibson } 2242026bfd89SDavid Gibson 224353018216SPaolo Bonzini /* allocate RAM */ 2244f92f5da1SAlexey Kardashevskiy memory_region_allocate_system_memory(ram, NULL, "ppc_spapr.ram", 2245fb164994SDavid Gibson machine->ram_size); 2246f92f5da1SAlexey Kardashevskiy memory_region_add_subregion(sysmem, 0, ram); 224753018216SPaolo Bonzini 2248658fa66bSAlexey Kardashevskiy if (rma_alloc_size && rma) { 2249658fa66bSAlexey Kardashevskiy rma_region = g_new(MemoryRegion, 1); 2250658fa66bSAlexey Kardashevskiy memory_region_init_ram_ptr(rma_region, NULL, "ppc_spapr.rma", 2251658fa66bSAlexey Kardashevskiy rma_alloc_size, rma); 2252658fa66bSAlexey Kardashevskiy vmstate_register_ram_global(rma_region); 2253658fa66bSAlexey Kardashevskiy memory_region_add_subregion(sysmem, 0, rma_region); 2254658fa66bSAlexey Kardashevskiy } 2255658fa66bSAlexey Kardashevskiy 22564a1c9cf0SBharata B Rao /* initialize hotplug memory address space */ 22574a1c9cf0SBharata B Rao if (machine->ram_size < machine->maxram_size) { 22584a1c9cf0SBharata B Rao ram_addr_t hotplug_mem_size = machine->maxram_size - machine->ram_size; 225971c9a3ddSBharata B Rao /* 226071c9a3ddSBharata B Rao * Limit the number of hotpluggable memory slots to half the number 226171c9a3ddSBharata B Rao * slots that KVM supports, leaving the other half for PCI and other 226271c9a3ddSBharata B Rao * devices. However ensure that number of slots doesn't drop below 32. 226371c9a3ddSBharata B Rao */ 226471c9a3ddSBharata B Rao int max_memslots = kvm_enabled() ? kvm_get_max_memslots() / 2 : 226571c9a3ddSBharata B Rao SPAPR_MAX_RAM_SLOTS; 22664a1c9cf0SBharata B Rao 226771c9a3ddSBharata B Rao if (max_memslots < SPAPR_MAX_RAM_SLOTS) { 226871c9a3ddSBharata B Rao max_memslots = SPAPR_MAX_RAM_SLOTS; 226971c9a3ddSBharata B Rao } 227071c9a3ddSBharata B Rao if (machine->ram_slots > max_memslots) { 2271d54e4d76SDavid Gibson error_report("Specified number of memory slots %" 2272d54e4d76SDavid Gibson PRIu64" exceeds max supported %d", 227371c9a3ddSBharata B Rao machine->ram_slots, max_memslots); 2274d54e4d76SDavid Gibson exit(1); 22754a1c9cf0SBharata B Rao } 22764a1c9cf0SBharata B Rao 22774a1c9cf0SBharata B Rao spapr->hotplug_memory.base = ROUND_UP(machine->ram_size, 22784a1c9cf0SBharata B Rao SPAPR_HOTPLUG_MEM_ALIGN); 22794a1c9cf0SBharata B Rao memory_region_init(&spapr->hotplug_memory.mr, OBJECT(spapr), 22804a1c9cf0SBharata B Rao "hotplug-memory", hotplug_mem_size); 22814a1c9cf0SBharata B Rao memory_region_add_subregion(sysmem, spapr->hotplug_memory.base, 22824a1c9cf0SBharata B Rao &spapr->hotplug_memory.mr); 22834a1c9cf0SBharata B Rao } 22844a1c9cf0SBharata B Rao 2285224245bfSDavid Gibson if (smc->dr_lmb_enabled) { 2286224245bfSDavid Gibson spapr_create_lmb_dr_connectors(spapr); 2287224245bfSDavid Gibson } 2288224245bfSDavid Gibson 228953018216SPaolo Bonzini filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, "spapr-rtas.bin"); 22904c56440dSStefan Weil if (!filename) { 2291730fce59SThomas Huth error_report("Could not find LPAR rtas '%s'", "spapr-rtas.bin"); 22924c56440dSStefan Weil exit(1); 22934c56440dSStefan Weil } 2294b7d1f77aSBenjamin Herrenschmidt spapr->rtas_size = get_image_size(filename); 22958afc22a2SZhou Jie if (spapr->rtas_size < 0) { 22968afc22a2SZhou Jie error_report("Could not get size of LPAR rtas '%s'", filename); 22978afc22a2SZhou Jie exit(1); 22988afc22a2SZhou Jie } 2299b7d1f77aSBenjamin Herrenschmidt spapr->rtas_blob = g_malloc(spapr->rtas_size); 2300b7d1f77aSBenjamin Herrenschmidt if (load_image_size(filename, spapr->rtas_blob, spapr->rtas_size) < 0) { 2301730fce59SThomas Huth error_report("Could not load LPAR rtas '%s'", filename); 230253018216SPaolo Bonzini exit(1); 230353018216SPaolo Bonzini } 230453018216SPaolo Bonzini if (spapr->rtas_size > RTAS_MAX_SIZE) { 2305730fce59SThomas Huth error_report("RTAS too big ! 0x%zx bytes (max is 0x%x)", 23062f285bddSPeter Maydell (size_t)spapr->rtas_size, RTAS_MAX_SIZE); 230753018216SPaolo Bonzini exit(1); 230853018216SPaolo Bonzini } 230953018216SPaolo Bonzini g_free(filename); 231053018216SPaolo Bonzini 2311ffbb1705SMichael Roth /* Set up RTAS event infrastructure */ 231253018216SPaolo Bonzini spapr_events_init(spapr); 231353018216SPaolo Bonzini 231412f42174SDavid Gibson /* Set up the RTC RTAS interfaces */ 231528df36a1SDavid Gibson spapr_rtc_create(spapr); 231612f42174SDavid Gibson 231753018216SPaolo Bonzini /* Set up VIO bus */ 231853018216SPaolo Bonzini spapr->vio_bus = spapr_vio_bus_init(); 231953018216SPaolo Bonzini 232053018216SPaolo Bonzini for (i = 0; i < MAX_SERIAL_PORTS; i++) { 232153018216SPaolo Bonzini if (serial_hds[i]) { 232253018216SPaolo Bonzini spapr_vty_create(spapr->vio_bus, serial_hds[i]); 232353018216SPaolo Bonzini } 232453018216SPaolo Bonzini } 232553018216SPaolo Bonzini 232653018216SPaolo Bonzini /* We always have at least the nvram device on VIO */ 232753018216SPaolo Bonzini spapr_create_nvram(spapr); 232853018216SPaolo Bonzini 232953018216SPaolo Bonzini /* Set up PCI */ 233053018216SPaolo Bonzini spapr_pci_rtas_init(); 233153018216SPaolo Bonzini 233289dfd6e1SDavid Gibson phb = spapr_create_phb(spapr, 0); 233353018216SPaolo Bonzini 233453018216SPaolo Bonzini for (i = 0; i < nb_nics; i++) { 233553018216SPaolo Bonzini NICInfo *nd = &nd_table[i]; 233653018216SPaolo Bonzini 233753018216SPaolo Bonzini if (!nd->model) { 233853018216SPaolo Bonzini nd->model = g_strdup("ibmveth"); 233953018216SPaolo Bonzini } 234053018216SPaolo Bonzini 234153018216SPaolo Bonzini if (strcmp(nd->model, "ibmveth") == 0) { 234253018216SPaolo Bonzini spapr_vlan_create(spapr->vio_bus, nd); 234353018216SPaolo Bonzini } else { 234429b358f9SDavid Gibson pci_nic_init_nofail(&nd_table[i], phb->bus, nd->model, NULL); 234553018216SPaolo Bonzini } 234653018216SPaolo Bonzini } 234753018216SPaolo Bonzini 234853018216SPaolo Bonzini for (i = 0; i <= drive_get_max_bus(IF_SCSI); i++) { 234953018216SPaolo Bonzini spapr_vscsi_create(spapr->vio_bus); 235053018216SPaolo Bonzini } 235153018216SPaolo Bonzini 235253018216SPaolo Bonzini /* Graphics */ 235314c6a894SDavid Gibson if (spapr_vga_init(phb->bus, &error_fatal)) { 235453018216SPaolo Bonzini spapr->has_graphics = true; 2355c6e76503SPaolo Bonzini machine->usb |= defaults_enabled() && !machine->usb_disabled; 235653018216SPaolo Bonzini } 235753018216SPaolo Bonzini 23584ee9ced9SMarcel Apfelbaum if (machine->usb) { 235957040d45SThomas Huth if (smc->use_ohci_by_default) { 236053018216SPaolo Bonzini pci_create_simple(phb->bus, -1, "pci-ohci"); 236157040d45SThomas Huth } else { 236257040d45SThomas Huth pci_create_simple(phb->bus, -1, "nec-usb-xhci"); 236357040d45SThomas Huth } 2364c86580b8SMarkus Armbruster 236553018216SPaolo Bonzini if (spapr->has_graphics) { 2366c86580b8SMarkus Armbruster USBBus *usb_bus = usb_bus_find(-1); 2367c86580b8SMarkus Armbruster 2368c86580b8SMarkus Armbruster usb_create_simple(usb_bus, "usb-kbd"); 2369c86580b8SMarkus Armbruster usb_create_simple(usb_bus, "usb-mouse"); 237053018216SPaolo Bonzini } 237153018216SPaolo Bonzini } 237253018216SPaolo Bonzini 237353018216SPaolo Bonzini if (spapr->rma_size < (MIN_RMA_SLOF << 20)) { 2374d54e4d76SDavid Gibson error_report( 2375d54e4d76SDavid Gibson "pSeries SLOF firmware requires >= %ldM guest RMA (Real Mode Area memory)", 2376d54e4d76SDavid Gibson MIN_RMA_SLOF); 237753018216SPaolo Bonzini exit(1); 237853018216SPaolo Bonzini } 237953018216SPaolo Bonzini 238053018216SPaolo Bonzini if (kernel_filename) { 238153018216SPaolo Bonzini uint64_t lowaddr = 0; 238253018216SPaolo Bonzini 2383a19f7fb0SDavid Gibson spapr->kernel_size = load_elf(kernel_filename, translate_kernel_address, 2384a19f7fb0SDavid Gibson NULL, NULL, &lowaddr, NULL, 1, 2385a19f7fb0SDavid Gibson PPC_ELF_MACHINE, 0, 0); 2386a19f7fb0SDavid Gibson if (spapr->kernel_size == ELF_LOAD_WRONG_ENDIAN) { 2387a19f7fb0SDavid Gibson spapr->kernel_size = load_elf(kernel_filename, 2388a19f7fb0SDavid Gibson translate_kernel_address, NULL, NULL, 2389a19f7fb0SDavid Gibson &lowaddr, NULL, 0, PPC_ELF_MACHINE, 23907ef295eaSPeter Crosthwaite 0, 0); 2391a19f7fb0SDavid Gibson spapr->kernel_le = spapr->kernel_size > 0; 239216457e7fSBenjamin Herrenschmidt } 2393a19f7fb0SDavid Gibson if (spapr->kernel_size < 0) { 2394a19f7fb0SDavid Gibson error_report("error loading %s: %s", kernel_filename, 2395a19f7fb0SDavid Gibson load_elf_strerror(spapr->kernel_size)); 239653018216SPaolo Bonzini exit(1); 239753018216SPaolo Bonzini } 239853018216SPaolo Bonzini 239953018216SPaolo Bonzini /* load initrd */ 240053018216SPaolo Bonzini if (initrd_filename) { 240153018216SPaolo Bonzini /* Try to locate the initrd in the gap between the kernel 240253018216SPaolo Bonzini * and the firmware. Add a bit of space just in case 240353018216SPaolo Bonzini */ 2404a19f7fb0SDavid Gibson spapr->initrd_base = (KERNEL_LOAD_ADDR + spapr->kernel_size 2405a19f7fb0SDavid Gibson + 0x1ffff) & ~0xffff; 2406a19f7fb0SDavid Gibson spapr->initrd_size = load_image_targphys(initrd_filename, 2407a19f7fb0SDavid Gibson spapr->initrd_base, 2408a19f7fb0SDavid Gibson load_limit 2409a19f7fb0SDavid Gibson - spapr->initrd_base); 2410a19f7fb0SDavid Gibson if (spapr->initrd_size < 0) { 2411d54e4d76SDavid Gibson error_report("could not load initial ram disk '%s'", 241253018216SPaolo Bonzini initrd_filename); 241353018216SPaolo Bonzini exit(1); 241453018216SPaolo Bonzini } 241553018216SPaolo Bonzini } 241653018216SPaolo Bonzini } 241753018216SPaolo Bonzini 24188e7ea787SAndreas Färber if (bios_name == NULL) { 24198e7ea787SAndreas Färber bios_name = FW_FILE_NAME; 24208e7ea787SAndreas Färber } 24218e7ea787SAndreas Färber filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name); 24224c56440dSStefan Weil if (!filename) { 242368fea5a0SThomas Huth error_report("Could not find LPAR firmware '%s'", bios_name); 24244c56440dSStefan Weil exit(1); 24254c56440dSStefan Weil } 242653018216SPaolo Bonzini fw_size = load_image_targphys(filename, 0, FW_MAX_SIZE); 242768fea5a0SThomas Huth if (fw_size <= 0) { 242868fea5a0SThomas Huth error_report("Could not load LPAR firmware '%s'", filename); 242953018216SPaolo Bonzini exit(1); 243053018216SPaolo Bonzini } 243153018216SPaolo Bonzini g_free(filename); 243253018216SPaolo Bonzini 243328e02042SDavid Gibson /* FIXME: Should register things through the MachineState's qdev 243428e02042SDavid Gibson * interface, this is a legacy from the sPAPREnvironment structure 243528e02042SDavid Gibson * which predated MachineState but had a similar function */ 24364be21d56SDavid Gibson vmstate_register(NULL, 0, &vmstate_spapr, spapr); 24374be21d56SDavid Gibson register_savevm_live(NULL, "spapr/htab", -1, 1, 24384be21d56SDavid Gibson &savevm_htab_handlers, spapr); 24394be21d56SDavid Gibson 24405b2128d2SAlexander Graf qemu_register_boot_set(spapr_boot_set, spapr); 244142043e4fSLaurent Vivier 244242043e4fSLaurent Vivier if (kvm_enabled()) { 24433dc410aeSAlexey Kardashevskiy /* to stop and start vmclock */ 244442043e4fSLaurent Vivier qemu_add_vm_change_state_handler(cpu_ppc_clock_vm_state_change, 244542043e4fSLaurent Vivier &spapr->tb); 24463dc410aeSAlexey Kardashevskiy 24473dc410aeSAlexey Kardashevskiy kvmppc_spapr_enable_inkernel_multitce(); 244842043e4fSLaurent Vivier } 244953018216SPaolo Bonzini } 245053018216SPaolo Bonzini 2451135a129aSAneesh Kumar K.V static int spapr_kvm_type(const char *vm_type) 2452135a129aSAneesh Kumar K.V { 2453135a129aSAneesh Kumar K.V if (!vm_type) { 2454135a129aSAneesh Kumar K.V return 0; 2455135a129aSAneesh Kumar K.V } 2456135a129aSAneesh Kumar K.V 2457135a129aSAneesh Kumar K.V if (!strcmp(vm_type, "HV")) { 2458135a129aSAneesh Kumar K.V return 1; 2459135a129aSAneesh Kumar K.V } 2460135a129aSAneesh Kumar K.V 2461135a129aSAneesh Kumar K.V if (!strcmp(vm_type, "PR")) { 2462135a129aSAneesh Kumar K.V return 2; 2463135a129aSAneesh Kumar K.V } 2464135a129aSAneesh Kumar K.V 2465135a129aSAneesh Kumar K.V error_report("Unknown kvm-type specified '%s'", vm_type); 2466135a129aSAneesh Kumar K.V exit(1); 2467135a129aSAneesh Kumar K.V } 2468135a129aSAneesh Kumar K.V 246971461b0fSAlexey Kardashevskiy /* 2470627b84f4SGonglei * Implementation of an interface to adjust firmware path 247171461b0fSAlexey Kardashevskiy * for the bootindex property handling. 247271461b0fSAlexey Kardashevskiy */ 247371461b0fSAlexey Kardashevskiy static char *spapr_get_fw_dev_path(FWPathProvider *p, BusState *bus, 247471461b0fSAlexey Kardashevskiy DeviceState *dev) 247571461b0fSAlexey Kardashevskiy { 247671461b0fSAlexey Kardashevskiy #define CAST(type, obj, name) \ 247771461b0fSAlexey Kardashevskiy ((type *)object_dynamic_cast(OBJECT(obj), (name))) 247871461b0fSAlexey Kardashevskiy SCSIDevice *d = CAST(SCSIDevice, dev, TYPE_SCSI_DEVICE); 247971461b0fSAlexey Kardashevskiy sPAPRPHBState *phb = CAST(sPAPRPHBState, dev, TYPE_SPAPR_PCI_HOST_BRIDGE); 2480c4e13492SFelipe Franciosi VHostSCSICommon *vsc = CAST(VHostSCSICommon, dev, TYPE_VHOST_SCSI_COMMON); 248171461b0fSAlexey Kardashevskiy 248271461b0fSAlexey Kardashevskiy if (d) { 248371461b0fSAlexey Kardashevskiy void *spapr = CAST(void, bus->parent, "spapr-vscsi"); 248471461b0fSAlexey Kardashevskiy VirtIOSCSI *virtio = CAST(VirtIOSCSI, bus->parent, TYPE_VIRTIO_SCSI); 248571461b0fSAlexey Kardashevskiy USBDevice *usb = CAST(USBDevice, bus->parent, TYPE_USB_DEVICE); 248671461b0fSAlexey Kardashevskiy 248771461b0fSAlexey Kardashevskiy if (spapr) { 248871461b0fSAlexey Kardashevskiy /* 248971461b0fSAlexey Kardashevskiy * Replace "channel@0/disk@0,0" with "disk@8000000000000000": 249071461b0fSAlexey Kardashevskiy * We use SRP luns of the form 8000 | (bus << 8) | (id << 5) | lun 249171461b0fSAlexey Kardashevskiy * in the top 16 bits of the 64-bit LUN 249271461b0fSAlexey Kardashevskiy */ 249371461b0fSAlexey Kardashevskiy unsigned id = 0x8000 | (d->id << 8) | d->lun; 249471461b0fSAlexey Kardashevskiy return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev), 249571461b0fSAlexey Kardashevskiy (uint64_t)id << 48); 249671461b0fSAlexey Kardashevskiy } else if (virtio) { 249771461b0fSAlexey Kardashevskiy /* 249871461b0fSAlexey Kardashevskiy * We use SRP luns of the form 01000000 | (target << 8) | lun 249971461b0fSAlexey Kardashevskiy * in the top 32 bits of the 64-bit LUN 250071461b0fSAlexey Kardashevskiy * Note: the quote above is from SLOF and it is wrong, 250171461b0fSAlexey Kardashevskiy * the actual binding is: 250271461b0fSAlexey Kardashevskiy * swap 0100 or 10 << or 20 << ( target lun-id -- srplun ) 250371461b0fSAlexey Kardashevskiy */ 250471461b0fSAlexey Kardashevskiy unsigned id = 0x1000000 | (d->id << 16) | d->lun; 250571461b0fSAlexey Kardashevskiy return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev), 250671461b0fSAlexey Kardashevskiy (uint64_t)id << 32); 250771461b0fSAlexey Kardashevskiy } else if (usb) { 250871461b0fSAlexey Kardashevskiy /* 250971461b0fSAlexey Kardashevskiy * We use SRP luns of the form 01000000 | (usb-port << 16) | lun 251071461b0fSAlexey Kardashevskiy * in the top 32 bits of the 64-bit LUN 251171461b0fSAlexey Kardashevskiy */ 251271461b0fSAlexey Kardashevskiy unsigned usb_port = atoi(usb->port->path); 251371461b0fSAlexey Kardashevskiy unsigned id = 0x1000000 | (usb_port << 16) | d->lun; 251471461b0fSAlexey Kardashevskiy return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev), 251571461b0fSAlexey Kardashevskiy (uint64_t)id << 32); 251671461b0fSAlexey Kardashevskiy } 251771461b0fSAlexey Kardashevskiy } 251871461b0fSAlexey Kardashevskiy 2519b99260ebSThomas Huth /* 2520b99260ebSThomas Huth * SLOF probes the USB devices, and if it recognizes that the device is a 2521b99260ebSThomas Huth * storage device, it changes its name to "storage" instead of "usb-host", 2522b99260ebSThomas Huth * and additionally adds a child node for the SCSI LUN, so the correct 2523b99260ebSThomas Huth * boot path in SLOF is something like .../storage@1/disk@xxx" instead. 2524b99260ebSThomas Huth */ 2525b99260ebSThomas Huth if (strcmp("usb-host", qdev_fw_name(dev)) == 0) { 2526b99260ebSThomas Huth USBDevice *usbdev = CAST(USBDevice, dev, TYPE_USB_DEVICE); 2527b99260ebSThomas Huth if (usb_host_dev_is_scsi_storage(usbdev)) { 2528b99260ebSThomas Huth return g_strdup_printf("storage@%s/disk", usbdev->port->path); 2529b99260ebSThomas Huth } 2530b99260ebSThomas Huth } 2531b99260ebSThomas Huth 253271461b0fSAlexey Kardashevskiy if (phb) { 253371461b0fSAlexey Kardashevskiy /* Replace "pci" with "pci@800000020000000" */ 253471461b0fSAlexey Kardashevskiy return g_strdup_printf("pci@%"PRIX64, phb->buid); 253571461b0fSAlexey Kardashevskiy } 253671461b0fSAlexey Kardashevskiy 2537c4e13492SFelipe Franciosi if (vsc) { 2538c4e13492SFelipe Franciosi /* Same logic as virtio above */ 2539c4e13492SFelipe Franciosi unsigned id = 0x1000000 | (vsc->target << 16) | vsc->lun; 2540c4e13492SFelipe Franciosi return g_strdup_printf("disk@%"PRIX64, (uint64_t)id << 32); 2541c4e13492SFelipe Franciosi } 2542c4e13492SFelipe Franciosi 25434871dd4cSThomas Huth if (g_str_equal("pci-bridge", qdev_fw_name(dev))) { 25444871dd4cSThomas Huth /* SLOF uses "pci" instead of "pci-bridge" for PCI bridges */ 25454871dd4cSThomas Huth PCIDevice *pcidev = CAST(PCIDevice, dev, TYPE_PCI_DEVICE); 25464871dd4cSThomas Huth return g_strdup_printf("pci@%x", PCI_SLOT(pcidev->devfn)); 25474871dd4cSThomas Huth } 25484871dd4cSThomas Huth 254971461b0fSAlexey Kardashevskiy return NULL; 255071461b0fSAlexey Kardashevskiy } 255171461b0fSAlexey Kardashevskiy 255223825581SEduardo Habkost static char *spapr_get_kvm_type(Object *obj, Error **errp) 255323825581SEduardo Habkost { 255428e02042SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 255523825581SEduardo Habkost 255628e02042SDavid Gibson return g_strdup(spapr->kvm_type); 255723825581SEduardo Habkost } 255823825581SEduardo Habkost 255923825581SEduardo Habkost static void spapr_set_kvm_type(Object *obj, const char *value, Error **errp) 256023825581SEduardo Habkost { 256128e02042SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 256223825581SEduardo Habkost 256328e02042SDavid Gibson g_free(spapr->kvm_type); 256428e02042SDavid Gibson spapr->kvm_type = g_strdup(value); 256523825581SEduardo Habkost } 256623825581SEduardo Habkost 2567f6229214SMichael Roth static bool spapr_get_modern_hotplug_events(Object *obj, Error **errp) 2568f6229214SMichael Roth { 2569f6229214SMichael Roth sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 2570f6229214SMichael Roth 2571f6229214SMichael Roth return spapr->use_hotplug_event_source; 2572f6229214SMichael Roth } 2573f6229214SMichael Roth 2574f6229214SMichael Roth static void spapr_set_modern_hotplug_events(Object *obj, bool value, 2575f6229214SMichael Roth Error **errp) 2576f6229214SMichael Roth { 2577f6229214SMichael Roth sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 2578f6229214SMichael Roth 2579f6229214SMichael Roth spapr->use_hotplug_event_source = value; 2580f6229214SMichael Roth } 2581f6229214SMichael Roth 258223825581SEduardo Habkost static void spapr_machine_initfn(Object *obj) 258323825581SEduardo Habkost { 2584715c5407SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 2585715c5407SDavid Gibson 2586715c5407SDavid Gibson spapr->htab_fd = -1; 2587f6229214SMichael Roth spapr->use_hotplug_event_source = true; 258823825581SEduardo Habkost object_property_add_str(obj, "kvm-type", 258923825581SEduardo Habkost spapr_get_kvm_type, spapr_set_kvm_type, NULL); 259049d2e648SMarcel Apfelbaum object_property_set_description(obj, "kvm-type", 259149d2e648SMarcel Apfelbaum "Specifies the KVM virtualization mode (HV, PR)", 259249d2e648SMarcel Apfelbaum NULL); 2593f6229214SMichael Roth object_property_add_bool(obj, "modern-hotplug-events", 2594f6229214SMichael Roth spapr_get_modern_hotplug_events, 2595f6229214SMichael Roth spapr_set_modern_hotplug_events, 2596f6229214SMichael Roth NULL); 2597f6229214SMichael Roth object_property_set_description(obj, "modern-hotplug-events", 2598f6229214SMichael Roth "Use dedicated hotplug event mechanism in" 2599f6229214SMichael Roth " place of standard EPOW events when possible" 2600f6229214SMichael Roth " (required for memory hot-unplug support)", 2601f6229214SMichael Roth NULL); 26027843c0d6SDavid Gibson 26037843c0d6SDavid Gibson ppc_compat_add_property(obj, "max-cpu-compat", &spapr->max_compat_pvr, 26047843c0d6SDavid Gibson "Maximum permitted CPU compatibility mode", 26057843c0d6SDavid Gibson &error_fatal); 260623825581SEduardo Habkost } 260723825581SEduardo Habkost 260887bbdd9cSDavid Gibson static void spapr_machine_finalizefn(Object *obj) 260987bbdd9cSDavid Gibson { 261087bbdd9cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 261187bbdd9cSDavid Gibson 261287bbdd9cSDavid Gibson g_free(spapr->kvm_type); 261387bbdd9cSDavid Gibson } 261487bbdd9cSDavid Gibson 26151c7ad77eSNicholas Piggin void spapr_do_system_reset_on_cpu(CPUState *cs, run_on_cpu_data arg) 261634316482SAlexey Kardashevskiy { 261734316482SAlexey Kardashevskiy cpu_synchronize_state(cs); 261834316482SAlexey Kardashevskiy ppc_cpu_do_system_reset(cs); 261934316482SAlexey Kardashevskiy } 262034316482SAlexey Kardashevskiy 262134316482SAlexey Kardashevskiy static void spapr_nmi(NMIState *n, int cpu_index, Error **errp) 262234316482SAlexey Kardashevskiy { 262334316482SAlexey Kardashevskiy CPUState *cs; 262434316482SAlexey Kardashevskiy 262534316482SAlexey Kardashevskiy CPU_FOREACH(cs) { 26261c7ad77eSNicholas Piggin async_run_on_cpu(cs, spapr_do_system_reset_on_cpu, RUN_ON_CPU_NULL); 262734316482SAlexey Kardashevskiy } 262834316482SAlexey Kardashevskiy } 262934316482SAlexey Kardashevskiy 263079b78a6bSMichael Roth static void spapr_add_lmbs(DeviceState *dev, uint64_t addr_start, uint64_t size, 263179b78a6bSMichael Roth uint32_t node, bool dedicated_hp_event_source, 263279b78a6bSMichael Roth Error **errp) 2633c20d332aSBharata B Rao { 2634c20d332aSBharata B Rao sPAPRDRConnector *drc; 2635c20d332aSBharata B Rao uint32_t nr_lmbs = size/SPAPR_MEMORY_BLOCK_SIZE; 2636c20d332aSBharata B Rao int i, fdt_offset, fdt_size; 2637c20d332aSBharata B Rao void *fdt; 263879b78a6bSMichael Roth uint64_t addr = addr_start; 263994fd9cbaSLaurent Vivier bool hotplugged = spapr_drc_hotplugged(dev); 2640160bb678SGreg Kurz Error *local_err = NULL; 2641c20d332aSBharata B Rao 2642c20d332aSBharata B Rao for (i = 0; i < nr_lmbs; i++) { 2643fbf55397SDavid Gibson drc = spapr_drc_by_id(TYPE_SPAPR_DRC_LMB, 2644c20d332aSBharata B Rao addr / SPAPR_MEMORY_BLOCK_SIZE); 2645c20d332aSBharata B Rao g_assert(drc); 2646c20d332aSBharata B Rao 2647c20d332aSBharata B Rao fdt = create_device_tree(&fdt_size); 2648c20d332aSBharata B Rao fdt_offset = spapr_populate_memory_node(fdt, node, addr, 2649c20d332aSBharata B Rao SPAPR_MEMORY_BLOCK_SIZE); 2650c20d332aSBharata B Rao 2651160bb678SGreg Kurz spapr_drc_attach(drc, dev, fdt, fdt_offset, &local_err); 2652160bb678SGreg Kurz if (local_err) { 2653160bb678SGreg Kurz while (addr > addr_start) { 2654160bb678SGreg Kurz addr -= SPAPR_MEMORY_BLOCK_SIZE; 2655160bb678SGreg Kurz drc = spapr_drc_by_id(TYPE_SPAPR_DRC_LMB, 2656160bb678SGreg Kurz addr / SPAPR_MEMORY_BLOCK_SIZE); 2657*a8dc47fdSDavid Gibson spapr_drc_detach(drc); 2658160bb678SGreg Kurz } 2659160bb678SGreg Kurz g_free(fdt); 2660160bb678SGreg Kurz error_propagate(errp, local_err); 2661160bb678SGreg Kurz return; 2662160bb678SGreg Kurz } 266394fd9cbaSLaurent Vivier if (!hotplugged) { 266494fd9cbaSLaurent Vivier spapr_drc_reset(drc); 266594fd9cbaSLaurent Vivier } 2666c20d332aSBharata B Rao addr += SPAPR_MEMORY_BLOCK_SIZE; 2667c20d332aSBharata B Rao } 26685dd5238cSJianjun Duan /* send hotplug notification to the 26695dd5238cSJianjun Duan * guest only in case of hotplugged memory 26705dd5238cSJianjun Duan */ 267194fd9cbaSLaurent Vivier if (hotplugged) { 267279b78a6bSMichael Roth if (dedicated_hp_event_source) { 2673fbf55397SDavid Gibson drc = spapr_drc_by_id(TYPE_SPAPR_DRC_LMB, 267479b78a6bSMichael Roth addr_start / SPAPR_MEMORY_BLOCK_SIZE); 267579b78a6bSMichael Roth spapr_hotplug_req_add_by_count_indexed(SPAPR_DR_CONNECTOR_TYPE_LMB, 267679b78a6bSMichael Roth nr_lmbs, 26770b55aa91SDavid Gibson spapr_drc_index(drc)); 267879b78a6bSMichael Roth } else { 267979b78a6bSMichael Roth spapr_hotplug_req_add_by_count(SPAPR_DR_CONNECTOR_TYPE_LMB, 268079b78a6bSMichael Roth nr_lmbs); 268179b78a6bSMichael Roth } 2682c20d332aSBharata B Rao } 26835dd5238cSJianjun Duan } 2684c20d332aSBharata B Rao 2685c20d332aSBharata B Rao static void spapr_memory_plug(HotplugHandler *hotplug_dev, DeviceState *dev, 2686c20d332aSBharata B Rao uint32_t node, Error **errp) 2687c20d332aSBharata B Rao { 2688c20d332aSBharata B Rao Error *local_err = NULL; 2689c20d332aSBharata B Rao sPAPRMachineState *ms = SPAPR_MACHINE(hotplug_dev); 2690c20d332aSBharata B Rao PCDIMMDevice *dimm = PC_DIMM(dev); 2691c20d332aSBharata B Rao PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); 2692c20d332aSBharata B Rao MemoryRegion *mr = ddc->get_memory_region(dimm); 2693c20d332aSBharata B Rao uint64_t align = memory_region_get_alignment(mr); 2694c20d332aSBharata B Rao uint64_t size = memory_region_size(mr); 2695c20d332aSBharata B Rao uint64_t addr; 2696df587133SThomas Huth 2697d6a9b0b8SMichael S. Tsirkin pc_dimm_memory_plug(dev, &ms->hotplug_memory, mr, align, &local_err); 2698c20d332aSBharata B Rao if (local_err) { 2699c20d332aSBharata B Rao goto out; 2700c20d332aSBharata B Rao } 2701c20d332aSBharata B Rao 27029ed442b8SMarc-André Lureau addr = object_property_get_uint(OBJECT(dimm), 27039ed442b8SMarc-André Lureau PC_DIMM_ADDR_PROP, &local_err); 2704c20d332aSBharata B Rao if (local_err) { 2705160bb678SGreg Kurz goto out_unplug; 2706c20d332aSBharata B Rao } 2707c20d332aSBharata B Rao 270879b78a6bSMichael Roth spapr_add_lmbs(dev, addr, size, node, 270979b78a6bSMichael Roth spapr_ovec_test(ms->ov5_cas, OV5_HP_EVT), 2710160bb678SGreg Kurz &local_err); 2711160bb678SGreg Kurz if (local_err) { 2712160bb678SGreg Kurz goto out_unplug; 2713160bb678SGreg Kurz } 2714c20d332aSBharata B Rao 2715160bb678SGreg Kurz return; 2716160bb678SGreg Kurz 2717160bb678SGreg Kurz out_unplug: 2718160bb678SGreg Kurz pc_dimm_memory_unplug(dev, &ms->hotplug_memory, mr); 2719c20d332aSBharata B Rao out: 2720c20d332aSBharata B Rao error_propagate(errp, local_err); 2721c20d332aSBharata B Rao } 2722c20d332aSBharata B Rao 2723c871bc70SLaurent Vivier static void spapr_memory_pre_plug(HotplugHandler *hotplug_dev, DeviceState *dev, 2724c871bc70SLaurent Vivier Error **errp) 2725c871bc70SLaurent Vivier { 2726c871bc70SLaurent Vivier PCDIMMDevice *dimm = PC_DIMM(dev); 2727c871bc70SLaurent Vivier PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); 2728c871bc70SLaurent Vivier MemoryRegion *mr = ddc->get_memory_region(dimm); 2729c871bc70SLaurent Vivier uint64_t size = memory_region_size(mr); 2730c871bc70SLaurent Vivier char *mem_dev; 2731c871bc70SLaurent Vivier 2732c871bc70SLaurent Vivier if (size % SPAPR_MEMORY_BLOCK_SIZE) { 2733c871bc70SLaurent Vivier error_setg(errp, "Hotplugged memory size must be a multiple of " 2734c871bc70SLaurent Vivier "%lld MB", SPAPR_MEMORY_BLOCK_SIZE / M_BYTE); 2735c871bc70SLaurent Vivier return; 2736c871bc70SLaurent Vivier } 2737c871bc70SLaurent Vivier 2738c871bc70SLaurent Vivier mem_dev = object_property_get_str(OBJECT(dimm), PC_DIMM_MEMDEV_PROP, NULL); 2739c871bc70SLaurent Vivier if (mem_dev && !kvmppc_is_mem_backend_page_size_ok(mem_dev)) { 2740c871bc70SLaurent Vivier error_setg(errp, "Memory backend has bad page size. " 2741c871bc70SLaurent Vivier "Use 'memory-backend-file' with correct mem-path."); 27428a9e0e7bSGreg Kurz goto out; 2743c871bc70SLaurent Vivier } 27448a9e0e7bSGreg Kurz 27458a9e0e7bSGreg Kurz out: 27468a9e0e7bSGreg Kurz g_free(mem_dev); 2747c871bc70SLaurent Vivier } 2748c871bc70SLaurent Vivier 27490cffce56SDavid Gibson struct sPAPRDIMMState { 27500cffce56SDavid Gibson PCDIMMDevice *dimm; 2751cf632463SBharata B Rao uint32_t nr_lmbs; 27520cffce56SDavid Gibson QTAILQ_ENTRY(sPAPRDIMMState) next; 27530cffce56SDavid Gibson }; 27540cffce56SDavid Gibson 27550cffce56SDavid Gibson static sPAPRDIMMState *spapr_pending_dimm_unplugs_find(sPAPRMachineState *s, 27560cffce56SDavid Gibson PCDIMMDevice *dimm) 27570cffce56SDavid Gibson { 27580cffce56SDavid Gibson sPAPRDIMMState *dimm_state = NULL; 27590cffce56SDavid Gibson 27600cffce56SDavid Gibson QTAILQ_FOREACH(dimm_state, &s->pending_dimm_unplugs, next) { 27610cffce56SDavid Gibson if (dimm_state->dimm == dimm) { 27620cffce56SDavid Gibson break; 27630cffce56SDavid Gibson } 27640cffce56SDavid Gibson } 27650cffce56SDavid Gibson return dimm_state; 27660cffce56SDavid Gibson } 27670cffce56SDavid Gibson 27680cffce56SDavid Gibson static void spapr_pending_dimm_unplugs_add(sPAPRMachineState *spapr, 27690cffce56SDavid Gibson sPAPRDIMMState *dimm_state) 27700cffce56SDavid Gibson { 27710cffce56SDavid Gibson g_assert(!spapr_pending_dimm_unplugs_find(spapr, dimm_state->dimm)); 27720cffce56SDavid Gibson QTAILQ_INSERT_HEAD(&spapr->pending_dimm_unplugs, dimm_state, next); 27730cffce56SDavid Gibson } 27740cffce56SDavid Gibson 27750cffce56SDavid Gibson static void spapr_pending_dimm_unplugs_remove(sPAPRMachineState *spapr, 27760cffce56SDavid Gibson sPAPRDIMMState *dimm_state) 27770cffce56SDavid Gibson { 27780cffce56SDavid Gibson QTAILQ_REMOVE(&spapr->pending_dimm_unplugs, dimm_state, next); 27790cffce56SDavid Gibson g_free(dimm_state); 27800cffce56SDavid Gibson } 2781cf632463SBharata B Rao 278216ee9980SDaniel Henrique Barboza static sPAPRDIMMState *spapr_recover_pending_dimm_state(sPAPRMachineState *ms, 278316ee9980SDaniel Henrique Barboza PCDIMMDevice *dimm) 278416ee9980SDaniel Henrique Barboza { 278516ee9980SDaniel Henrique Barboza sPAPRDRConnector *drc; 278616ee9980SDaniel Henrique Barboza PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); 278716ee9980SDaniel Henrique Barboza MemoryRegion *mr = ddc->get_memory_region(dimm); 278816ee9980SDaniel Henrique Barboza uint64_t size = memory_region_size(mr); 278916ee9980SDaniel Henrique Barboza uint32_t nr_lmbs = size / SPAPR_MEMORY_BLOCK_SIZE; 279016ee9980SDaniel Henrique Barboza uint32_t avail_lmbs = 0; 279116ee9980SDaniel Henrique Barboza uint64_t addr_start, addr; 279216ee9980SDaniel Henrique Barboza int i; 279316ee9980SDaniel Henrique Barboza sPAPRDIMMState *ds; 279416ee9980SDaniel Henrique Barboza 279516ee9980SDaniel Henrique Barboza addr_start = object_property_get_int(OBJECT(dimm), PC_DIMM_ADDR_PROP, 279616ee9980SDaniel Henrique Barboza &error_abort); 279716ee9980SDaniel Henrique Barboza 279816ee9980SDaniel Henrique Barboza addr = addr_start; 279916ee9980SDaniel Henrique Barboza for (i = 0; i < nr_lmbs; i++) { 2800fbf55397SDavid Gibson drc = spapr_drc_by_id(TYPE_SPAPR_DRC_LMB, 280116ee9980SDaniel Henrique Barboza addr / SPAPR_MEMORY_BLOCK_SIZE); 280216ee9980SDaniel Henrique Barboza g_assert(drc); 2803454b580aSDavid Gibson if (drc->dev) { 280416ee9980SDaniel Henrique Barboza avail_lmbs++; 280516ee9980SDaniel Henrique Barboza } 280616ee9980SDaniel Henrique Barboza addr += SPAPR_MEMORY_BLOCK_SIZE; 280716ee9980SDaniel Henrique Barboza } 280816ee9980SDaniel Henrique Barboza 280916ee9980SDaniel Henrique Barboza ds = g_malloc0(sizeof(sPAPRDIMMState)); 281016ee9980SDaniel Henrique Barboza ds->nr_lmbs = avail_lmbs; 281116ee9980SDaniel Henrique Barboza ds->dimm = dimm; 281216ee9980SDaniel Henrique Barboza spapr_pending_dimm_unplugs_add(ms, ds); 281316ee9980SDaniel Henrique Barboza return ds; 281416ee9980SDaniel Henrique Barboza } 281516ee9980SDaniel Henrique Barboza 281631834723SDaniel Henrique Barboza /* Callback to be called during DRC release. */ 281731834723SDaniel Henrique Barboza void spapr_lmb_release(DeviceState *dev) 2818cf632463SBharata B Rao { 2819765d1bddSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(qdev_get_hotplug_handler(dev)); 2820765d1bddSDavid Gibson PCDIMMDevice *dimm = PC_DIMM(dev); 2821765d1bddSDavid Gibson PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); 2822765d1bddSDavid Gibson MemoryRegion *mr = ddc->get_memory_region(dimm); 28230cffce56SDavid Gibson sPAPRDIMMState *ds = spapr_pending_dimm_unplugs_find(spapr, PC_DIMM(dev)); 2824cf632463SBharata B Rao 282516ee9980SDaniel Henrique Barboza /* This information will get lost if a migration occurs 282616ee9980SDaniel Henrique Barboza * during the unplug process. In this case recover it. */ 282716ee9980SDaniel Henrique Barboza if (ds == NULL) { 282816ee9980SDaniel Henrique Barboza ds = spapr_recover_pending_dimm_state(spapr, PC_DIMM(dev)); 2829454b580aSDavid Gibson /* The DRC being examined by the caller at least must be counted */ 2830454b580aSDavid Gibson g_assert(ds->nr_lmbs); 283116ee9980SDaniel Henrique Barboza } 2832454b580aSDavid Gibson 2833454b580aSDavid Gibson if (--ds->nr_lmbs) { 2834cf632463SBharata B Rao return; 2835cf632463SBharata B Rao } 2836cf632463SBharata B Rao 28370cffce56SDavid Gibson spapr_pending_dimm_unplugs_remove(spapr, ds); 2838cf632463SBharata B Rao 2839cf632463SBharata B Rao /* 2840cf632463SBharata B Rao * Now that all the LMBs have been removed by the guest, call the 2841cf632463SBharata B Rao * pc-dimm unplug handler to cleanup up the pc-dimm device. 2842cf632463SBharata B Rao */ 2843765d1bddSDavid Gibson pc_dimm_memory_unplug(dev, &spapr->hotplug_memory, mr); 2844cf632463SBharata B Rao object_unparent(OBJECT(dev)); 2845cf632463SBharata B Rao } 2846cf632463SBharata B Rao 2847cf632463SBharata B Rao static void spapr_memory_unplug_request(HotplugHandler *hotplug_dev, 2848cf632463SBharata B Rao DeviceState *dev, Error **errp) 2849cf632463SBharata B Rao { 28500cffce56SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(hotplug_dev); 2851cf632463SBharata B Rao Error *local_err = NULL; 2852cf632463SBharata B Rao PCDIMMDevice *dimm = PC_DIMM(dev); 2853cf632463SBharata B Rao PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); 2854cf632463SBharata B Rao MemoryRegion *mr = ddc->get_memory_region(dimm); 2855cf632463SBharata B Rao uint64_t size = memory_region_size(mr); 28560cffce56SDavid Gibson uint32_t nr_lmbs = size / SPAPR_MEMORY_BLOCK_SIZE; 28570cffce56SDavid Gibson uint64_t addr_start, addr; 28580cffce56SDavid Gibson int i; 28590cffce56SDavid Gibson sPAPRDRConnector *drc; 28600cffce56SDavid Gibson sPAPRDIMMState *ds; 2861cf632463SBharata B Rao 28629ed442b8SMarc-André Lureau addr_start = object_property_get_uint(OBJECT(dimm), PC_DIMM_ADDR_PROP, 28630cffce56SDavid Gibson &local_err); 2864cf632463SBharata B Rao if (local_err) { 2865cf632463SBharata B Rao goto out; 2866cf632463SBharata B Rao } 2867cf632463SBharata B Rao 28680cffce56SDavid Gibson ds = g_malloc0(sizeof(sPAPRDIMMState)); 28690cffce56SDavid Gibson ds->nr_lmbs = nr_lmbs; 28700cffce56SDavid Gibson ds->dimm = dimm; 28710cffce56SDavid Gibson spapr_pending_dimm_unplugs_add(spapr, ds); 28720cffce56SDavid Gibson 28730cffce56SDavid Gibson addr = addr_start; 28740cffce56SDavid Gibson for (i = 0; i < nr_lmbs; i++) { 2875fbf55397SDavid Gibson drc = spapr_drc_by_id(TYPE_SPAPR_DRC_LMB, 28760cffce56SDavid Gibson addr / SPAPR_MEMORY_BLOCK_SIZE); 28770cffce56SDavid Gibson g_assert(drc); 28780cffce56SDavid Gibson 2879*a8dc47fdSDavid Gibson spapr_drc_detach(drc); 28800cffce56SDavid Gibson addr += SPAPR_MEMORY_BLOCK_SIZE; 28810cffce56SDavid Gibson } 28820cffce56SDavid Gibson 2883fbf55397SDavid Gibson drc = spapr_drc_by_id(TYPE_SPAPR_DRC_LMB, 28840cffce56SDavid Gibson addr_start / SPAPR_MEMORY_BLOCK_SIZE); 28850cffce56SDavid Gibson spapr_hotplug_req_remove_by_count_indexed(SPAPR_DR_CONNECTOR_TYPE_LMB, 28860b55aa91SDavid Gibson nr_lmbs, spapr_drc_index(drc)); 2887cf632463SBharata B Rao out: 2888cf632463SBharata B Rao error_propagate(errp, local_err); 2889cf632463SBharata B Rao } 2890cf632463SBharata B Rao 289104d0ffbdSGreg Kurz static void *spapr_populate_hotplug_cpu_dt(CPUState *cs, int *fdt_offset, 2892af81cf32SBharata B Rao sPAPRMachineState *spapr) 2893af81cf32SBharata B Rao { 2894af81cf32SBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(cs); 2895af81cf32SBharata B Rao DeviceClass *dc = DEVICE_GET_CLASS(cs); 2896af81cf32SBharata B Rao int id = ppc_get_vcpu_dt_id(cpu); 2897af81cf32SBharata B Rao void *fdt; 2898af81cf32SBharata B Rao int offset, fdt_size; 2899af81cf32SBharata B Rao char *nodename; 2900af81cf32SBharata B Rao 2901af81cf32SBharata B Rao fdt = create_device_tree(&fdt_size); 2902af81cf32SBharata B Rao nodename = g_strdup_printf("%s@%x", dc->fw_name, id); 2903af81cf32SBharata B Rao offset = fdt_add_subnode(fdt, 0, nodename); 2904af81cf32SBharata B Rao 2905af81cf32SBharata B Rao spapr_populate_cpu_dt(cs, fdt, offset, spapr); 2906af81cf32SBharata B Rao g_free(nodename); 2907af81cf32SBharata B Rao 2908af81cf32SBharata B Rao *fdt_offset = offset; 2909af81cf32SBharata B Rao return fdt; 2910af81cf32SBharata B Rao } 2911af81cf32SBharata B Rao 2912765d1bddSDavid Gibson /* Callback to be called during DRC release. */ 2913765d1bddSDavid Gibson void spapr_core_release(DeviceState *dev) 2914ff9006ddSIgor Mammedov { 2915765d1bddSDavid Gibson MachineState *ms = MACHINE(qdev_get_hotplug_handler(dev)); 291646f7afa3SGreg Kurz sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(ms); 2917ff9006ddSIgor Mammedov CPUCore *cc = CPU_CORE(dev); 2918535455fdSIgor Mammedov CPUArchId *core_slot = spapr_find_cpu_slot(ms, cc->core_id, NULL); 2919ff9006ddSIgor Mammedov 292046f7afa3SGreg Kurz if (smc->pre_2_10_has_unused_icps) { 292146f7afa3SGreg Kurz sPAPRCPUCore *sc = SPAPR_CPU_CORE(OBJECT(dev)); 292246f7afa3SGreg Kurz sPAPRCPUCoreClass *scc = SPAPR_CPU_CORE_GET_CLASS(OBJECT(cc)); 292346f7afa3SGreg Kurz const char *typename = object_class_get_name(scc->cpu_class); 292446f7afa3SGreg Kurz size_t size = object_type_get_instance_size(typename); 292546f7afa3SGreg Kurz int i; 292646f7afa3SGreg Kurz 292746f7afa3SGreg Kurz for (i = 0; i < cc->nr_threads; i++) { 292846f7afa3SGreg Kurz CPUState *cs = CPU(sc->threads + i * size); 292946f7afa3SGreg Kurz 293046f7afa3SGreg Kurz pre_2_10_vmstate_register_dummy_icp(cs->cpu_index); 293146f7afa3SGreg Kurz } 293246f7afa3SGreg Kurz } 293346f7afa3SGreg Kurz 293407572c06SGreg Kurz assert(core_slot); 2935535455fdSIgor Mammedov core_slot->cpu = NULL; 2936ff9006ddSIgor Mammedov object_unparent(OBJECT(dev)); 2937ff9006ddSIgor Mammedov } 2938ff9006ddSIgor Mammedov 2939115debf2SIgor Mammedov static 2940115debf2SIgor Mammedov void spapr_core_unplug_request(HotplugHandler *hotplug_dev, DeviceState *dev, 2941ff9006ddSIgor Mammedov Error **errp) 2942ff9006ddSIgor Mammedov { 2943535455fdSIgor Mammedov int index; 2944535455fdSIgor Mammedov sPAPRDRConnector *drc; 2945535455fdSIgor Mammedov CPUCore *cc = CPU_CORE(dev); 2946535455fdSIgor Mammedov int smt = kvmppc_smt_threads(); 2947ff9006ddSIgor Mammedov 2948535455fdSIgor Mammedov if (!spapr_find_cpu_slot(MACHINE(hotplug_dev), cc->core_id, &index)) { 2949535455fdSIgor Mammedov error_setg(errp, "Unable to find CPU core with core-id: %d", 2950535455fdSIgor Mammedov cc->core_id); 2951535455fdSIgor Mammedov return; 2952535455fdSIgor Mammedov } 2953ff9006ddSIgor Mammedov if (index == 0) { 2954ff9006ddSIgor Mammedov error_setg(errp, "Boot CPU core may not be unplugged"); 2955ff9006ddSIgor Mammedov return; 2956ff9006ddSIgor Mammedov } 2957ff9006ddSIgor Mammedov 2958fbf55397SDavid Gibson drc = spapr_drc_by_id(TYPE_SPAPR_DRC_CPU, index * smt); 2959ff9006ddSIgor Mammedov g_assert(drc); 2960ff9006ddSIgor Mammedov 2961*a8dc47fdSDavid Gibson spapr_drc_detach(drc); 2962ff9006ddSIgor Mammedov 2963ff9006ddSIgor Mammedov spapr_hotplug_req_remove_by_index(drc); 2964ff9006ddSIgor Mammedov } 2965ff9006ddSIgor Mammedov 2966ff9006ddSIgor Mammedov static void spapr_core_plug(HotplugHandler *hotplug_dev, DeviceState *dev, 2967ff9006ddSIgor Mammedov Error **errp) 2968ff9006ddSIgor Mammedov { 2969ff9006ddSIgor Mammedov sPAPRMachineState *spapr = SPAPR_MACHINE(OBJECT(hotplug_dev)); 2970ff9006ddSIgor Mammedov MachineClass *mc = MACHINE_GET_CLASS(spapr); 297146f7afa3SGreg Kurz sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); 2972ff9006ddSIgor Mammedov sPAPRCPUCore *core = SPAPR_CPU_CORE(OBJECT(dev)); 2973ff9006ddSIgor Mammedov CPUCore *cc = CPU_CORE(dev); 2974ff9006ddSIgor Mammedov CPUState *cs = CPU(core->threads); 2975ff9006ddSIgor Mammedov sPAPRDRConnector *drc; 2976ff9006ddSIgor Mammedov Error *local_err = NULL; 2977ff9006ddSIgor Mammedov void *fdt = NULL; 2978ff9006ddSIgor Mammedov int fdt_offset = 0; 2979ff9006ddSIgor Mammedov int smt = kvmppc_smt_threads(); 2980535455fdSIgor Mammedov CPUArchId *core_slot; 2981535455fdSIgor Mammedov int index; 298294fd9cbaSLaurent Vivier bool hotplugged = spapr_drc_hotplugged(dev); 2983ff9006ddSIgor Mammedov 2984535455fdSIgor Mammedov core_slot = spapr_find_cpu_slot(MACHINE(hotplug_dev), cc->core_id, &index); 2985535455fdSIgor Mammedov if (!core_slot) { 2986535455fdSIgor Mammedov error_setg(errp, "Unable to find CPU core with core-id: %d", 2987535455fdSIgor Mammedov cc->core_id); 2988535455fdSIgor Mammedov return; 2989535455fdSIgor Mammedov } 2990fbf55397SDavid Gibson drc = spapr_drc_by_id(TYPE_SPAPR_DRC_CPU, index * smt); 2991ff9006ddSIgor Mammedov 2992c5514d0eSIgor Mammedov g_assert(drc || !mc->has_hotpluggable_cpus); 2993ff9006ddSIgor Mammedov 2994ff9006ddSIgor Mammedov fdt = spapr_populate_hotplug_cpu_dt(cs, &fdt_offset, spapr); 2995ff9006ddSIgor Mammedov 2996ff9006ddSIgor Mammedov if (drc) { 29975c1da812SDavid Gibson spapr_drc_attach(drc, dev, fdt, fdt_offset, &local_err); 2998ff9006ddSIgor Mammedov if (local_err) { 2999ff9006ddSIgor Mammedov g_free(fdt); 3000ff9006ddSIgor Mammedov error_propagate(errp, local_err); 3001ff9006ddSIgor Mammedov return; 3002ff9006ddSIgor Mammedov } 3003ff9006ddSIgor Mammedov 300494fd9cbaSLaurent Vivier if (hotplugged) { 3005ff9006ddSIgor Mammedov /* 300694fd9cbaSLaurent Vivier * Send hotplug notification interrupt to the guest only 300794fd9cbaSLaurent Vivier * in case of hotplugged CPUs. 3008ff9006ddSIgor Mammedov */ 3009ff9006ddSIgor Mammedov spapr_hotplug_req_add_by_index(drc); 301094fd9cbaSLaurent Vivier } else { 301194fd9cbaSLaurent Vivier spapr_drc_reset(drc); 3012ff9006ddSIgor Mammedov } 301394fd9cbaSLaurent Vivier } 301494fd9cbaSLaurent Vivier 3015535455fdSIgor Mammedov core_slot->cpu = OBJECT(dev); 301646f7afa3SGreg Kurz 301746f7afa3SGreg Kurz if (smc->pre_2_10_has_unused_icps) { 301846f7afa3SGreg Kurz sPAPRCPUCoreClass *scc = SPAPR_CPU_CORE_GET_CLASS(OBJECT(cc)); 301946f7afa3SGreg Kurz const char *typename = object_class_get_name(scc->cpu_class); 302046f7afa3SGreg Kurz size_t size = object_type_get_instance_size(typename); 302146f7afa3SGreg Kurz int i; 302246f7afa3SGreg Kurz 302346f7afa3SGreg Kurz for (i = 0; i < cc->nr_threads; i++) { 302446f7afa3SGreg Kurz sPAPRCPUCore *sc = SPAPR_CPU_CORE(dev); 302546f7afa3SGreg Kurz void *obj = sc->threads + i * size; 302646f7afa3SGreg Kurz 302746f7afa3SGreg Kurz cs = CPU(obj); 302846f7afa3SGreg Kurz pre_2_10_vmstate_unregister_dummy_icp(cs->cpu_index); 302946f7afa3SGreg Kurz } 303046f7afa3SGreg Kurz } 3031ff9006ddSIgor Mammedov } 3032ff9006ddSIgor Mammedov 3033ff9006ddSIgor Mammedov static void spapr_core_pre_plug(HotplugHandler *hotplug_dev, DeviceState *dev, 3034ff9006ddSIgor Mammedov Error **errp) 3035ff9006ddSIgor Mammedov { 3036ff9006ddSIgor Mammedov MachineState *machine = MACHINE(OBJECT(hotplug_dev)); 3037ff9006ddSIgor Mammedov MachineClass *mc = MACHINE_GET_CLASS(hotplug_dev); 3038ff9006ddSIgor Mammedov Error *local_err = NULL; 3039ff9006ddSIgor Mammedov CPUCore *cc = CPU_CORE(dev); 3040ff9006ddSIgor Mammedov char *base_core_type = spapr_get_cpu_core_type(machine->cpu_model); 3041ff9006ddSIgor Mammedov const char *type = object_get_typename(OBJECT(dev)); 3042535455fdSIgor Mammedov CPUArchId *core_slot; 3043535455fdSIgor Mammedov int index; 3044ff9006ddSIgor Mammedov 3045c5514d0eSIgor Mammedov if (dev->hotplugged && !mc->has_hotpluggable_cpus) { 3046ff9006ddSIgor Mammedov error_setg(&local_err, "CPU hotplug not supported for this machine"); 3047ff9006ddSIgor Mammedov goto out; 3048ff9006ddSIgor Mammedov } 3049ff9006ddSIgor Mammedov 3050ff9006ddSIgor Mammedov if (strcmp(base_core_type, type)) { 3051ff9006ddSIgor Mammedov error_setg(&local_err, "CPU core type should be %s", base_core_type); 3052ff9006ddSIgor Mammedov goto out; 3053ff9006ddSIgor Mammedov } 3054ff9006ddSIgor Mammedov 3055ff9006ddSIgor Mammedov if (cc->core_id % smp_threads) { 3056ff9006ddSIgor Mammedov error_setg(&local_err, "invalid core id %d", cc->core_id); 3057ff9006ddSIgor Mammedov goto out; 3058ff9006ddSIgor Mammedov } 3059ff9006ddSIgor Mammedov 3060459264efSDavid Gibson /* 3061459264efSDavid Gibson * In general we should have homogeneous threads-per-core, but old 3062459264efSDavid Gibson * (pre hotplug support) machine types allow the last core to have 3063459264efSDavid Gibson * reduced threads as a compatibility hack for when we allowed 3064459264efSDavid Gibson * total vcpus not a multiple of threads-per-core. 3065459264efSDavid Gibson */ 3066459264efSDavid Gibson if (mc->has_hotpluggable_cpus && (cc->nr_threads != smp_threads)) { 30678149e299SDavid Gibson error_setg(errp, "invalid nr-threads %d, must be %d", 30688149e299SDavid Gibson cc->nr_threads, smp_threads); 30698149e299SDavid Gibson return; 30708149e299SDavid Gibson } 30718149e299SDavid Gibson 3072535455fdSIgor Mammedov core_slot = spapr_find_cpu_slot(MACHINE(hotplug_dev), cc->core_id, &index); 3073535455fdSIgor Mammedov if (!core_slot) { 3074ff9006ddSIgor Mammedov error_setg(&local_err, "core id %d out of range", cc->core_id); 3075ff9006ddSIgor Mammedov goto out; 3076ff9006ddSIgor Mammedov } 3077ff9006ddSIgor Mammedov 3078535455fdSIgor Mammedov if (core_slot->cpu) { 3079ff9006ddSIgor Mammedov error_setg(&local_err, "core %d already populated", cc->core_id); 3080ff9006ddSIgor Mammedov goto out; 3081ff9006ddSIgor Mammedov } 3082ff9006ddSIgor Mammedov 3083a0ceb640SIgor Mammedov numa_cpu_pre_plug(core_slot, dev, &local_err); 30840b8497f0SIgor Mammedov 3085ff9006ddSIgor Mammedov out: 3086ff9006ddSIgor Mammedov g_free(base_core_type); 3087ff9006ddSIgor Mammedov error_propagate(errp, local_err); 3088ff9006ddSIgor Mammedov } 3089ff9006ddSIgor Mammedov 3090c20d332aSBharata B Rao static void spapr_machine_device_plug(HotplugHandler *hotplug_dev, 3091c20d332aSBharata B Rao DeviceState *dev, Error **errp) 3092c20d332aSBharata B Rao { 3093c20d332aSBharata B Rao sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(qdev_get_machine()); 3094c20d332aSBharata B Rao 3095c20d332aSBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { 3096b556854bSBharata B Rao int node; 3097c20d332aSBharata B Rao 3098c20d332aSBharata B Rao if (!smc->dr_lmb_enabled) { 3099c20d332aSBharata B Rao error_setg(errp, "Memory hotplug not supported for this machine"); 3100c20d332aSBharata B Rao return; 3101c20d332aSBharata B Rao } 31029ed442b8SMarc-André Lureau node = object_property_get_uint(OBJECT(dev), PC_DIMM_NODE_PROP, errp); 3103c20d332aSBharata B Rao if (*errp) { 3104c20d332aSBharata B Rao return; 3105c20d332aSBharata B Rao } 31061a5512bbSGonglei if (node < 0 || node >= MAX_NODES) { 31071a5512bbSGonglei error_setg(errp, "Invaild node %d", node); 31081a5512bbSGonglei return; 31091a5512bbSGonglei } 3110c20d332aSBharata B Rao 3111b556854bSBharata B Rao /* 3112b556854bSBharata B Rao * Currently PowerPC kernel doesn't allow hot-adding memory to 3113b556854bSBharata B Rao * memory-less node, but instead will silently add the memory 3114b556854bSBharata B Rao * to the first node that has some memory. This causes two 3115b556854bSBharata B Rao * unexpected behaviours for the user. 3116b556854bSBharata B Rao * 3117b556854bSBharata B Rao * - Memory gets hotplugged to a different node than what the user 3118b556854bSBharata B Rao * specified. 3119b556854bSBharata B Rao * - Since pc-dimm subsystem in QEMU still thinks that memory belongs 3120b556854bSBharata B Rao * to memory-less node, a reboot will set things accordingly 3121b556854bSBharata B Rao * and the previously hotplugged memory now ends in the right node. 3122b556854bSBharata B Rao * This appears as if some memory moved from one node to another. 3123b556854bSBharata B Rao * 3124b556854bSBharata B Rao * So until kernel starts supporting memory hotplug to memory-less 3125b556854bSBharata B Rao * nodes, just prevent such attempts upfront in QEMU. 3126b556854bSBharata B Rao */ 3127b556854bSBharata B Rao if (nb_numa_nodes && !numa_info[node].node_mem) { 3128b556854bSBharata B Rao error_setg(errp, "Can't hotplug memory to memory-less node %d", 3129b556854bSBharata B Rao node); 3130b556854bSBharata B Rao return; 3131b556854bSBharata B Rao } 3132b556854bSBharata B Rao 3133c20d332aSBharata B Rao spapr_memory_plug(hotplug_dev, dev, node, errp); 3134af81cf32SBharata B Rao } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 3135af81cf32SBharata B Rao spapr_core_plug(hotplug_dev, dev, errp); 3136c20d332aSBharata B Rao } 3137c20d332aSBharata B Rao } 3138c20d332aSBharata B Rao 3139cf632463SBharata B Rao static void spapr_machine_device_unplug_request(HotplugHandler *hotplug_dev, 3140cf632463SBharata B Rao DeviceState *dev, Error **errp) 3141cf632463SBharata B Rao { 3142cf632463SBharata B Rao sPAPRMachineState *sms = SPAPR_MACHINE(qdev_get_machine()); 3143cf632463SBharata B Rao MachineClass *mc = MACHINE_GET_CLASS(qdev_get_machine()); 3144cf632463SBharata B Rao 3145cf632463SBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { 3146cf632463SBharata B Rao if (spapr_ovec_test(sms->ov5_cas, OV5_HP_EVT)) { 3147cf632463SBharata B Rao spapr_memory_unplug_request(hotplug_dev, dev, errp); 3148cf632463SBharata B Rao } else { 3149cf632463SBharata B Rao /* NOTE: this means there is a window after guest reset, prior to 3150cf632463SBharata B Rao * CAS negotiation, where unplug requests will fail due to the 3151cf632463SBharata B Rao * capability not being detected yet. This is a bit different than 3152cf632463SBharata B Rao * the case with PCI unplug, where the events will be queued and 3153cf632463SBharata B Rao * eventually handled by the guest after boot 3154cf632463SBharata B Rao */ 3155cf632463SBharata B Rao error_setg(errp, "Memory hot unplug not supported for this guest"); 3156cf632463SBharata B Rao } 31576f4b5c3eSBharata B Rao } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 3158c5514d0eSIgor Mammedov if (!mc->has_hotpluggable_cpus) { 31596f4b5c3eSBharata B Rao error_setg(errp, "CPU hot unplug not supported on this machine"); 31606f4b5c3eSBharata B Rao return; 31616f4b5c3eSBharata B Rao } 3162115debf2SIgor Mammedov spapr_core_unplug_request(hotplug_dev, dev, errp); 3163c20d332aSBharata B Rao } 3164c20d332aSBharata B Rao } 3165c20d332aSBharata B Rao 316694a94e4cSBharata B Rao static void spapr_machine_device_pre_plug(HotplugHandler *hotplug_dev, 316794a94e4cSBharata B Rao DeviceState *dev, Error **errp) 316894a94e4cSBharata B Rao { 3169c871bc70SLaurent Vivier if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { 3170c871bc70SLaurent Vivier spapr_memory_pre_plug(hotplug_dev, dev, errp); 3171c871bc70SLaurent Vivier } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 317294a94e4cSBharata B Rao spapr_core_pre_plug(hotplug_dev, dev, errp); 317394a94e4cSBharata B Rao } 317494a94e4cSBharata B Rao } 317594a94e4cSBharata B Rao 31767ebaf795SBharata B Rao static HotplugHandler *spapr_get_hotplug_handler(MachineState *machine, 3177c20d332aSBharata B Rao DeviceState *dev) 3178c20d332aSBharata B Rao { 317994a94e4cSBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM) || 318094a94e4cSBharata B Rao object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 3181c20d332aSBharata B Rao return HOTPLUG_HANDLER(machine); 3182c20d332aSBharata B Rao } 3183c20d332aSBharata B Rao return NULL; 3184c20d332aSBharata B Rao } 3185c20d332aSBharata B Rao 3186ea089eebSIgor Mammedov static CpuInstanceProperties 3187ea089eebSIgor Mammedov spapr_cpu_index_to_props(MachineState *machine, unsigned cpu_index) 318820bb648dSDavid Gibson { 3189ea089eebSIgor Mammedov CPUArchId *core_slot; 3190ea089eebSIgor Mammedov MachineClass *mc = MACHINE_GET_CLASS(machine); 3191ea089eebSIgor Mammedov 3192ea089eebSIgor Mammedov /* make sure possible_cpu are intialized */ 3193ea089eebSIgor Mammedov mc->possible_cpu_arch_ids(machine); 3194ea089eebSIgor Mammedov /* get CPU core slot containing thread that matches cpu_index */ 3195ea089eebSIgor Mammedov core_slot = spapr_find_cpu_slot(machine, cpu_index, NULL); 3196ea089eebSIgor Mammedov assert(core_slot); 3197ea089eebSIgor Mammedov return core_slot->props; 319820bb648dSDavid Gibson } 319920bb648dSDavid Gibson 3200535455fdSIgor Mammedov static const CPUArchIdList *spapr_possible_cpu_arch_ids(MachineState *machine) 3201535455fdSIgor Mammedov { 3202535455fdSIgor Mammedov int i; 3203535455fdSIgor Mammedov int spapr_max_cores = max_cpus / smp_threads; 3204535455fdSIgor Mammedov MachineClass *mc = MACHINE_GET_CLASS(machine); 3205535455fdSIgor Mammedov 3206c5514d0eSIgor Mammedov if (!mc->has_hotpluggable_cpus) { 3207535455fdSIgor Mammedov spapr_max_cores = QEMU_ALIGN_UP(smp_cpus, smp_threads) / smp_threads; 3208535455fdSIgor Mammedov } 3209535455fdSIgor Mammedov if (machine->possible_cpus) { 3210535455fdSIgor Mammedov assert(machine->possible_cpus->len == spapr_max_cores); 3211535455fdSIgor Mammedov return machine->possible_cpus; 3212535455fdSIgor Mammedov } 3213535455fdSIgor Mammedov 3214535455fdSIgor Mammedov machine->possible_cpus = g_malloc0(sizeof(CPUArchIdList) + 3215535455fdSIgor Mammedov sizeof(CPUArchId) * spapr_max_cores); 3216535455fdSIgor Mammedov machine->possible_cpus->len = spapr_max_cores; 3217535455fdSIgor Mammedov for (i = 0; i < machine->possible_cpus->len; i++) { 3218535455fdSIgor Mammedov int core_id = i * smp_threads; 3219535455fdSIgor Mammedov 3220f2d672c2SIgor Mammedov machine->possible_cpus->cpus[i].vcpus_count = smp_threads; 3221535455fdSIgor Mammedov machine->possible_cpus->cpus[i].arch_id = core_id; 3222535455fdSIgor Mammedov machine->possible_cpus->cpus[i].props.has_core_id = true; 3223535455fdSIgor Mammedov machine->possible_cpus->cpus[i].props.core_id = core_id; 3224ea089eebSIgor Mammedov 3225ea089eebSIgor Mammedov /* default distribution of CPUs over NUMA nodes */ 3226ea089eebSIgor Mammedov if (nb_numa_nodes) { 3227ea089eebSIgor Mammedov /* preset values but do not enable them i.e. 'has_node_id = false', 3228ea089eebSIgor Mammedov * numa init code will enable them later if manual mapping wasn't 3229ea089eebSIgor Mammedov * present on CLI */ 3230ea089eebSIgor Mammedov machine->possible_cpus->cpus[i].props.node_id = 3231ea089eebSIgor Mammedov core_id / smp_threads / smp_cores % nb_numa_nodes; 3232ea089eebSIgor Mammedov } 3233535455fdSIgor Mammedov } 3234535455fdSIgor Mammedov return machine->possible_cpus; 3235535455fdSIgor Mammedov } 3236535455fdSIgor Mammedov 32376737d9adSDavid Gibson static void spapr_phb_placement(sPAPRMachineState *spapr, uint32_t index, 3238daa23699SDavid Gibson uint64_t *buid, hwaddr *pio, 3239daa23699SDavid Gibson hwaddr *mmio32, hwaddr *mmio64, 32406737d9adSDavid Gibson unsigned n_dma, uint32_t *liobns, Error **errp) 32416737d9adSDavid Gibson { 3242357d1e3bSDavid Gibson /* 3243357d1e3bSDavid Gibson * New-style PHB window placement. 3244357d1e3bSDavid Gibson * 3245357d1e3bSDavid Gibson * Goals: Gives large (1TiB), naturally aligned 64-bit MMIO window 3246357d1e3bSDavid Gibson * for each PHB, in addition to 2GiB 32-bit MMIO and 64kiB PIO 3247357d1e3bSDavid Gibson * windows. 3248357d1e3bSDavid Gibson * 3249357d1e3bSDavid Gibson * Some guest kernels can't work with MMIO windows above 1<<46 3250357d1e3bSDavid Gibson * (64TiB), so we place up to 31 PHBs in the area 32TiB..64TiB 3251357d1e3bSDavid Gibson * 3252357d1e3bSDavid Gibson * 32TiB..(33TiB+1984kiB) contains the 64kiB PIO windows for each 3253357d1e3bSDavid Gibson * PHB stacked together. (32TiB+2GiB)..(32TiB+64GiB) contains the 3254357d1e3bSDavid Gibson * 2GiB 32-bit MMIO windows for each PHB. Then 33..64TiB has the 3255357d1e3bSDavid Gibson * 1TiB 64-bit MMIO windows for each PHB. 3256357d1e3bSDavid Gibson */ 32576737d9adSDavid Gibson const uint64_t base_buid = 0x800000020000000ULL; 325825e6a118SMichael S. Tsirkin #define SPAPR_MAX_PHBS ((SPAPR_PCI_LIMIT - SPAPR_PCI_BASE) / \ 325925e6a118SMichael S. Tsirkin SPAPR_PCI_MEM64_WIN_SIZE - 1) 32606737d9adSDavid Gibson int i; 32616737d9adSDavid Gibson 3262357d1e3bSDavid Gibson /* Sanity check natural alignments */ 3263357d1e3bSDavid Gibson QEMU_BUILD_BUG_ON((SPAPR_PCI_BASE % SPAPR_PCI_MEM64_WIN_SIZE) != 0); 3264357d1e3bSDavid Gibson QEMU_BUILD_BUG_ON((SPAPR_PCI_LIMIT % SPAPR_PCI_MEM64_WIN_SIZE) != 0); 3265357d1e3bSDavid Gibson QEMU_BUILD_BUG_ON((SPAPR_PCI_MEM64_WIN_SIZE % SPAPR_PCI_MEM32_WIN_SIZE) != 0); 3266357d1e3bSDavid Gibson QEMU_BUILD_BUG_ON((SPAPR_PCI_MEM32_WIN_SIZE % SPAPR_PCI_IO_WIN_SIZE) != 0); 3267357d1e3bSDavid Gibson /* Sanity check bounds */ 326825e6a118SMichael S. Tsirkin QEMU_BUILD_BUG_ON((SPAPR_MAX_PHBS * SPAPR_PCI_IO_WIN_SIZE) > 326925e6a118SMichael S. Tsirkin SPAPR_PCI_MEM32_WIN_SIZE); 327025e6a118SMichael S. Tsirkin QEMU_BUILD_BUG_ON((SPAPR_MAX_PHBS * SPAPR_PCI_MEM32_WIN_SIZE) > 327125e6a118SMichael S. Tsirkin SPAPR_PCI_MEM64_WIN_SIZE); 32722efff1c0SDavid Gibson 327325e6a118SMichael S. Tsirkin if (index >= SPAPR_MAX_PHBS) { 327425e6a118SMichael S. Tsirkin error_setg(errp, "\"index\" for PAPR PHB is too large (max %llu)", 327525e6a118SMichael S. Tsirkin SPAPR_MAX_PHBS - 1); 32766737d9adSDavid Gibson return; 32776737d9adSDavid Gibson } 32786737d9adSDavid Gibson 32796737d9adSDavid Gibson *buid = base_buid + index; 32806737d9adSDavid Gibson for (i = 0; i < n_dma; ++i) { 32816737d9adSDavid Gibson liobns[i] = SPAPR_PCI_LIOBN(index, i); 32826737d9adSDavid Gibson } 32836737d9adSDavid Gibson 3284357d1e3bSDavid Gibson *pio = SPAPR_PCI_BASE + index * SPAPR_PCI_IO_WIN_SIZE; 3285357d1e3bSDavid Gibson *mmio32 = SPAPR_PCI_BASE + (index + 1) * SPAPR_PCI_MEM32_WIN_SIZE; 3286357d1e3bSDavid Gibson *mmio64 = SPAPR_PCI_BASE + (index + 1) * SPAPR_PCI_MEM64_WIN_SIZE; 32876737d9adSDavid Gibson } 32886737d9adSDavid Gibson 32897844e12bSCédric Le Goater static ICSState *spapr_ics_get(XICSFabric *dev, int irq) 32907844e12bSCédric Le Goater { 32917844e12bSCédric Le Goater sPAPRMachineState *spapr = SPAPR_MACHINE(dev); 32927844e12bSCédric Le Goater 32937844e12bSCédric Le Goater return ics_valid_irq(spapr->ics, irq) ? spapr->ics : NULL; 32947844e12bSCédric Le Goater } 32957844e12bSCédric Le Goater 32967844e12bSCédric Le Goater static void spapr_ics_resend(XICSFabric *dev) 32977844e12bSCédric Le Goater { 32987844e12bSCédric Le Goater sPAPRMachineState *spapr = SPAPR_MACHINE(dev); 32997844e12bSCédric Le Goater 33007844e12bSCédric Le Goater ics_resend(spapr->ics); 33017844e12bSCédric Le Goater } 33027844e12bSCédric Le Goater 330306747ba6SCédric Le Goater static ICPState *spapr_icp_get(XICSFabric *xi, int cpu_dt_id) 3304b2fc59aaSCédric Le Goater { 33055bc8d26dSCédric Le Goater PowerPCCPU *cpu = ppc_get_vcpu_by_dt_id(cpu_dt_id); 3306b2fc59aaSCédric Le Goater 33075bc8d26dSCédric Le Goater return cpu ? ICP(cpu->intc) : NULL; 3308b2fc59aaSCédric Le Goater } 3309b2fc59aaSCédric Le Goater 33106449da45SCédric Le Goater static void spapr_pic_print_info(InterruptStatsProvider *obj, 33116449da45SCédric Le Goater Monitor *mon) 33126449da45SCédric Le Goater { 33136449da45SCédric Le Goater sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 33145bc8d26dSCédric Le Goater CPUState *cs; 33156449da45SCédric Le Goater 33165bc8d26dSCédric Le Goater CPU_FOREACH(cs) { 33175bc8d26dSCédric Le Goater PowerPCCPU *cpu = POWERPC_CPU(cs); 33185bc8d26dSCédric Le Goater 33195bc8d26dSCédric Le Goater icp_pic_print_info(ICP(cpu->intc), mon); 33206449da45SCédric Le Goater } 33216449da45SCédric Le Goater 33226449da45SCédric Le Goater ics_pic_print_info(spapr->ics, mon); 33236449da45SCédric Le Goater } 33246449da45SCédric Le Goater 332529ee3247SAlexey Kardashevskiy static void spapr_machine_class_init(ObjectClass *oc, void *data) 332653018216SPaolo Bonzini { 332729ee3247SAlexey Kardashevskiy MachineClass *mc = MACHINE_CLASS(oc); 3328224245bfSDavid Gibson sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(oc); 332971461b0fSAlexey Kardashevskiy FWPathProviderClass *fwc = FW_PATH_PROVIDER_CLASS(oc); 333034316482SAlexey Kardashevskiy NMIClass *nc = NMI_CLASS(oc); 3331c20d332aSBharata B Rao HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(oc); 33321d1be34dSDavid Gibson PPCVirtualHypervisorClass *vhc = PPC_VIRTUAL_HYPERVISOR_CLASS(oc); 33337844e12bSCédric Le Goater XICSFabricClass *xic = XICS_FABRIC_CLASS(oc); 33346449da45SCédric Le Goater InterruptStatsProviderClass *ispc = INTERRUPT_STATS_PROVIDER_CLASS(oc); 333529ee3247SAlexey Kardashevskiy 33360eb9054cSDavid Gibson mc->desc = "pSeries Logical Partition (PAPR compliant)"; 3337fc9f38c3SDavid Gibson 3338fc9f38c3SDavid Gibson /* 3339fc9f38c3SDavid Gibson * We set up the default / latest behaviour here. The class_init 3340fc9f38c3SDavid Gibson * functions for the specific versioned machine types can override 3341fc9f38c3SDavid Gibson * these details for backwards compatibility 3342fc9f38c3SDavid Gibson */ 3343958db90cSMarcel Apfelbaum mc->init = ppc_spapr_init; 3344958db90cSMarcel Apfelbaum mc->reset = ppc_spapr_reset; 3345958db90cSMarcel Apfelbaum mc->block_default_type = IF_SCSI; 33466244bb7eSGreg Kurz mc->max_cpus = 1024; 3347958db90cSMarcel Apfelbaum mc->no_parallel = 1; 33485b2128d2SAlexander Graf mc->default_boot_order = ""; 3349a34944feSNikunj A Dadhania mc->default_ram_size = 512 * M_BYTE; 3350958db90cSMarcel Apfelbaum mc->kvm_type = spapr_kvm_type; 33519e3f9733SAlexander Graf mc->has_dynamic_sysbus = true; 3352e4024630SLaurent Vivier mc->pci_allow_0_address = true; 33537ebaf795SBharata B Rao mc->get_hotplug_handler = spapr_get_hotplug_handler; 335494a94e4cSBharata B Rao hc->pre_plug = spapr_machine_device_pre_plug; 3355c20d332aSBharata B Rao hc->plug = spapr_machine_device_plug; 3356ea089eebSIgor Mammedov mc->cpu_index_to_instance_props = spapr_cpu_index_to_props; 3357535455fdSIgor Mammedov mc->possible_cpu_arch_ids = spapr_possible_cpu_arch_ids; 3358cf632463SBharata B Rao hc->unplug_request = spapr_machine_device_unplug_request; 335900b4fbe2SMarcel Apfelbaum 3360fc9f38c3SDavid Gibson smc->dr_lmb_enabled = true; 33613daa4a9fSThomas Huth smc->tcg_default_cpu = "POWER8"; 3362c5514d0eSIgor Mammedov mc->has_hotpluggable_cpus = true; 336371461b0fSAlexey Kardashevskiy fwc->get_dev_path = spapr_get_fw_dev_path; 336434316482SAlexey Kardashevskiy nc->nmi_monitor_handler = spapr_nmi; 33656737d9adSDavid Gibson smc->phb_placement = spapr_phb_placement; 33661d1be34dSDavid Gibson vhc->hypercall = emulate_spapr_hypercall; 3367e57ca75cSDavid Gibson vhc->hpt_mask = spapr_hpt_mask; 3368e57ca75cSDavid Gibson vhc->map_hptes = spapr_map_hptes; 3369e57ca75cSDavid Gibson vhc->unmap_hptes = spapr_unmap_hptes; 3370e57ca75cSDavid Gibson vhc->store_hpte = spapr_store_hpte; 33719861bb3eSSuraj Jitindar Singh vhc->get_patbe = spapr_get_patbe; 33727844e12bSCédric Le Goater xic->ics_get = spapr_ics_get; 33737844e12bSCédric Le Goater xic->ics_resend = spapr_ics_resend; 3374b2fc59aaSCédric Le Goater xic->icp_get = spapr_icp_get; 33756449da45SCédric Le Goater ispc->print_info = spapr_pic_print_info; 337655641213SLaurent Vivier /* Force NUMA node memory size to be a multiple of 337755641213SLaurent Vivier * SPAPR_MEMORY_BLOCK_SIZE (256M) since that's the granularity 337855641213SLaurent Vivier * in which LMBs are represented and hot-added 337955641213SLaurent Vivier */ 338055641213SLaurent Vivier mc->numa_mem_align_shift = 28; 338153018216SPaolo Bonzini } 338253018216SPaolo Bonzini 338329ee3247SAlexey Kardashevskiy static const TypeInfo spapr_machine_info = { 338429ee3247SAlexey Kardashevskiy .name = TYPE_SPAPR_MACHINE, 338529ee3247SAlexey Kardashevskiy .parent = TYPE_MACHINE, 33864aee7362SDavid Gibson .abstract = true, 33876ca1502eSAlexey Kardashevskiy .instance_size = sizeof(sPAPRMachineState), 338823825581SEduardo Habkost .instance_init = spapr_machine_initfn, 338987bbdd9cSDavid Gibson .instance_finalize = spapr_machine_finalizefn, 3390183930c0SDavid Gibson .class_size = sizeof(sPAPRMachineClass), 339129ee3247SAlexey Kardashevskiy .class_init = spapr_machine_class_init, 339271461b0fSAlexey Kardashevskiy .interfaces = (InterfaceInfo[]) { 339371461b0fSAlexey Kardashevskiy { TYPE_FW_PATH_PROVIDER }, 339434316482SAlexey Kardashevskiy { TYPE_NMI }, 3395c20d332aSBharata B Rao { TYPE_HOTPLUG_HANDLER }, 33961d1be34dSDavid Gibson { TYPE_PPC_VIRTUAL_HYPERVISOR }, 33977844e12bSCédric Le Goater { TYPE_XICS_FABRIC }, 33986449da45SCédric Le Goater { TYPE_INTERRUPT_STATS_PROVIDER }, 339971461b0fSAlexey Kardashevskiy { } 340071461b0fSAlexey Kardashevskiy }, 340129ee3247SAlexey Kardashevskiy }; 340229ee3247SAlexey Kardashevskiy 3403fccbc785SDavid Gibson #define DEFINE_SPAPR_MACHINE(suffix, verstr, latest) \ 34045013c547SDavid Gibson static void spapr_machine_##suffix##_class_init(ObjectClass *oc, \ 34055013c547SDavid Gibson void *data) \ 34065013c547SDavid Gibson { \ 34075013c547SDavid Gibson MachineClass *mc = MACHINE_CLASS(oc); \ 34085013c547SDavid Gibson spapr_machine_##suffix##_class_options(mc); \ 3409fccbc785SDavid Gibson if (latest) { \ 3410fccbc785SDavid Gibson mc->alias = "pseries"; \ 3411fccbc785SDavid Gibson mc->is_default = 1; \ 3412fccbc785SDavid Gibson } \ 34135013c547SDavid Gibson } \ 34145013c547SDavid Gibson static void spapr_machine_##suffix##_instance_init(Object *obj) \ 34155013c547SDavid Gibson { \ 34165013c547SDavid Gibson MachineState *machine = MACHINE(obj); \ 34175013c547SDavid Gibson spapr_machine_##suffix##_instance_options(machine); \ 34185013c547SDavid Gibson } \ 34195013c547SDavid Gibson static const TypeInfo spapr_machine_##suffix##_info = { \ 34205013c547SDavid Gibson .name = MACHINE_TYPE_NAME("pseries-" verstr), \ 34215013c547SDavid Gibson .parent = TYPE_SPAPR_MACHINE, \ 34225013c547SDavid Gibson .class_init = spapr_machine_##suffix##_class_init, \ 34235013c547SDavid Gibson .instance_init = spapr_machine_##suffix##_instance_init, \ 34245013c547SDavid Gibson }; \ 34255013c547SDavid Gibson static void spapr_machine_register_##suffix(void) \ 34265013c547SDavid Gibson { \ 34275013c547SDavid Gibson type_register(&spapr_machine_##suffix##_info); \ 34285013c547SDavid Gibson } \ 34290e6aac87SEduardo Habkost type_init(spapr_machine_register_##suffix) 34305013c547SDavid Gibson 34311c5f29bbSDavid Gibson /* 34323fa14fbeSDavid Gibson * pseries-2.10 3433db800b21SDavid Gibson */ 34343fa14fbeSDavid Gibson static void spapr_machine_2_10_instance_options(MachineState *machine) 3435db800b21SDavid Gibson { 3436db800b21SDavid Gibson } 3437db800b21SDavid Gibson 34383fa14fbeSDavid Gibson static void spapr_machine_2_10_class_options(MachineClass *mc) 3439db800b21SDavid Gibson { 3440db800b21SDavid Gibson /* Defaults for the latest behaviour inherited from the base class */ 3441db800b21SDavid Gibson } 3442db800b21SDavid Gibson 34433fa14fbeSDavid Gibson DEFINE_SPAPR_MACHINE(2_10, "2.10", true); 34443fa14fbeSDavid Gibson 34453fa14fbeSDavid Gibson /* 34463fa14fbeSDavid Gibson * pseries-2.9 34473fa14fbeSDavid Gibson */ 34483fa14fbeSDavid Gibson #define SPAPR_COMPAT_2_9 \ 3449d5fc133eSDavid Gibson HW_COMPAT_2_9 \ 3450d5fc133eSDavid Gibson { \ 3451d5fc133eSDavid Gibson .driver = TYPE_POWERPC_CPU, \ 3452d5fc133eSDavid Gibson .property = "pre-2.10-migration", \ 3453d5fc133eSDavid Gibson .value = "on", \ 3454d5fc133eSDavid Gibson }, \ 34553fa14fbeSDavid Gibson 34563fa14fbeSDavid Gibson static void spapr_machine_2_9_instance_options(MachineState *machine) 34573fa14fbeSDavid Gibson { 34583fa14fbeSDavid Gibson spapr_machine_2_10_instance_options(machine); 34593fa14fbeSDavid Gibson } 34603fa14fbeSDavid Gibson 34613fa14fbeSDavid Gibson static void spapr_machine_2_9_class_options(MachineClass *mc) 34623fa14fbeSDavid Gibson { 346346f7afa3SGreg Kurz sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); 346446f7afa3SGreg Kurz 34653fa14fbeSDavid Gibson spapr_machine_2_10_class_options(mc); 34663fa14fbeSDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_9); 34673bfe5716SLaurent Vivier mc->numa_auto_assign_ram = numa_legacy_auto_assign_ram; 346846f7afa3SGreg Kurz smc->pre_2_10_has_unused_icps = true; 34693fa14fbeSDavid Gibson } 34703fa14fbeSDavid Gibson 34713fa14fbeSDavid Gibson DEFINE_SPAPR_MACHINE(2_9, "2.9", false); 3472fa325e6cSDavid Gibson 3473fa325e6cSDavid Gibson /* 3474fa325e6cSDavid Gibson * pseries-2.8 3475fa325e6cSDavid Gibson */ 3476fa325e6cSDavid Gibson #define SPAPR_COMPAT_2_8 \ 347782516263SDavid Gibson HW_COMPAT_2_8 \ 347882516263SDavid Gibson { \ 347982516263SDavid Gibson .driver = TYPE_SPAPR_PCI_HOST_BRIDGE, \ 348082516263SDavid Gibson .property = "pcie-extended-configuration-space", \ 348182516263SDavid Gibson .value = "off", \ 348282516263SDavid Gibson }, 3483fa325e6cSDavid Gibson 3484fa325e6cSDavid Gibson static void spapr_machine_2_8_instance_options(MachineState *machine) 3485fa325e6cSDavid Gibson { 3486fa325e6cSDavid Gibson spapr_machine_2_9_instance_options(machine); 3487fa325e6cSDavid Gibson } 3488fa325e6cSDavid Gibson 3489fa325e6cSDavid Gibson static void spapr_machine_2_8_class_options(MachineClass *mc) 3490fa325e6cSDavid Gibson { 3491fa325e6cSDavid Gibson spapr_machine_2_9_class_options(mc); 3492fa325e6cSDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_8); 349355641213SLaurent Vivier mc->numa_mem_align_shift = 23; 3494fa325e6cSDavid Gibson } 3495fa325e6cSDavid Gibson 3496fa325e6cSDavid Gibson DEFINE_SPAPR_MACHINE(2_8, "2.8", false); 3497db800b21SDavid Gibson 3498db800b21SDavid Gibson /* 34991ea1eefcSBharata B Rao * pseries-2.7 35001ea1eefcSBharata B Rao */ 3501db800b21SDavid Gibson #define SPAPR_COMPAT_2_7 \ 3502db800b21SDavid Gibson HW_COMPAT_2_7 \ 3503357d1e3bSDavid Gibson { \ 3504357d1e3bSDavid Gibson .driver = TYPE_SPAPR_PCI_HOST_BRIDGE, \ 3505357d1e3bSDavid Gibson .property = "mem_win_size", \ 3506357d1e3bSDavid Gibson .value = stringify(SPAPR_PCI_2_7_MMIO_WIN_SIZE),\ 3507357d1e3bSDavid Gibson }, \ 3508357d1e3bSDavid Gibson { \ 3509357d1e3bSDavid Gibson .driver = TYPE_SPAPR_PCI_HOST_BRIDGE, \ 3510357d1e3bSDavid Gibson .property = "mem64_win_size", \ 3511357d1e3bSDavid Gibson .value = "0", \ 3512146c11f1SDavid Gibson }, \ 3513146c11f1SDavid Gibson { \ 3514146c11f1SDavid Gibson .driver = TYPE_POWERPC_CPU, \ 3515146c11f1SDavid Gibson .property = "pre-2.8-migration", \ 3516146c11f1SDavid Gibson .value = "on", \ 35175c4537bdSDavid Gibson }, \ 35185c4537bdSDavid Gibson { \ 35195c4537bdSDavid Gibson .driver = TYPE_SPAPR_PCI_HOST_BRIDGE, \ 35205c4537bdSDavid Gibson .property = "pre-2.8-migration", \ 35215c4537bdSDavid Gibson .value = "on", \ 3522357d1e3bSDavid Gibson }, 3523357d1e3bSDavid Gibson 3524357d1e3bSDavid Gibson static void phb_placement_2_7(sPAPRMachineState *spapr, uint32_t index, 3525357d1e3bSDavid Gibson uint64_t *buid, hwaddr *pio, 3526357d1e3bSDavid Gibson hwaddr *mmio32, hwaddr *mmio64, 3527357d1e3bSDavid Gibson unsigned n_dma, uint32_t *liobns, Error **errp) 3528357d1e3bSDavid Gibson { 3529357d1e3bSDavid Gibson /* Legacy PHB placement for pseries-2.7 and earlier machine types */ 3530357d1e3bSDavid Gibson const uint64_t base_buid = 0x800000020000000ULL; 3531357d1e3bSDavid Gibson const hwaddr phb_spacing = 0x1000000000ULL; /* 64 GiB */ 3532357d1e3bSDavid Gibson const hwaddr mmio_offset = 0xa0000000; /* 2 GiB + 512 MiB */ 3533357d1e3bSDavid Gibson const hwaddr pio_offset = 0x80000000; /* 2 GiB */ 3534357d1e3bSDavid Gibson const uint32_t max_index = 255; 3535357d1e3bSDavid Gibson const hwaddr phb0_alignment = 0x10000000000ULL; /* 1 TiB */ 3536357d1e3bSDavid Gibson 3537357d1e3bSDavid Gibson uint64_t ram_top = MACHINE(spapr)->ram_size; 3538357d1e3bSDavid Gibson hwaddr phb0_base, phb_base; 3539357d1e3bSDavid Gibson int i; 3540357d1e3bSDavid Gibson 3541357d1e3bSDavid Gibson /* Do we have hotpluggable memory? */ 3542357d1e3bSDavid Gibson if (MACHINE(spapr)->maxram_size > ram_top) { 3543357d1e3bSDavid Gibson /* Can't just use maxram_size, because there may be an 3544357d1e3bSDavid Gibson * alignment gap between normal and hotpluggable memory 3545357d1e3bSDavid Gibson * regions */ 3546357d1e3bSDavid Gibson ram_top = spapr->hotplug_memory.base + 3547357d1e3bSDavid Gibson memory_region_size(&spapr->hotplug_memory.mr); 3548357d1e3bSDavid Gibson } 3549357d1e3bSDavid Gibson 3550357d1e3bSDavid Gibson phb0_base = QEMU_ALIGN_UP(ram_top, phb0_alignment); 3551357d1e3bSDavid Gibson 3552357d1e3bSDavid Gibson if (index > max_index) { 3553357d1e3bSDavid Gibson error_setg(errp, "\"index\" for PAPR PHB is too large (max %u)", 3554357d1e3bSDavid Gibson max_index); 3555357d1e3bSDavid Gibson return; 3556357d1e3bSDavid Gibson } 3557357d1e3bSDavid Gibson 3558357d1e3bSDavid Gibson *buid = base_buid + index; 3559357d1e3bSDavid Gibson for (i = 0; i < n_dma; ++i) { 3560357d1e3bSDavid Gibson liobns[i] = SPAPR_PCI_LIOBN(index, i); 3561357d1e3bSDavid Gibson } 3562357d1e3bSDavid Gibson 3563357d1e3bSDavid Gibson phb_base = phb0_base + index * phb_spacing; 3564357d1e3bSDavid Gibson *pio = phb_base + pio_offset; 3565357d1e3bSDavid Gibson *mmio32 = phb_base + mmio_offset; 3566357d1e3bSDavid Gibson /* 3567357d1e3bSDavid Gibson * We don't set the 64-bit MMIO window, relying on the PHB's 3568357d1e3bSDavid Gibson * fallback behaviour of automatically splitting a large "32-bit" 3569357d1e3bSDavid Gibson * window into contiguous 32-bit and 64-bit windows 3570357d1e3bSDavid Gibson */ 3571357d1e3bSDavid Gibson } 3572db800b21SDavid Gibson 35731ea1eefcSBharata B Rao static void spapr_machine_2_7_instance_options(MachineState *machine) 35741ea1eefcSBharata B Rao { 3575f6229214SMichael Roth sPAPRMachineState *spapr = SPAPR_MACHINE(machine); 3576f6229214SMichael Roth 3577672de881SMichael Roth spapr_machine_2_8_instance_options(machine); 3578f6229214SMichael Roth spapr->use_hotplug_event_source = false; 35791ea1eefcSBharata B Rao } 35801ea1eefcSBharata B Rao 35811ea1eefcSBharata B Rao static void spapr_machine_2_7_class_options(MachineClass *mc) 35821ea1eefcSBharata B Rao { 35833daa4a9fSThomas Huth sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); 35843daa4a9fSThomas Huth 3585db800b21SDavid Gibson spapr_machine_2_8_class_options(mc); 35863daa4a9fSThomas Huth smc->tcg_default_cpu = "POWER7"; 3587db800b21SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_7); 3588357d1e3bSDavid Gibson smc->phb_placement = phb_placement_2_7; 35891ea1eefcSBharata B Rao } 35901ea1eefcSBharata B Rao 3591db800b21SDavid Gibson DEFINE_SPAPR_MACHINE(2_7, "2.7", false); 35921ea1eefcSBharata B Rao 35931ea1eefcSBharata B Rao /* 35944b23699cSDavid Gibson * pseries-2.6 35954b23699cSDavid Gibson */ 35961ea1eefcSBharata B Rao #define SPAPR_COMPAT_2_6 \ 3597ae4de14cSAlexey Kardashevskiy HW_COMPAT_2_6 \ 3598ae4de14cSAlexey Kardashevskiy { \ 3599ae4de14cSAlexey Kardashevskiy .driver = TYPE_SPAPR_PCI_HOST_BRIDGE,\ 3600ae4de14cSAlexey Kardashevskiy .property = "ddw",\ 3601ae4de14cSAlexey Kardashevskiy .value = stringify(off),\ 3602ae4de14cSAlexey Kardashevskiy }, 36031ea1eefcSBharata B Rao 36044b23699cSDavid Gibson static void spapr_machine_2_6_instance_options(MachineState *machine) 36054b23699cSDavid Gibson { 3606672de881SMichael Roth spapr_machine_2_7_instance_options(machine); 36074b23699cSDavid Gibson } 36084b23699cSDavid Gibson 36094b23699cSDavid Gibson static void spapr_machine_2_6_class_options(MachineClass *mc) 36104b23699cSDavid Gibson { 36111ea1eefcSBharata B Rao spapr_machine_2_7_class_options(mc); 3612c5514d0eSIgor Mammedov mc->has_hotpluggable_cpus = false; 36131ea1eefcSBharata B Rao SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_6); 36144b23699cSDavid Gibson } 36154b23699cSDavid Gibson 36161ea1eefcSBharata B Rao DEFINE_SPAPR_MACHINE(2_6, "2.6", false); 36174b23699cSDavid Gibson 36184b23699cSDavid Gibson /* 36191c5f29bbSDavid Gibson * pseries-2.5 36201c5f29bbSDavid Gibson */ 36214b23699cSDavid Gibson #define SPAPR_COMPAT_2_5 \ 362257c522f4SThomas Huth HW_COMPAT_2_5 \ 362357c522f4SThomas Huth { \ 362457c522f4SThomas Huth .driver = "spapr-vlan", \ 362557c522f4SThomas Huth .property = "use-rx-buffer-pools", \ 362657c522f4SThomas Huth .value = "off", \ 362757c522f4SThomas Huth }, 36284b23699cSDavid Gibson 36295013c547SDavid Gibson static void spapr_machine_2_5_instance_options(MachineState *machine) 36301c5f29bbSDavid Gibson { 3631672de881SMichael Roth spapr_machine_2_6_instance_options(machine); 36325013c547SDavid Gibson } 36335013c547SDavid Gibson 36345013c547SDavid Gibson static void spapr_machine_2_5_class_options(MachineClass *mc) 36355013c547SDavid Gibson { 363657040d45SThomas Huth sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); 363757040d45SThomas Huth 36384b23699cSDavid Gibson spapr_machine_2_6_class_options(mc); 363957040d45SThomas Huth smc->use_ohci_by_default = true; 36404b23699cSDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_5); 36411c5f29bbSDavid Gibson } 36421c5f29bbSDavid Gibson 36434b23699cSDavid Gibson DEFINE_SPAPR_MACHINE(2_5, "2.5", false); 36441c5f29bbSDavid Gibson 36451c5f29bbSDavid Gibson /* 36461c5f29bbSDavid Gibson * pseries-2.4 36471c5f29bbSDavid Gibson */ 364880fd50f9SCornelia Huck #define SPAPR_COMPAT_2_4 \ 364980fd50f9SCornelia Huck HW_COMPAT_2_4 365080fd50f9SCornelia Huck 36515013c547SDavid Gibson static void spapr_machine_2_4_instance_options(MachineState *machine) 36521c5f29bbSDavid Gibson { 36535013c547SDavid Gibson spapr_machine_2_5_instance_options(machine); 36545013c547SDavid Gibson } 36551c5f29bbSDavid Gibson 36565013c547SDavid Gibson static void spapr_machine_2_4_class_options(MachineClass *mc) 36575013c547SDavid Gibson { 3658fc9f38c3SDavid Gibson sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); 3659fc9f38c3SDavid Gibson 3660fc9f38c3SDavid Gibson spapr_machine_2_5_class_options(mc); 3661fc9f38c3SDavid Gibson smc->dr_lmb_enabled = false; 3662f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_4); 36631c5f29bbSDavid Gibson } 36641c5f29bbSDavid Gibson 3665fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_4, "2.4", false); 36661c5f29bbSDavid Gibson 36671c5f29bbSDavid Gibson /* 36681c5f29bbSDavid Gibson * pseries-2.3 36691c5f29bbSDavid Gibson */ 367038ff32c6SEduardo Habkost #define SPAPR_COMPAT_2_3 \ 36717619c7b0SMichael Roth HW_COMPAT_2_3 \ 36727619c7b0SMichael Roth {\ 36737619c7b0SMichael Roth .driver = "spapr-pci-host-bridge",\ 36747619c7b0SMichael Roth .property = "dynamic-reconfiguration",\ 36757619c7b0SMichael Roth .value = "off",\ 36767619c7b0SMichael Roth }, 367738ff32c6SEduardo Habkost 36785013c547SDavid Gibson static void spapr_machine_2_3_instance_options(MachineState *machine) 36791c5f29bbSDavid Gibson { 36805013c547SDavid Gibson spapr_machine_2_4_instance_options(machine); 36811c5f29bbSDavid Gibson } 36821c5f29bbSDavid Gibson 36835013c547SDavid Gibson static void spapr_machine_2_3_class_options(MachineClass *mc) 36841c5f29bbSDavid Gibson { 3685fc9f38c3SDavid Gibson spapr_machine_2_4_class_options(mc); 3686f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_3); 36871c5f29bbSDavid Gibson } 3688fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_3, "2.3", false); 36891c5f29bbSDavid Gibson 36901c5f29bbSDavid Gibson /* 36911c5f29bbSDavid Gibson * pseries-2.2 36921c5f29bbSDavid Gibson */ 36931c5f29bbSDavid Gibson 3694b194df47SAlexey Kardashevskiy #define SPAPR_COMPAT_2_2 \ 36954dfd8eaaSEduardo Habkost HW_COMPAT_2_2 \ 3696b194df47SAlexey Kardashevskiy {\ 3697b194df47SAlexey Kardashevskiy .driver = TYPE_SPAPR_PCI_HOST_BRIDGE,\ 3698b194df47SAlexey Kardashevskiy .property = "mem_win_size",\ 3699b194df47SAlexey Kardashevskiy .value = "0x20000000",\ 3700dd754bafSEduardo Habkost }, 3701b194df47SAlexey Kardashevskiy 37025013c547SDavid Gibson static void spapr_machine_2_2_instance_options(MachineState *machine) 3703b0e966d0SJason Wang { 37045013c547SDavid Gibson spapr_machine_2_3_instance_options(machine); 3705cba0e779SGreg Kurz machine->suppress_vmdesc = true; 3706b0e966d0SJason Wang } 3707b0e966d0SJason Wang 37085013c547SDavid Gibson static void spapr_machine_2_2_class_options(MachineClass *mc) 3709b0e966d0SJason Wang { 3710fc9f38c3SDavid Gibson spapr_machine_2_3_class_options(mc); 3711f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_2); 37121c5f29bbSDavid Gibson } 3713fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_2, "2.2", false); 37141c5f29bbSDavid Gibson 37151c5f29bbSDavid Gibson /* 37161c5f29bbSDavid Gibson * pseries-2.1 37171c5f29bbSDavid Gibson */ 37181c5f29bbSDavid Gibson #define SPAPR_COMPAT_2_1 \ 37191c5f29bbSDavid Gibson HW_COMPAT_2_1 37201c5f29bbSDavid Gibson 37215013c547SDavid Gibson static void spapr_machine_2_1_instance_options(MachineState *machine) 37221c5f29bbSDavid Gibson { 37235013c547SDavid Gibson spapr_machine_2_2_instance_options(machine); 37241c5f29bbSDavid Gibson } 37251c5f29bbSDavid Gibson 37265013c547SDavid Gibson static void spapr_machine_2_1_class_options(MachineClass *mc) 3727b0e966d0SJason Wang { 3728fc9f38c3SDavid Gibson spapr_machine_2_2_class_options(mc); 3729f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_1); 37306026db45SAlexey Kardashevskiy } 3731fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_1, "2.1", false); 37326026db45SAlexey Kardashevskiy 373329ee3247SAlexey Kardashevskiy static void spapr_machine_register_types(void) 373429ee3247SAlexey Kardashevskiy { 373529ee3247SAlexey Kardashevskiy type_register_static(&spapr_machine_info); 373629ee3247SAlexey Kardashevskiy } 373729ee3247SAlexey Kardashevskiy 373829ee3247SAlexey Kardashevskiy type_init(spapr_machine_register_types) 3739