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" 29fa98fbfcSSam Bobroff #include "qapi/visitor.h" 3053018216SPaolo Bonzini #include "sysemu/sysemu.h" 31e35704baSEduardo Habkost #include "sysemu/numa.h" 3253018216SPaolo Bonzini #include "hw/hw.h" 3303dd024fSPaolo Bonzini #include "qemu/log.h" 3471461b0fSAlexey Kardashevskiy #include "hw/fw-path-provider.h" 3553018216SPaolo Bonzini #include "elf.h" 3653018216SPaolo Bonzini #include "net/net.h" 37ad440b4aSAndrew Jones #include "sysemu/device_tree.h" 38fa1d36dfSMarkus Armbruster #include "sysemu/block-backend.h" 3953018216SPaolo Bonzini #include "sysemu/cpus.h" 40b3946626SVincent Palatin #include "sysemu/hw_accel.h" 4153018216SPaolo Bonzini #include "kvm_ppc.h" 42c4b63b7cSJuan Quintela #include "migration/misc.h" 4384a899deSJuan Quintela #include "migration/global_state.h" 44f2a8f0a6SJuan Quintela #include "migration/register.h" 454be21d56SDavid Gibson #include "mmu-hash64.h" 46b4db5413SSuraj Jitindar Singh #include "mmu-book3s-v3.h" 477abd43baSSuraj Jitindar Singh #include "cpu-models.h" 483794d548SAlexey Kardashevskiy #include "qom/cpu.h" 4953018216SPaolo Bonzini 5053018216SPaolo Bonzini #include "hw/boards.h" 510d09e41aSPaolo Bonzini #include "hw/ppc/ppc.h" 5253018216SPaolo Bonzini #include "hw/loader.h" 5353018216SPaolo Bonzini 547804c353SCédric Le Goater #include "hw/ppc/fdt.h" 550d09e41aSPaolo Bonzini #include "hw/ppc/spapr.h" 560d09e41aSPaolo Bonzini #include "hw/ppc/spapr_vio.h" 570d09e41aSPaolo Bonzini #include "hw/pci-host/spapr.h" 580d09e41aSPaolo Bonzini #include "hw/ppc/xics.h" 5953018216SPaolo Bonzini #include "hw/pci/msi.h" 6053018216SPaolo Bonzini 6153018216SPaolo Bonzini #include "hw/pci/pci.h" 6271461b0fSAlexey Kardashevskiy #include "hw/scsi/scsi.h" 6371461b0fSAlexey Kardashevskiy #include "hw/virtio/virtio-scsi.h" 64c4e13492SFelipe Franciosi #include "hw/virtio/vhost-scsi-common.h" 6553018216SPaolo Bonzini 6653018216SPaolo Bonzini #include "exec/address-spaces.h" 6753018216SPaolo Bonzini #include "hw/usb.h" 6853018216SPaolo Bonzini #include "qemu/config-file.h" 69135a129aSAneesh Kumar K.V #include "qemu/error-report.h" 702a6593cbSAlexey Kardashevskiy #include "trace.h" 7134316482SAlexey Kardashevskiy #include "hw/nmi.h" 726449da45SCédric Le Goater #include "hw/intc/intc.h" 7353018216SPaolo Bonzini 7468a27b20SMichael S. Tsirkin #include "hw/compat.h" 75f348b6d1SVeronia Bahaa #include "qemu/cutils.h" 7694a94e4cSBharata B Rao #include "hw/ppc/spapr_cpu_core.h" 772474bfd4SIgor Mammedov #include "qmp-commands.h" 7868a27b20SMichael S. Tsirkin 7953018216SPaolo Bonzini #include <libfdt.h> 8053018216SPaolo Bonzini 8153018216SPaolo Bonzini /* SLOF memory layout: 8253018216SPaolo Bonzini * 8353018216SPaolo Bonzini * SLOF raw image loaded at 0, copies its romfs right below the flat 8453018216SPaolo Bonzini * device-tree, then position SLOF itself 31M below that 8553018216SPaolo Bonzini * 8653018216SPaolo Bonzini * So we set FW_OVERHEAD to 40MB which should account for all of that 8753018216SPaolo Bonzini * and more 8853018216SPaolo Bonzini * 8953018216SPaolo Bonzini * We load our kernel at 4M, leaving space for SLOF initial image 9053018216SPaolo Bonzini */ 9138b02bd8SAlexey Kardashevskiy #define FDT_MAX_SIZE 0x100000 9253018216SPaolo Bonzini #define RTAS_MAX_SIZE 0x10000 93b7d1f77aSBenjamin Herrenschmidt #define RTAS_MAX_ADDR 0x80000000 /* RTAS must stay below that */ 9453018216SPaolo Bonzini #define FW_MAX_SIZE 0x400000 9553018216SPaolo Bonzini #define FW_FILE_NAME "slof.bin" 9653018216SPaolo Bonzini #define FW_OVERHEAD 0x2800000 9753018216SPaolo Bonzini #define KERNEL_LOAD_ADDR FW_MAX_SIZE 9853018216SPaolo Bonzini 9953018216SPaolo Bonzini #define MIN_RMA_SLOF 128UL 10053018216SPaolo Bonzini 10153018216SPaolo Bonzini #define PHANDLE_XICP 0x00001111 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]; 2132e886fb3SSam Bobroff int index = spapr_vcpu_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 { 2422e886fb3SSam Bobroff int index = spapr_vcpu_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 */ 2567abd43baSSuraj Jitindar Singh static void spapr_populate_pa_features(PowerPCCPU *cpu, void *fdt, int offset, 257e957f6a9SSam Bobroff bool legacy_guest) 25886d5771aSSam Bobroff { 2597abd43baSSuraj Jitindar Singh CPUPPCState *env = &cpu->env; 26086d5771aSSam Bobroff uint8_t pa_features_206[] = { 6, 0, 26186d5771aSSam Bobroff 0xf6, 0x1f, 0xc7, 0x00, 0x80, 0xc0 }; 26286d5771aSSam Bobroff uint8_t pa_features_207[] = { 24, 0, 26386d5771aSSam Bobroff 0xf6, 0x1f, 0xc7, 0xc0, 0x80, 0xf0, 26486d5771aSSam Bobroff 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 26586d5771aSSam Bobroff 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 26686d5771aSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x00, 0x00 }; 2679fb4541fSSam Bobroff uint8_t pa_features_300[] = { 66, 0, 2689fb4541fSSam Bobroff /* 0: MMU|FPU|SLB|RUN|DABR|NX, 1: fri[nzpm]|DABRX|SPRG3|SLB0|PP110 */ 2699fb4541fSSam Bobroff /* 2: VPM|DS205|PPR|DS202|DS206, 3: LSD|URG, SSO, 5: LE|CFAR|EB|LSQ */ 27086d5771aSSam Bobroff 0xf6, 0x1f, 0xc7, 0xc0, 0x80, 0xf0, /* 0 - 5 */ 2719fb4541fSSam Bobroff /* 6: DS207 */ 27286d5771aSSam Bobroff 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, /* 6 - 11 */ 2739fb4541fSSam Bobroff /* 16: Vector */ 27486d5771aSSam Bobroff 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, /* 12 - 17 */ 2759fb4541fSSam Bobroff /* 18: Vec. Scalar, 20: Vec. XOR, 22: HTM */ 2769bf502feSDavid Gibson 0x80, 0x00, 0x80, 0x00, 0x00, 0x00, /* 18 - 23 */ 2779fb4541fSSam Bobroff /* 24: Ext. Dec, 26: 64 bit ftrs, 28: PM ftrs */ 2789fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, /* 24 - 29 */ 2799fb4541fSSam Bobroff /* 30: MMR, 32: LE atomic, 34: EBB + ext EBB */ 2809fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0xC0, 0x00, /* 30 - 35 */ 2819fb4541fSSam Bobroff /* 36: SPR SO, 38: Copy/Paste, 40: Radix MMU */ 2829fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, /* 36 - 41 */ 2839fb4541fSSam Bobroff /* 42: PM, 44: PC RA, 46: SC vec'd */ 2849fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, /* 42 - 47 */ 2859fb4541fSSam Bobroff /* 48: SIMD, 50: QP BFP, 52: String */ 2869fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, /* 48 - 53 */ 2879fb4541fSSam Bobroff /* 54: DecFP, 56: DecI, 58: SHA */ 2889fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, /* 54 - 59 */ 2899fb4541fSSam Bobroff /* 60: NM atomic, 62: RNG */ 2909fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x00, 0x00, /* 60 - 65 */ 2919fb4541fSSam Bobroff }; 2927abd43baSSuraj Jitindar Singh uint8_t *pa_features = NULL; 29386d5771aSSam Bobroff size_t pa_size; 29486d5771aSSam Bobroff 2957abd43baSSuraj Jitindar Singh if (ppc_check_compat(cpu, CPU_POWERPC_LOGICAL_2_06, 0, cpu->compat_pvr)) { 29686d5771aSSam Bobroff pa_features = pa_features_206; 29786d5771aSSam Bobroff pa_size = sizeof(pa_features_206); 2987abd43baSSuraj Jitindar Singh } 2997abd43baSSuraj Jitindar Singh if (ppc_check_compat(cpu, CPU_POWERPC_LOGICAL_2_07, 0, cpu->compat_pvr)) { 30086d5771aSSam Bobroff pa_features = pa_features_207; 30186d5771aSSam Bobroff pa_size = sizeof(pa_features_207); 3027abd43baSSuraj Jitindar Singh } 3037abd43baSSuraj Jitindar Singh if (ppc_check_compat(cpu, CPU_POWERPC_LOGICAL_3_00, 0, cpu->compat_pvr)) { 30486d5771aSSam Bobroff pa_features = pa_features_300; 30586d5771aSSam Bobroff pa_size = sizeof(pa_features_300); 3067abd43baSSuraj Jitindar Singh } 3077abd43baSSuraj Jitindar Singh if (!pa_features) { 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); 34482677ed2SAlexey Kardashevskiy DeviceClass *dc = DEVICE_GET_CLASS(cs); 3452e886fb3SSam Bobroff int index = spapr_vcpu_id(cpu); 34612dbeb16SDavid Gibson int compat_smt = MIN(smp_threads, ppc_compat_max_threads(cpu)); 34753018216SPaolo Bonzini 3480f20ba62SAlexey Kardashevskiy if ((index % smt) != 0) { 34953018216SPaolo Bonzini continue; 35053018216SPaolo Bonzini } 35153018216SPaolo Bonzini 35282677ed2SAlexey Kardashevskiy snprintf(cpu_model, 32, "%s@%x", dc->fw_name, index); 35353018216SPaolo Bonzini 35482677ed2SAlexey Kardashevskiy cpus_offset = fdt_path_offset(fdt, "/cpus"); 35582677ed2SAlexey Kardashevskiy if (cpus_offset < 0) { 356a4f3885cSGreg Kurz cpus_offset = fdt_add_subnode(fdt, 0, "cpus"); 35782677ed2SAlexey Kardashevskiy if (cpus_offset < 0) { 35882677ed2SAlexey Kardashevskiy return cpus_offset; 35982677ed2SAlexey Kardashevskiy } 36082677ed2SAlexey Kardashevskiy } 36182677ed2SAlexey Kardashevskiy offset = fdt_subnode_offset(fdt, cpus_offset, cpu_model); 36282677ed2SAlexey Kardashevskiy if (offset < 0) { 36382677ed2SAlexey Kardashevskiy offset = fdt_add_subnode(fdt, cpus_offset, cpu_model); 36453018216SPaolo Bonzini if (offset < 0) { 36553018216SPaolo Bonzini return offset; 36653018216SPaolo Bonzini } 36782677ed2SAlexey Kardashevskiy } 36853018216SPaolo Bonzini 3690da6f3feSBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,pft-size", 3700da6f3feSBharata B Rao pft_size_prop, sizeof(pft_size_prop)); 37153018216SPaolo Bonzini if (ret < 0) { 37253018216SPaolo Bonzini return ret; 37353018216SPaolo Bonzini } 37453018216SPaolo Bonzini 37599861ecbSIgor Mammedov if (nb_numa_nodes > 1) { 37699861ecbSIgor Mammedov ret = spapr_fixup_cpu_numa_dt(fdt, offset, cpu); 37753018216SPaolo Bonzini if (ret < 0) { 37853018216SPaolo Bonzini return ret; 37953018216SPaolo Bonzini } 38099861ecbSIgor Mammedov } 381833d4668SAlexey Kardashevskiy 38212dbeb16SDavid Gibson ret = spapr_fixup_cpu_smt_dt(fdt, offset, cpu, compat_smt); 383833d4668SAlexey Kardashevskiy if (ret < 0) { 384833d4668SAlexey Kardashevskiy return ret; 385833d4668SAlexey Kardashevskiy } 386e957f6a9SSam Bobroff 3877abd43baSSuraj Jitindar Singh spapr_populate_pa_features(cpu, fdt, offset, 388e957f6a9SSam Bobroff spapr->cas_legacy_guest_workaround); 38953018216SPaolo Bonzini } 39053018216SPaolo Bonzini return ret; 39153018216SPaolo Bonzini } 39253018216SPaolo Bonzini 393c86c1affSDaniel Henrique Barboza static hwaddr spapr_node0_size(MachineState *machine) 394b082d65aSAlexey Kardashevskiy { 395b082d65aSAlexey Kardashevskiy if (nb_numa_nodes) { 396b082d65aSAlexey Kardashevskiy int i; 397b082d65aSAlexey Kardashevskiy for (i = 0; i < nb_numa_nodes; ++i) { 398b082d65aSAlexey Kardashevskiy if (numa_info[i].node_mem) { 399fb164994SDavid Gibson return MIN(pow2floor(numa_info[i].node_mem), 400fb164994SDavid Gibson machine->ram_size); 401b082d65aSAlexey Kardashevskiy } 402b082d65aSAlexey Kardashevskiy } 403b082d65aSAlexey Kardashevskiy } 404fb164994SDavid Gibson return machine->ram_size; 405b082d65aSAlexey Kardashevskiy } 406b082d65aSAlexey Kardashevskiy 407a1d59c0fSAlexey Kardashevskiy static void add_str(GString *s, const gchar *s1) 408a1d59c0fSAlexey Kardashevskiy { 409a1d59c0fSAlexey Kardashevskiy g_string_append_len(s, s1, strlen(s1) + 1); 410a1d59c0fSAlexey Kardashevskiy } 41153018216SPaolo Bonzini 41203d196b7SBharata B Rao static int spapr_populate_memory_node(void *fdt, int nodeid, hwaddr start, 41326a8c353SAlexey Kardashevskiy hwaddr size) 41426a8c353SAlexey Kardashevskiy { 41526a8c353SAlexey Kardashevskiy uint32_t associativity[] = { 41626a8c353SAlexey Kardashevskiy cpu_to_be32(0x4), /* length */ 41726a8c353SAlexey Kardashevskiy cpu_to_be32(0x0), cpu_to_be32(0x0), 418c3b4f589SAlexey Kardashevskiy cpu_to_be32(0x0), cpu_to_be32(nodeid) 41926a8c353SAlexey Kardashevskiy }; 42026a8c353SAlexey Kardashevskiy char mem_name[32]; 42126a8c353SAlexey Kardashevskiy uint64_t mem_reg_property[2]; 42226a8c353SAlexey Kardashevskiy int off; 42326a8c353SAlexey Kardashevskiy 42426a8c353SAlexey Kardashevskiy mem_reg_property[0] = cpu_to_be64(start); 42526a8c353SAlexey Kardashevskiy mem_reg_property[1] = cpu_to_be64(size); 42626a8c353SAlexey Kardashevskiy 42726a8c353SAlexey Kardashevskiy sprintf(mem_name, "memory@" TARGET_FMT_lx, start); 42826a8c353SAlexey Kardashevskiy off = fdt_add_subnode(fdt, 0, mem_name); 42926a8c353SAlexey Kardashevskiy _FDT(off); 43026a8c353SAlexey Kardashevskiy _FDT((fdt_setprop_string(fdt, off, "device_type", "memory"))); 43126a8c353SAlexey Kardashevskiy _FDT((fdt_setprop(fdt, off, "reg", mem_reg_property, 43226a8c353SAlexey Kardashevskiy sizeof(mem_reg_property)))); 43326a8c353SAlexey Kardashevskiy _FDT((fdt_setprop(fdt, off, "ibm,associativity", associativity, 43426a8c353SAlexey Kardashevskiy sizeof(associativity)))); 43503d196b7SBharata B Rao return off; 43626a8c353SAlexey Kardashevskiy } 43726a8c353SAlexey Kardashevskiy 43828e02042SDavid Gibson static int spapr_populate_memory(sPAPRMachineState *spapr, void *fdt) 43953018216SPaolo Bonzini { 440fb164994SDavid Gibson MachineState *machine = MACHINE(spapr); 4417db8a127SAlexey Kardashevskiy hwaddr mem_start, node_size; 4427db8a127SAlexey Kardashevskiy int i, nb_nodes = nb_numa_nodes; 4437db8a127SAlexey Kardashevskiy NodeInfo *nodes = numa_info; 4447db8a127SAlexey Kardashevskiy NodeInfo ramnode; 44553018216SPaolo Bonzini 4467db8a127SAlexey Kardashevskiy /* No NUMA nodes, assume there is just one node with whole RAM */ 4477db8a127SAlexey Kardashevskiy if (!nb_numa_nodes) { 4487db8a127SAlexey Kardashevskiy nb_nodes = 1; 449fb164994SDavid Gibson ramnode.node_mem = machine->ram_size; 4507db8a127SAlexey Kardashevskiy nodes = &ramnode; 4515fe269b1SPaul Mackerras } 45253018216SPaolo Bonzini 4537db8a127SAlexey Kardashevskiy for (i = 0, mem_start = 0; i < nb_nodes; ++i) { 4547db8a127SAlexey Kardashevskiy if (!nodes[i].node_mem) { 4557db8a127SAlexey Kardashevskiy continue; 45653018216SPaolo Bonzini } 457fb164994SDavid Gibson if (mem_start >= machine->ram_size) { 4585fe269b1SPaul Mackerras node_size = 0; 4595fe269b1SPaul Mackerras } else { 4607db8a127SAlexey Kardashevskiy node_size = nodes[i].node_mem; 461fb164994SDavid Gibson if (node_size > machine->ram_size - mem_start) { 462fb164994SDavid Gibson node_size = machine->ram_size - mem_start; 4635fe269b1SPaul Mackerras } 4645fe269b1SPaul Mackerras } 4657db8a127SAlexey Kardashevskiy if (!mem_start) { 4667db8a127SAlexey Kardashevskiy /* ppc_spapr_init() checks for rma_size <= node0_size already */ 467e8f986fcSBharata B Rao spapr_populate_memory_node(fdt, i, 0, spapr->rma_size); 4687db8a127SAlexey Kardashevskiy mem_start += spapr->rma_size; 4697db8a127SAlexey Kardashevskiy node_size -= spapr->rma_size; 4707db8a127SAlexey Kardashevskiy } 4716010818cSAlexey Kardashevskiy for ( ; node_size; ) { 4726010818cSAlexey Kardashevskiy hwaddr sizetmp = pow2floor(node_size); 4736010818cSAlexey Kardashevskiy 4746010818cSAlexey Kardashevskiy /* mem_start != 0 here */ 4756010818cSAlexey Kardashevskiy if (ctzl(mem_start) < ctzl(sizetmp)) { 4766010818cSAlexey Kardashevskiy sizetmp = 1ULL << ctzl(mem_start); 4776010818cSAlexey Kardashevskiy } 4786010818cSAlexey Kardashevskiy 4796010818cSAlexey Kardashevskiy spapr_populate_memory_node(fdt, i, mem_start, sizetmp); 4806010818cSAlexey Kardashevskiy node_size -= sizetmp; 4816010818cSAlexey Kardashevskiy mem_start += sizetmp; 4826010818cSAlexey Kardashevskiy } 48353018216SPaolo Bonzini } 48453018216SPaolo Bonzini 48553018216SPaolo Bonzini return 0; 48653018216SPaolo Bonzini } 48753018216SPaolo Bonzini 4880da6f3feSBharata B Rao static void spapr_populate_cpu_dt(CPUState *cs, void *fdt, int offset, 4890da6f3feSBharata B Rao sPAPRMachineState *spapr) 4900da6f3feSBharata B Rao { 4910da6f3feSBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(cs); 4920da6f3feSBharata B Rao CPUPPCState *env = &cpu->env; 4930da6f3feSBharata B Rao PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(cs); 4942e886fb3SSam Bobroff int index = spapr_vcpu_id(cpu); 4950da6f3feSBharata B Rao uint32_t segs[] = {cpu_to_be32(28), cpu_to_be32(40), 4960da6f3feSBharata B Rao 0xffffffff, 0xffffffff}; 497afd10a0fSBharata B Rao uint32_t tbfreq = kvm_enabled() ? kvmppc_get_tbfreq() 498afd10a0fSBharata B Rao : SPAPR_TIMEBASE_FREQ; 4990da6f3feSBharata B Rao uint32_t cpufreq = kvm_enabled() ? kvmppc_get_clockfreq() : 1000000000; 5000da6f3feSBharata B Rao uint32_t page_sizes_prop[64]; 5010da6f3feSBharata B Rao size_t page_sizes_prop_size; 50222419c2aSDavid Gibson uint32_t vcpus_per_socket = smp_threads * smp_cores; 5030da6f3feSBharata B Rao uint32_t pft_size_prop[] = {0, cpu_to_be32(spapr->htab_shift)}; 50412dbeb16SDavid Gibson int compat_smt = MIN(smp_threads, ppc_compat_max_threads(cpu)); 505af81cf32SBharata B Rao sPAPRDRConnector *drc; 506af81cf32SBharata B Rao int drc_index; 507c64abd1fSSam Bobroff uint32_t radix_AP_encodings[PPC_PAGE_SIZES_MAX_SZ]; 508c64abd1fSSam Bobroff int i; 509af81cf32SBharata B Rao 510fbf55397SDavid Gibson drc = spapr_drc_by_id(TYPE_SPAPR_DRC_CPU, index); 511af81cf32SBharata B Rao if (drc) { 5120b55aa91SDavid Gibson drc_index = spapr_drc_index(drc); 513af81cf32SBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,my-drc-index", drc_index))); 514af81cf32SBharata B Rao } 5150da6f3feSBharata B Rao 5160da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "reg", index))); 5170da6f3feSBharata B Rao _FDT((fdt_setprop_string(fdt, offset, "device_type", "cpu"))); 5180da6f3feSBharata B Rao 5190da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "cpu-version", env->spr[SPR_PVR]))); 5200da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "d-cache-block-size", 5210da6f3feSBharata B Rao env->dcache_line_size))); 5220da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "d-cache-line-size", 5230da6f3feSBharata B Rao env->dcache_line_size))); 5240da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "i-cache-block-size", 5250da6f3feSBharata B Rao env->icache_line_size))); 5260da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "i-cache-line-size", 5270da6f3feSBharata B Rao env->icache_line_size))); 5280da6f3feSBharata B Rao 5290da6f3feSBharata B Rao if (pcc->l1_dcache_size) { 5300da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "d-cache-size", 5310da6f3feSBharata B Rao pcc->l1_dcache_size))); 5320da6f3feSBharata B Rao } else { 5333dc6f869SAlistair Francis warn_report("Unknown L1 dcache size for cpu"); 5340da6f3feSBharata B Rao } 5350da6f3feSBharata B Rao if (pcc->l1_icache_size) { 5360da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "i-cache-size", 5370da6f3feSBharata B Rao pcc->l1_icache_size))); 5380da6f3feSBharata B Rao } else { 5393dc6f869SAlistair Francis warn_report("Unknown L1 icache size for cpu"); 5400da6f3feSBharata B Rao } 5410da6f3feSBharata B Rao 5420da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "timebase-frequency", tbfreq))); 5430da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "clock-frequency", cpufreq))); 544fd5da5c4SThomas Huth _FDT((fdt_setprop_cell(fdt, offset, "slb-size", env->slb_nr))); 5450da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,slb-size", env->slb_nr))); 5460da6f3feSBharata B Rao _FDT((fdt_setprop_string(fdt, offset, "status", "okay"))); 5470da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "64-bit", NULL, 0))); 5480da6f3feSBharata B Rao 5490da6f3feSBharata B Rao if (env->spr_cb[SPR_PURR].oea_read) { 5500da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,purr", NULL, 0))); 5510da6f3feSBharata B Rao } 5520da6f3feSBharata B Rao 5530da6f3feSBharata B Rao if (env->mmu_model & POWERPC_MMU_1TSEG) { 5540da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,processor-segment-sizes", 5550da6f3feSBharata B Rao segs, sizeof(segs)))); 5560da6f3feSBharata B Rao } 5570da6f3feSBharata B Rao 5580da6f3feSBharata B Rao /* Advertise VMX/VSX (vector extensions) if available 5590da6f3feSBharata B Rao * 0 / no property == no vector extensions 5600da6f3feSBharata B Rao * 1 == VMX / Altivec available 5610da6f3feSBharata B Rao * 2 == VSX available */ 5620da6f3feSBharata B Rao if (env->insns_flags & PPC_ALTIVEC) { 5630da6f3feSBharata B Rao uint32_t vmx = (env->insns_flags2 & PPC2_VSX) ? 2 : 1; 5640da6f3feSBharata B Rao 5650da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,vmx", vmx))); 5660da6f3feSBharata B Rao } 5670da6f3feSBharata B Rao 5680da6f3feSBharata B Rao /* Advertise DFP (Decimal Floating Point) if available 5690da6f3feSBharata B Rao * 0 / no property == no DFP 5700da6f3feSBharata B Rao * 1 == DFP available */ 5710da6f3feSBharata B Rao if (env->insns_flags2 & PPC2_DFP) { 5720da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,dfp", 1))); 5730da6f3feSBharata B Rao } 5740da6f3feSBharata B Rao 5753654fa95SCédric Le Goater page_sizes_prop_size = ppc_create_page_sizes_prop(env, page_sizes_prop, 5760da6f3feSBharata B Rao sizeof(page_sizes_prop)); 5770da6f3feSBharata B Rao if (page_sizes_prop_size) { 5780da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,segment-page-sizes", 5790da6f3feSBharata B Rao page_sizes_prop, page_sizes_prop_size))); 5800da6f3feSBharata B Rao } 5810da6f3feSBharata B Rao 5827abd43baSSuraj Jitindar Singh spapr_populate_pa_features(cpu, fdt, offset, false); 58390da0d5aSBenjamin Herrenschmidt 5840da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,chip-id", 58522419c2aSDavid Gibson cs->cpu_index / vcpus_per_socket))); 5860da6f3feSBharata B Rao 5870da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,pft-size", 5880da6f3feSBharata B Rao pft_size_prop, sizeof(pft_size_prop)))); 5890da6f3feSBharata B Rao 59099861ecbSIgor Mammedov if (nb_numa_nodes > 1) { 59199861ecbSIgor Mammedov _FDT(spapr_fixup_cpu_numa_dt(fdt, offset, cpu)); 59299861ecbSIgor Mammedov } 5930da6f3feSBharata B Rao 59412dbeb16SDavid Gibson _FDT(spapr_fixup_cpu_smt_dt(fdt, offset, cpu, compat_smt)); 595c64abd1fSSam Bobroff 596c64abd1fSSam Bobroff if (pcc->radix_page_info) { 597c64abd1fSSam Bobroff for (i = 0; i < pcc->radix_page_info->count; i++) { 598c64abd1fSSam Bobroff radix_AP_encodings[i] = 599c64abd1fSSam Bobroff cpu_to_be32(pcc->radix_page_info->entries[i]); 600c64abd1fSSam Bobroff } 601c64abd1fSSam Bobroff _FDT((fdt_setprop(fdt, offset, "ibm,processor-radix-AP-encodings", 602c64abd1fSSam Bobroff radix_AP_encodings, 603c64abd1fSSam Bobroff pcc->radix_page_info->count * 604c64abd1fSSam Bobroff sizeof(radix_AP_encodings[0])))); 605c64abd1fSSam Bobroff } 6060da6f3feSBharata B Rao } 6070da6f3feSBharata B Rao 6080da6f3feSBharata B Rao static void spapr_populate_cpus_dt_node(void *fdt, sPAPRMachineState *spapr) 6090da6f3feSBharata B Rao { 6100da6f3feSBharata B Rao CPUState *cs; 6110da6f3feSBharata B Rao int cpus_offset; 6120da6f3feSBharata B Rao char *nodename; 6130da6f3feSBharata B Rao int smt = kvmppc_smt_threads(); 6140da6f3feSBharata B Rao 6150da6f3feSBharata B Rao cpus_offset = fdt_add_subnode(fdt, 0, "cpus"); 6160da6f3feSBharata B Rao _FDT(cpus_offset); 6170da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, cpus_offset, "#address-cells", 0x1))); 6180da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, cpus_offset, "#size-cells", 0x0))); 6190da6f3feSBharata B Rao 6200da6f3feSBharata B Rao /* 6210da6f3feSBharata B Rao * We walk the CPUs in reverse order to ensure that CPU DT nodes 6220da6f3feSBharata B Rao * created by fdt_add_subnode() end up in the right order in FDT 6230da6f3feSBharata B Rao * for the guest kernel the enumerate the CPUs correctly. 6240da6f3feSBharata B Rao */ 6250da6f3feSBharata B Rao CPU_FOREACH_REVERSE(cs) { 6260da6f3feSBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(cs); 6272e886fb3SSam Bobroff int index = spapr_vcpu_id(cpu); 6280da6f3feSBharata B Rao DeviceClass *dc = DEVICE_GET_CLASS(cs); 6290da6f3feSBharata B Rao int offset; 6300da6f3feSBharata B Rao 6310da6f3feSBharata B Rao if ((index % smt) != 0) { 6320da6f3feSBharata B Rao continue; 6330da6f3feSBharata B Rao } 6340da6f3feSBharata B Rao 6350da6f3feSBharata B Rao nodename = g_strdup_printf("%s@%x", dc->fw_name, index); 6360da6f3feSBharata B Rao offset = fdt_add_subnode(fdt, cpus_offset, nodename); 6370da6f3feSBharata B Rao g_free(nodename); 6380da6f3feSBharata B Rao _FDT(offset); 6390da6f3feSBharata B Rao spapr_populate_cpu_dt(cs, fdt, offset, spapr); 6400da6f3feSBharata B Rao } 6410da6f3feSBharata B Rao 6420da6f3feSBharata B Rao } 6430da6f3feSBharata B Rao 64403d196b7SBharata B Rao /* 64503d196b7SBharata B Rao * Adds ibm,dynamic-reconfiguration-memory node. 64603d196b7SBharata B Rao * Refer to docs/specs/ppc-spapr-hotplug.txt for the documentation 64703d196b7SBharata B Rao * of this device tree node. 64803d196b7SBharata B Rao */ 64903d196b7SBharata B Rao static int spapr_populate_drconf_memory(sPAPRMachineState *spapr, void *fdt) 65003d196b7SBharata B Rao { 65103d196b7SBharata B Rao MachineState *machine = MACHINE(spapr); 65203d196b7SBharata B Rao int ret, i, offset; 65303d196b7SBharata B Rao uint64_t lmb_size = SPAPR_MEMORY_BLOCK_SIZE; 65403d196b7SBharata B Rao uint32_t prop_lmb_size[] = {0, cpu_to_be32(lmb_size)}; 655d0e5a8f2SBharata B Rao uint32_t hotplug_lmb_start = spapr->hotplug_memory.base / lmb_size; 656d0e5a8f2SBharata B Rao uint32_t nr_lmbs = (spapr->hotplug_memory.base + 657d0e5a8f2SBharata B Rao memory_region_size(&spapr->hotplug_memory.mr)) / 658d0e5a8f2SBharata B Rao lmb_size; 65903d196b7SBharata B Rao uint32_t *int_buf, *cur_index, buf_len; 6606663864eSBharata B Rao int nr_nodes = nb_numa_nodes ? nb_numa_nodes : 1; 66103d196b7SBharata B Rao 662ef001f06SThomas Huth /* 663d0e5a8f2SBharata B Rao * Don't create the node if there is no hotpluggable memory 66416c25aefSBharata B Rao */ 665d0e5a8f2SBharata B Rao if (machine->ram_size == machine->maxram_size) { 66616c25aefSBharata B Rao return 0; 66716c25aefSBharata B Rao } 66816c25aefSBharata B Rao 66916c25aefSBharata B Rao /* 670ef001f06SThomas Huth * Allocate enough buffer size to fit in ibm,dynamic-memory 671ef001f06SThomas Huth * or ibm,associativity-lookup-arrays 672ef001f06SThomas Huth */ 673ef001f06SThomas Huth buf_len = MAX(nr_lmbs * SPAPR_DR_LMB_LIST_ENTRY_SIZE + 1, nr_nodes * 4 + 2) 674ef001f06SThomas Huth * sizeof(uint32_t); 67503d196b7SBharata B Rao cur_index = int_buf = g_malloc0(buf_len); 67603d196b7SBharata B Rao 67703d196b7SBharata B Rao offset = fdt_add_subnode(fdt, 0, "ibm,dynamic-reconfiguration-memory"); 67803d196b7SBharata B Rao 67903d196b7SBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,lmb-size", prop_lmb_size, 68003d196b7SBharata B Rao sizeof(prop_lmb_size)); 68103d196b7SBharata B Rao if (ret < 0) { 68203d196b7SBharata B Rao goto out; 68303d196b7SBharata B Rao } 68403d196b7SBharata B Rao 68503d196b7SBharata B Rao ret = fdt_setprop_cell(fdt, offset, "ibm,memory-flags-mask", 0xff); 68603d196b7SBharata B Rao if (ret < 0) { 68703d196b7SBharata B Rao goto out; 68803d196b7SBharata B Rao } 68903d196b7SBharata B Rao 69003d196b7SBharata B Rao ret = fdt_setprop_cell(fdt, offset, "ibm,memory-preservation-time", 0x0); 69103d196b7SBharata B Rao if (ret < 0) { 69203d196b7SBharata B Rao goto out; 69303d196b7SBharata B Rao } 69403d196b7SBharata B Rao 69503d196b7SBharata B Rao /* ibm,dynamic-memory */ 69603d196b7SBharata B Rao int_buf[0] = cpu_to_be32(nr_lmbs); 69703d196b7SBharata B Rao cur_index++; 69803d196b7SBharata B Rao for (i = 0; i < nr_lmbs; i++) { 699d0e5a8f2SBharata B Rao uint64_t addr = i * lmb_size; 70003d196b7SBharata B Rao uint32_t *dynamic_memory = cur_index; 70103d196b7SBharata B Rao 702d0e5a8f2SBharata B Rao if (i >= hotplug_lmb_start) { 703d0e5a8f2SBharata B Rao sPAPRDRConnector *drc; 704d0e5a8f2SBharata B Rao 705fbf55397SDavid Gibson drc = spapr_drc_by_id(TYPE_SPAPR_DRC_LMB, i); 70603d196b7SBharata B Rao g_assert(drc); 70703d196b7SBharata B Rao 70803d196b7SBharata B Rao dynamic_memory[0] = cpu_to_be32(addr >> 32); 70903d196b7SBharata B Rao dynamic_memory[1] = cpu_to_be32(addr & 0xffffffff); 7100b55aa91SDavid Gibson dynamic_memory[2] = cpu_to_be32(spapr_drc_index(drc)); 71103d196b7SBharata B Rao dynamic_memory[3] = cpu_to_be32(0); /* reserved */ 71203d196b7SBharata B Rao dynamic_memory[4] = cpu_to_be32(numa_get_node(addr, NULL)); 713d0e5a8f2SBharata B Rao if (memory_region_present(get_system_memory(), addr)) { 71403d196b7SBharata B Rao dynamic_memory[5] = cpu_to_be32(SPAPR_LMB_FLAGS_ASSIGNED); 71503d196b7SBharata B Rao } else { 71603d196b7SBharata B Rao dynamic_memory[5] = cpu_to_be32(0); 71703d196b7SBharata B Rao } 718d0e5a8f2SBharata B Rao } else { 719d0e5a8f2SBharata B Rao /* 720d0e5a8f2SBharata B Rao * LMB information for RMA, boot time RAM and gap b/n RAM and 721d0e5a8f2SBharata B Rao * hotplug memory region -- all these are marked as reserved 722d0e5a8f2SBharata B Rao * and as having no valid DRC. 723d0e5a8f2SBharata B Rao */ 724d0e5a8f2SBharata B Rao dynamic_memory[0] = cpu_to_be32(addr >> 32); 725d0e5a8f2SBharata B Rao dynamic_memory[1] = cpu_to_be32(addr & 0xffffffff); 726d0e5a8f2SBharata B Rao dynamic_memory[2] = cpu_to_be32(0); 727d0e5a8f2SBharata B Rao dynamic_memory[3] = cpu_to_be32(0); /* reserved */ 728d0e5a8f2SBharata B Rao dynamic_memory[4] = cpu_to_be32(-1); 729d0e5a8f2SBharata B Rao dynamic_memory[5] = cpu_to_be32(SPAPR_LMB_FLAGS_RESERVED | 730d0e5a8f2SBharata B Rao SPAPR_LMB_FLAGS_DRC_INVALID); 731d0e5a8f2SBharata B Rao } 73203d196b7SBharata B Rao 73303d196b7SBharata B Rao cur_index += SPAPR_DR_LMB_LIST_ENTRY_SIZE; 73403d196b7SBharata B Rao } 73503d196b7SBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,dynamic-memory", int_buf, buf_len); 73603d196b7SBharata B Rao if (ret < 0) { 73703d196b7SBharata B Rao goto out; 73803d196b7SBharata B Rao } 73903d196b7SBharata B Rao 74003d196b7SBharata B Rao /* ibm,associativity-lookup-arrays */ 74103d196b7SBharata B Rao cur_index = int_buf; 7426663864eSBharata B Rao int_buf[0] = cpu_to_be32(nr_nodes); 74303d196b7SBharata B Rao int_buf[1] = cpu_to_be32(4); /* Number of entries per associativity list */ 74403d196b7SBharata B Rao cur_index += 2; 7456663864eSBharata B Rao for (i = 0; i < nr_nodes; i++) { 74603d196b7SBharata B Rao uint32_t associativity[] = { 74703d196b7SBharata B Rao cpu_to_be32(0x0), 74803d196b7SBharata B Rao cpu_to_be32(0x0), 74903d196b7SBharata B Rao cpu_to_be32(0x0), 75003d196b7SBharata B Rao cpu_to_be32(i) 75103d196b7SBharata B Rao }; 75203d196b7SBharata B Rao memcpy(cur_index, associativity, sizeof(associativity)); 75303d196b7SBharata B Rao cur_index += 4; 75403d196b7SBharata B Rao } 75503d196b7SBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,associativity-lookup-arrays", int_buf, 75603d196b7SBharata B Rao (cur_index - int_buf) * sizeof(uint32_t)); 75703d196b7SBharata B Rao out: 75803d196b7SBharata B Rao g_free(int_buf); 75903d196b7SBharata B Rao return ret; 76003d196b7SBharata B Rao } 76103d196b7SBharata B Rao 7626787d27bSMichael Roth static int spapr_dt_cas_updates(sPAPRMachineState *spapr, void *fdt, 7636787d27bSMichael Roth sPAPROptionVector *ov5_updates) 7646787d27bSMichael Roth { 7656787d27bSMichael Roth sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(spapr); 766417ece33SMichael Roth int ret = 0, offset; 7676787d27bSMichael Roth 7686787d27bSMichael Roth /* Generate ibm,dynamic-reconfiguration-memory node if required */ 7696787d27bSMichael Roth if (spapr_ovec_test(ov5_updates, OV5_DRCONF_MEMORY)) { 7706787d27bSMichael Roth g_assert(smc->dr_lmb_enabled); 7716787d27bSMichael Roth ret = spapr_populate_drconf_memory(spapr, fdt); 772417ece33SMichael Roth if (ret) { 773417ece33SMichael Roth goto out; 774417ece33SMichael Roth } 7756787d27bSMichael Roth } 7766787d27bSMichael Roth 777417ece33SMichael Roth offset = fdt_path_offset(fdt, "/chosen"); 778417ece33SMichael Roth if (offset < 0) { 779417ece33SMichael Roth offset = fdt_add_subnode(fdt, 0, "chosen"); 780417ece33SMichael Roth if (offset < 0) { 781417ece33SMichael Roth return offset; 782417ece33SMichael Roth } 783417ece33SMichael Roth } 784417ece33SMichael Roth ret = spapr_ovec_populate_dt(fdt, offset, spapr->ov5_cas, 785417ece33SMichael Roth "ibm,architecture-vec-5"); 786417ece33SMichael Roth 787417ece33SMichael Roth out: 7886787d27bSMichael Roth return ret; 7896787d27bSMichael Roth } 7906787d27bSMichael Roth 79110f12e64SDaniel Henrique Barboza static bool spapr_hotplugged_dev_before_cas(void) 79210f12e64SDaniel Henrique Barboza { 79310f12e64SDaniel Henrique Barboza Object *drc_container, *obj; 79410f12e64SDaniel Henrique Barboza ObjectProperty *prop; 79510f12e64SDaniel Henrique Barboza ObjectPropertyIterator iter; 79610f12e64SDaniel Henrique Barboza 79710f12e64SDaniel Henrique Barboza drc_container = container_get(object_get_root(), "/dr-connector"); 79810f12e64SDaniel Henrique Barboza object_property_iter_init(&iter, drc_container); 79910f12e64SDaniel Henrique Barboza while ((prop = object_property_iter_next(&iter))) { 80010f12e64SDaniel Henrique Barboza if (!strstart(prop->type, "link<", NULL)) { 80110f12e64SDaniel Henrique Barboza continue; 80210f12e64SDaniel Henrique Barboza } 80310f12e64SDaniel Henrique Barboza obj = object_property_get_link(drc_container, prop->name, NULL); 80410f12e64SDaniel Henrique Barboza if (spapr_drc_needed(obj)) { 80510f12e64SDaniel Henrique Barboza return true; 80610f12e64SDaniel Henrique Barboza } 80710f12e64SDaniel Henrique Barboza } 80810f12e64SDaniel Henrique Barboza return false; 80910f12e64SDaniel Henrique Barboza } 81010f12e64SDaniel Henrique Barboza 81103d196b7SBharata B Rao int spapr_h_cas_compose_response(sPAPRMachineState *spapr, 81203d196b7SBharata B Rao target_ulong addr, target_ulong size, 8136787d27bSMichael Roth sPAPROptionVector *ov5_updates) 81403d196b7SBharata B Rao { 81503d196b7SBharata B Rao void *fdt, *fdt_skel; 81603d196b7SBharata B Rao sPAPRDeviceTreeUpdateHeader hdr = { .version_id = 1 }; 81703d196b7SBharata B Rao 81810f12e64SDaniel Henrique Barboza if (spapr_hotplugged_dev_before_cas()) { 81910f12e64SDaniel Henrique Barboza return 1; 82010f12e64SDaniel Henrique Barboza } 82110f12e64SDaniel Henrique Barboza 822827b17c4SGreg Kurz if (size < sizeof(hdr) || size > FW_MAX_SIZE) { 823827b17c4SGreg Kurz error_report("SLOF provided an unexpected CAS buffer size " 824827b17c4SGreg Kurz TARGET_FMT_lu " (min: %zu, max: %u)", 825827b17c4SGreg Kurz size, sizeof(hdr), FW_MAX_SIZE); 826827b17c4SGreg Kurz exit(EXIT_FAILURE); 827827b17c4SGreg Kurz } 828827b17c4SGreg Kurz 82903d196b7SBharata B Rao size -= sizeof(hdr); 83003d196b7SBharata B Rao 83110f12e64SDaniel Henrique Barboza /* Create skeleton */ 83203d196b7SBharata B Rao fdt_skel = g_malloc0(size); 83303d196b7SBharata B Rao _FDT((fdt_create(fdt_skel, size))); 83403d196b7SBharata B Rao _FDT((fdt_begin_node(fdt_skel, ""))); 83503d196b7SBharata B Rao _FDT((fdt_end_node(fdt_skel))); 83603d196b7SBharata B Rao _FDT((fdt_finish(fdt_skel))); 83703d196b7SBharata B Rao fdt = g_malloc0(size); 83803d196b7SBharata B Rao _FDT((fdt_open_into(fdt_skel, fdt, size))); 83903d196b7SBharata B Rao g_free(fdt_skel); 84003d196b7SBharata B Rao 84103d196b7SBharata B Rao /* Fixup cpu nodes */ 84203d196b7SBharata B Rao _FDT((spapr_fixup_cpu_dt(fdt, spapr))); 84303d196b7SBharata B Rao 8446787d27bSMichael Roth if (spapr_dt_cas_updates(spapr, fdt, ov5_updates)) { 8456787d27bSMichael Roth return -1; 84603d196b7SBharata B Rao } 84703d196b7SBharata B Rao 84803d196b7SBharata B Rao /* Pack resulting tree */ 84903d196b7SBharata B Rao _FDT((fdt_pack(fdt))); 85003d196b7SBharata B Rao 85103d196b7SBharata B Rao if (fdt_totalsize(fdt) + sizeof(hdr) > size) { 85203d196b7SBharata B Rao trace_spapr_cas_failed(size); 85303d196b7SBharata B Rao return -1; 85403d196b7SBharata B Rao } 85503d196b7SBharata B Rao 85603d196b7SBharata B Rao cpu_physical_memory_write(addr, &hdr, sizeof(hdr)); 85703d196b7SBharata B Rao cpu_physical_memory_write(addr + sizeof(hdr), fdt, fdt_totalsize(fdt)); 85803d196b7SBharata B Rao trace_spapr_cas_continue(fdt_totalsize(fdt) + sizeof(hdr)); 85903d196b7SBharata B Rao g_free(fdt); 86003d196b7SBharata B Rao 86103d196b7SBharata B Rao return 0; 86203d196b7SBharata B Rao } 86303d196b7SBharata B Rao 8643f5dabceSDavid Gibson static void spapr_dt_rtas(sPAPRMachineState *spapr, void *fdt) 8653f5dabceSDavid Gibson { 8663f5dabceSDavid Gibson int rtas; 8673f5dabceSDavid Gibson GString *hypertas = g_string_sized_new(256); 8683f5dabceSDavid Gibson GString *qemu_hypertas = g_string_sized_new(256); 8693f5dabceSDavid Gibson uint32_t refpoints[] = { cpu_to_be32(0x4), cpu_to_be32(0x4) }; 8703f5dabceSDavid Gibson uint64_t max_hotplug_addr = spapr->hotplug_memory.base + 8713f5dabceSDavid Gibson memory_region_size(&spapr->hotplug_memory.mr); 8723f5dabceSDavid Gibson uint32_t lrdr_capacity[] = { 8733f5dabceSDavid Gibson cpu_to_be32(max_hotplug_addr >> 32), 8743f5dabceSDavid Gibson cpu_to_be32(max_hotplug_addr & 0xffffffff), 8753f5dabceSDavid Gibson 0, cpu_to_be32(SPAPR_MEMORY_BLOCK_SIZE), 8763f5dabceSDavid Gibson cpu_to_be32(max_cpus / smp_threads), 8773f5dabceSDavid Gibson }; 8783f5dabceSDavid Gibson 8793f5dabceSDavid Gibson _FDT(rtas = fdt_add_subnode(fdt, 0, "rtas")); 8803f5dabceSDavid Gibson 8813f5dabceSDavid Gibson /* hypertas */ 8823f5dabceSDavid Gibson add_str(hypertas, "hcall-pft"); 8833f5dabceSDavid Gibson add_str(hypertas, "hcall-term"); 8843f5dabceSDavid Gibson add_str(hypertas, "hcall-dabr"); 8853f5dabceSDavid Gibson add_str(hypertas, "hcall-interrupt"); 8863f5dabceSDavid Gibson add_str(hypertas, "hcall-tce"); 8873f5dabceSDavid Gibson add_str(hypertas, "hcall-vio"); 8883f5dabceSDavid Gibson add_str(hypertas, "hcall-splpar"); 8893f5dabceSDavid Gibson add_str(hypertas, "hcall-bulk"); 8903f5dabceSDavid Gibson add_str(hypertas, "hcall-set-mode"); 8913f5dabceSDavid Gibson add_str(hypertas, "hcall-sprg0"); 8923f5dabceSDavid Gibson add_str(hypertas, "hcall-copy"); 8933f5dabceSDavid Gibson add_str(hypertas, "hcall-debug"); 8943f5dabceSDavid Gibson add_str(qemu_hypertas, "hcall-memop1"); 8953f5dabceSDavid Gibson 8963f5dabceSDavid Gibson if (!kvm_enabled() || kvmppc_spapr_use_multitce()) { 8973f5dabceSDavid Gibson add_str(hypertas, "hcall-multi-tce"); 8983f5dabceSDavid Gibson } 89930f4b05bSDavid Gibson 90030f4b05bSDavid Gibson if (spapr->resize_hpt != SPAPR_RESIZE_HPT_DISABLED) { 90130f4b05bSDavid Gibson add_str(hypertas, "hcall-hpt-resize"); 90230f4b05bSDavid Gibson } 90330f4b05bSDavid Gibson 9043f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,hypertas-functions", 9053f5dabceSDavid Gibson hypertas->str, hypertas->len)); 9063f5dabceSDavid Gibson g_string_free(hypertas, TRUE); 9073f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "qemu,hypertas-functions", 9083f5dabceSDavid Gibson qemu_hypertas->str, qemu_hypertas->len)); 9093f5dabceSDavid Gibson g_string_free(qemu_hypertas, TRUE); 9103f5dabceSDavid Gibson 9113f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,associativity-reference-points", 9123f5dabceSDavid Gibson refpoints, sizeof(refpoints))); 9133f5dabceSDavid Gibson 9143f5dabceSDavid Gibson _FDT(fdt_setprop_cell(fdt, rtas, "rtas-error-log-max", 9153f5dabceSDavid Gibson RTAS_ERROR_LOG_MAX)); 9163f5dabceSDavid Gibson _FDT(fdt_setprop_cell(fdt, rtas, "rtas-event-scan-rate", 9173f5dabceSDavid Gibson RTAS_EVENT_SCAN_RATE)); 9183f5dabceSDavid Gibson 9193f5dabceSDavid Gibson if (msi_nonbroken) { 9203f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,change-msix-capable", NULL, 0)); 9213f5dabceSDavid Gibson } 9223f5dabceSDavid Gibson 9233f5dabceSDavid Gibson /* 9243f5dabceSDavid Gibson * According to PAPR, rtas ibm,os-term does not guarantee a return 9253f5dabceSDavid Gibson * back to the guest cpu. 9263f5dabceSDavid Gibson * 9273f5dabceSDavid Gibson * While an additional ibm,extended-os-term property indicates 9283f5dabceSDavid Gibson * that rtas call return will always occur. Set this property. 9293f5dabceSDavid Gibson */ 9303f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,extended-os-term", NULL, 0)); 9313f5dabceSDavid Gibson 9323f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,lrdr-capacity", 9333f5dabceSDavid Gibson lrdr_capacity, sizeof(lrdr_capacity))); 9343f5dabceSDavid Gibson 9353f5dabceSDavid Gibson spapr_dt_rtas_tokens(fdt, rtas); 9363f5dabceSDavid Gibson } 9373f5dabceSDavid Gibson 9389fb4541fSSam Bobroff /* Prepare ibm,arch-vec-5-platform-support, which indicates the MMU features 9399fb4541fSSam Bobroff * that the guest may request and thus the valid values for bytes 24..26 of 9409fb4541fSSam Bobroff * option vector 5: */ 9419fb4541fSSam Bobroff static void spapr_dt_ov5_platform_support(void *fdt, int chosen) 9429fb4541fSSam Bobroff { 943545d6e2bSSuraj Jitindar Singh PowerPCCPU *first_ppc_cpu = POWERPC_CPU(first_cpu); 944545d6e2bSSuraj Jitindar Singh 945f2b14e3aSCédric Le Goater char val[2 * 4] = { 94621f3f8dbSCédric Le Goater 23, 0x00, /* Xive mode, filled in below. */ 9479fb4541fSSam Bobroff 24, 0x00, /* Hash/Radix, filled in below. */ 9489fb4541fSSam Bobroff 25, 0x00, /* Hash options: Segment Tables == no, GTSE == no. */ 9499fb4541fSSam Bobroff 26, 0x40, /* Radix options: GTSE == yes. */ 9509fb4541fSSam Bobroff }; 9519fb4541fSSam Bobroff 9527abd43baSSuraj Jitindar Singh if (!ppc_check_compat(first_ppc_cpu, CPU_POWERPC_LOGICAL_3_00, 0, 9537abd43baSSuraj Jitindar Singh first_ppc_cpu->compat_pvr)) { 9547abd43baSSuraj Jitindar Singh /* If we're in a pre POWER9 compat mode then the guest should do hash */ 9557abd43baSSuraj Jitindar Singh val[3] = 0x00; /* Hash */ 9567abd43baSSuraj Jitindar Singh } else if (kvm_enabled()) { 9579fb4541fSSam Bobroff if (kvmppc_has_cap_mmu_radix() && kvmppc_has_cap_mmu_hash_v3()) { 958f2b14e3aSCédric Le Goater val[3] = 0x80; /* OV5_MMU_BOTH */ 9599fb4541fSSam Bobroff } else if (kvmppc_has_cap_mmu_radix()) { 960f2b14e3aSCédric Le Goater val[3] = 0x40; /* OV5_MMU_RADIX_300 */ 9619fb4541fSSam Bobroff } else { 962f2b14e3aSCédric Le Goater val[3] = 0x00; /* Hash */ 9639fb4541fSSam Bobroff } 9649fb4541fSSam Bobroff } else { 9657abd43baSSuraj Jitindar Singh /* V3 MMU supports both hash and radix in tcg (with dynamic switching) */ 966f2b14e3aSCédric Le Goater val[3] = 0xC0; 967545d6e2bSSuraj Jitindar Singh } 9689fb4541fSSam Bobroff _FDT(fdt_setprop(fdt, chosen, "ibm,arch-vec-5-platform-support", 9699fb4541fSSam Bobroff val, sizeof(val))); 9709fb4541fSSam Bobroff } 9719fb4541fSSam Bobroff 9727c866c6aSDavid Gibson static void spapr_dt_chosen(sPAPRMachineState *spapr, void *fdt) 9737c866c6aSDavid Gibson { 9747c866c6aSDavid Gibson MachineState *machine = MACHINE(spapr); 9757c866c6aSDavid Gibson int chosen; 9767c866c6aSDavid Gibson const char *boot_device = machine->boot_order; 9777c866c6aSDavid Gibson char *stdout_path = spapr_vio_stdout_path(spapr->vio_bus); 9787c866c6aSDavid Gibson size_t cb = 0; 9797c866c6aSDavid Gibson char *bootlist = get_boot_devices_list(&cb, true); 9807c866c6aSDavid Gibson 9817c866c6aSDavid Gibson _FDT(chosen = fdt_add_subnode(fdt, 0, "chosen")); 9827c866c6aSDavid Gibson 9837c866c6aSDavid Gibson _FDT(fdt_setprop_string(fdt, chosen, "bootargs", machine->kernel_cmdline)); 9847c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "linux,initrd-start", 9857c866c6aSDavid Gibson spapr->initrd_base)); 9867c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "linux,initrd-end", 9877c866c6aSDavid Gibson spapr->initrd_base + spapr->initrd_size)); 9887c866c6aSDavid Gibson 9897c866c6aSDavid Gibson if (spapr->kernel_size) { 9907c866c6aSDavid Gibson uint64_t kprop[2] = { cpu_to_be64(KERNEL_LOAD_ADDR), 9917c866c6aSDavid Gibson cpu_to_be64(spapr->kernel_size) }; 9927c866c6aSDavid Gibson 9937c866c6aSDavid Gibson _FDT(fdt_setprop(fdt, chosen, "qemu,boot-kernel", 9947c866c6aSDavid Gibson &kprop, sizeof(kprop))); 9957c866c6aSDavid Gibson if (spapr->kernel_le) { 9967c866c6aSDavid Gibson _FDT(fdt_setprop(fdt, chosen, "qemu,boot-kernel-le", NULL, 0)); 9977c866c6aSDavid Gibson } 9987c866c6aSDavid Gibson } 9997c866c6aSDavid Gibson if (boot_menu) { 10007c866c6aSDavid Gibson _FDT((fdt_setprop_cell(fdt, chosen, "qemu,boot-menu", boot_menu))); 10017c866c6aSDavid Gibson } 10027c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "qemu,graphic-width", graphic_width)); 10037c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "qemu,graphic-height", graphic_height)); 10047c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "qemu,graphic-depth", graphic_depth)); 10057c866c6aSDavid Gibson 10067c866c6aSDavid Gibson if (cb && bootlist) { 10077c866c6aSDavid Gibson int i; 10087c866c6aSDavid Gibson 10097c866c6aSDavid Gibson for (i = 0; i < cb; i++) { 10107c866c6aSDavid Gibson if (bootlist[i] == '\n') { 10117c866c6aSDavid Gibson bootlist[i] = ' '; 10127c866c6aSDavid Gibson } 10137c866c6aSDavid Gibson } 10147c866c6aSDavid Gibson _FDT(fdt_setprop_string(fdt, chosen, "qemu,boot-list", bootlist)); 10157c866c6aSDavid Gibson } 10167c866c6aSDavid Gibson 10177c866c6aSDavid Gibson if (boot_device && strlen(boot_device)) { 10187c866c6aSDavid Gibson _FDT(fdt_setprop_string(fdt, chosen, "qemu,boot-device", boot_device)); 10197c866c6aSDavid Gibson } 10207c866c6aSDavid Gibson 10217c866c6aSDavid Gibson if (!spapr->has_graphics && stdout_path) { 10227c866c6aSDavid Gibson _FDT(fdt_setprop_string(fdt, chosen, "linux,stdout-path", stdout_path)); 10237c866c6aSDavid Gibson } 10247c866c6aSDavid Gibson 10259fb4541fSSam Bobroff spapr_dt_ov5_platform_support(fdt, chosen); 10269fb4541fSSam Bobroff 10277c866c6aSDavid Gibson g_free(stdout_path); 10287c866c6aSDavid Gibson g_free(bootlist); 10297c866c6aSDavid Gibson } 10307c866c6aSDavid Gibson 1031fca5f2dcSDavid Gibson static void spapr_dt_hypervisor(sPAPRMachineState *spapr, void *fdt) 1032fca5f2dcSDavid Gibson { 1033fca5f2dcSDavid Gibson /* The /hypervisor node isn't in PAPR - this is a hack to allow PR 1034fca5f2dcSDavid Gibson * KVM to work under pHyp with some guest co-operation */ 1035fca5f2dcSDavid Gibson int hypervisor; 1036fca5f2dcSDavid Gibson uint8_t hypercall[16]; 1037fca5f2dcSDavid Gibson 1038fca5f2dcSDavid Gibson _FDT(hypervisor = fdt_add_subnode(fdt, 0, "hypervisor")); 1039fca5f2dcSDavid Gibson /* indicate KVM hypercall interface */ 1040fca5f2dcSDavid Gibson _FDT(fdt_setprop_string(fdt, hypervisor, "compatible", "linux,kvm")); 1041fca5f2dcSDavid Gibson if (kvmppc_has_cap_fixup_hcalls()) { 1042fca5f2dcSDavid Gibson /* 1043fca5f2dcSDavid Gibson * Older KVM versions with older guest kernels were broken 1044fca5f2dcSDavid Gibson * with the magic page, don't allow the guest to map it. 1045fca5f2dcSDavid Gibson */ 1046fca5f2dcSDavid Gibson if (!kvmppc_get_hypercall(first_cpu->env_ptr, hypercall, 1047fca5f2dcSDavid Gibson sizeof(hypercall))) { 1048fca5f2dcSDavid Gibson _FDT(fdt_setprop(fdt, hypervisor, "hcall-instructions", 1049fca5f2dcSDavid Gibson hypercall, sizeof(hypercall))); 1050fca5f2dcSDavid Gibson } 1051fca5f2dcSDavid Gibson } 1052fca5f2dcSDavid Gibson } 1053fca5f2dcSDavid Gibson 1054997b6cfcSDavid Gibson static void *spapr_build_fdt(sPAPRMachineState *spapr, 105553018216SPaolo Bonzini hwaddr rtas_addr, 105653018216SPaolo Bonzini hwaddr rtas_size) 105753018216SPaolo Bonzini { 1058c86c1affSDaniel Henrique Barboza MachineState *machine = MACHINE(spapr); 10593c0c47e3SDavid Gibson MachineClass *mc = MACHINE_GET_CLASS(machine); 1060c20d332aSBharata B Rao sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(machine); 10617c866c6aSDavid Gibson int ret; 106253018216SPaolo Bonzini void *fdt; 106353018216SPaolo Bonzini sPAPRPHBState *phb; 1064398a0bd5SDavid Gibson char *buf; 106553018216SPaolo Bonzini 1066398a0bd5SDavid Gibson fdt = g_malloc0(FDT_MAX_SIZE); 1067398a0bd5SDavid Gibson _FDT((fdt_create_empty_tree(fdt, FDT_MAX_SIZE))); 106853018216SPaolo Bonzini 1069398a0bd5SDavid Gibson /* Root node */ 1070398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "device_type", "chrp")); 1071398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "model", "IBM pSeries (emulated by qemu)")); 1072398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "compatible", "qemu,pseries")); 1073398a0bd5SDavid Gibson 1074398a0bd5SDavid Gibson /* 1075398a0bd5SDavid Gibson * Add info to guest to indentify which host is it being run on 1076398a0bd5SDavid Gibson * and what is the uuid of the guest 1077398a0bd5SDavid Gibson */ 1078398a0bd5SDavid Gibson if (kvmppc_get_host_model(&buf)) { 1079398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "host-model", buf)); 1080398a0bd5SDavid Gibson g_free(buf); 1081398a0bd5SDavid Gibson } 1082398a0bd5SDavid Gibson if (kvmppc_get_host_serial(&buf)) { 1083398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "host-serial", buf)); 1084398a0bd5SDavid Gibson g_free(buf); 1085398a0bd5SDavid Gibson } 1086398a0bd5SDavid Gibson 1087398a0bd5SDavid Gibson buf = qemu_uuid_unparse_strdup(&qemu_uuid); 1088398a0bd5SDavid Gibson 1089398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "vm,uuid", buf)); 1090398a0bd5SDavid Gibson if (qemu_uuid_set) { 1091398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "system-id", buf)); 1092398a0bd5SDavid Gibson } 1093398a0bd5SDavid Gibson g_free(buf); 1094398a0bd5SDavid Gibson 1095398a0bd5SDavid Gibson if (qemu_get_vm_name()) { 1096398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "ibm,partition-name", 1097398a0bd5SDavid Gibson qemu_get_vm_name())); 1098398a0bd5SDavid Gibson } 1099398a0bd5SDavid Gibson 1100398a0bd5SDavid Gibson _FDT(fdt_setprop_cell(fdt, 0, "#address-cells", 2)); 1101398a0bd5SDavid Gibson _FDT(fdt_setprop_cell(fdt, 0, "#size-cells", 2)); 110253018216SPaolo Bonzini 1103fc7e0765SDavid Gibson /* /interrupt controller */ 1104fc7e0765SDavid Gibson spapr_dt_xics(xics_max_server_number(), fdt, PHANDLE_XICP); 1105fc7e0765SDavid Gibson 1106e8f986fcSBharata B Rao ret = spapr_populate_memory(spapr, fdt); 1107e8f986fcSBharata B Rao if (ret < 0) { 1108ce9863b7SCédric Le Goater error_report("couldn't setup memory nodes in fdt"); 1109e8f986fcSBharata B Rao exit(1); 111053018216SPaolo Bonzini } 111153018216SPaolo Bonzini 1112bf5a6696SDavid Gibson /* /vdevice */ 1113bf5a6696SDavid Gibson spapr_dt_vdevice(spapr->vio_bus, fdt); 111453018216SPaolo Bonzini 11154d9392beSThomas Huth if (object_resolve_path_type("", TYPE_SPAPR_RNG, NULL)) { 11164d9392beSThomas Huth ret = spapr_rng_populate_dt(fdt); 11174d9392beSThomas Huth if (ret < 0) { 1118ce9863b7SCédric Le Goater error_report("could not set up rng device in the fdt"); 11194d9392beSThomas Huth exit(1); 11204d9392beSThomas Huth } 11214d9392beSThomas Huth } 11224d9392beSThomas Huth 112353018216SPaolo Bonzini QLIST_FOREACH(phb, &spapr->phbs, list) { 112453018216SPaolo Bonzini ret = spapr_populate_pci_dt(phb, PHANDLE_XICP, fdt); 112553018216SPaolo Bonzini if (ret < 0) { 1126da34fed7SThomas Huth error_report("couldn't setup PCI devices in fdt"); 112753018216SPaolo Bonzini exit(1); 112853018216SPaolo Bonzini } 1129da34fed7SThomas Huth } 113053018216SPaolo Bonzini 11310da6f3feSBharata B Rao /* cpus */ 11320da6f3feSBharata B Rao spapr_populate_cpus_dt_node(fdt, spapr); 113353018216SPaolo Bonzini 1134c20d332aSBharata B Rao if (smc->dr_lmb_enabled) { 1135c20d332aSBharata B Rao _FDT(spapr_drc_populate_dt(fdt, 0, NULL, SPAPR_DR_CONNECTOR_TYPE_LMB)); 1136c20d332aSBharata B Rao } 1137c20d332aSBharata B Rao 1138c5514d0eSIgor Mammedov if (mc->has_hotpluggable_cpus) { 1139af81cf32SBharata B Rao int offset = fdt_path_offset(fdt, "/cpus"); 1140af81cf32SBharata B Rao ret = spapr_drc_populate_dt(fdt, offset, NULL, 1141af81cf32SBharata B Rao SPAPR_DR_CONNECTOR_TYPE_CPU); 1142af81cf32SBharata B Rao if (ret < 0) { 1143af81cf32SBharata B Rao error_report("Couldn't set up CPU DR device tree properties"); 1144af81cf32SBharata B Rao exit(1); 1145af81cf32SBharata B Rao } 1146af81cf32SBharata B Rao } 1147af81cf32SBharata B Rao 1148ffb1e275SDavid Gibson /* /event-sources */ 1149ffbb1705SMichael Roth spapr_dt_events(spapr, fdt); 1150ffb1e275SDavid Gibson 11513f5dabceSDavid Gibson /* /rtas */ 11523f5dabceSDavid Gibson spapr_dt_rtas(spapr, fdt); 11533f5dabceSDavid Gibson 11547c866c6aSDavid Gibson /* /chosen */ 11557c866c6aSDavid Gibson spapr_dt_chosen(spapr, fdt); 1156cf6e5223SDavid Gibson 1157fca5f2dcSDavid Gibson /* /hypervisor */ 1158fca5f2dcSDavid Gibson if (kvm_enabled()) { 1159fca5f2dcSDavid Gibson spapr_dt_hypervisor(spapr, fdt); 1160fca5f2dcSDavid Gibson } 1161fca5f2dcSDavid Gibson 1162cf6e5223SDavid Gibson /* Build memory reserve map */ 1163cf6e5223SDavid Gibson if (spapr->kernel_size) { 1164cf6e5223SDavid Gibson _FDT((fdt_add_mem_rsv(fdt, KERNEL_LOAD_ADDR, spapr->kernel_size))); 1165cf6e5223SDavid Gibson } 1166cf6e5223SDavid Gibson if (spapr->initrd_size) { 1167cf6e5223SDavid Gibson _FDT((fdt_add_mem_rsv(fdt, spapr->initrd_base, spapr->initrd_size))); 1168cf6e5223SDavid Gibson } 1169cf6e5223SDavid Gibson 11706787d27bSMichael Roth /* ibm,client-architecture-support updates */ 11716787d27bSMichael Roth ret = spapr_dt_cas_updates(spapr, fdt, spapr->ov5_cas); 11726787d27bSMichael Roth if (ret < 0) { 11736787d27bSMichael Roth error_report("couldn't setup CAS properties fdt"); 11746787d27bSMichael Roth exit(1); 11756787d27bSMichael Roth } 11766787d27bSMichael Roth 1177997b6cfcSDavid Gibson return fdt; 117853018216SPaolo Bonzini } 117953018216SPaolo Bonzini 118053018216SPaolo Bonzini static uint64_t translate_kernel_address(void *opaque, uint64_t addr) 118153018216SPaolo Bonzini { 118253018216SPaolo Bonzini return (addr & 0x0fffffff) + KERNEL_LOAD_ADDR; 118353018216SPaolo Bonzini } 118453018216SPaolo Bonzini 11851d1be34dSDavid Gibson static void emulate_spapr_hypercall(PPCVirtualHypervisor *vhyp, 11861d1be34dSDavid Gibson PowerPCCPU *cpu) 118753018216SPaolo Bonzini { 118853018216SPaolo Bonzini CPUPPCState *env = &cpu->env; 118953018216SPaolo Bonzini 11908d04fb55SJan Kiszka /* The TCG path should also be holding the BQL at this point */ 11918d04fb55SJan Kiszka g_assert(qemu_mutex_iothread_locked()); 11928d04fb55SJan Kiszka 119353018216SPaolo Bonzini if (msr_pr) { 119453018216SPaolo Bonzini hcall_dprintf("Hypercall made with MSR[PR]=1\n"); 119553018216SPaolo Bonzini env->gpr[3] = H_PRIVILEGE; 119653018216SPaolo Bonzini } else { 119753018216SPaolo Bonzini env->gpr[3] = spapr_hypercall(cpu, env->gpr[3], &env->gpr[4]); 119853018216SPaolo Bonzini } 119953018216SPaolo Bonzini } 120053018216SPaolo Bonzini 12019861bb3eSSuraj Jitindar Singh static uint64_t spapr_get_patbe(PPCVirtualHypervisor *vhyp) 12029861bb3eSSuraj Jitindar Singh { 12039861bb3eSSuraj Jitindar Singh sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 12049861bb3eSSuraj Jitindar Singh 12059861bb3eSSuraj Jitindar Singh return spapr->patb_entry; 12069861bb3eSSuraj Jitindar Singh } 12079861bb3eSSuraj Jitindar Singh 1208e6b8fd24SSamuel Mendoza-Jonas #define HPTE(_table, _i) (void *)(((uint64_t *)(_table)) + ((_i) * 2)) 1209e6b8fd24SSamuel Mendoza-Jonas #define HPTE_VALID(_hpte) (tswap64(*((uint64_t *)(_hpte))) & HPTE64_V_VALID) 1210e6b8fd24SSamuel Mendoza-Jonas #define HPTE_DIRTY(_hpte) (tswap64(*((uint64_t *)(_hpte))) & HPTE64_V_HPTE_DIRTY) 1211e6b8fd24SSamuel Mendoza-Jonas #define CLEAN_HPTE(_hpte) ((*(uint64_t *)(_hpte)) &= tswap64(~HPTE64_V_HPTE_DIRTY)) 1212e6b8fd24SSamuel Mendoza-Jonas #define DIRTY_HPTE(_hpte) ((*(uint64_t *)(_hpte)) |= tswap64(HPTE64_V_HPTE_DIRTY)) 1213e6b8fd24SSamuel Mendoza-Jonas 1214715c5407SDavid Gibson /* 1215715c5407SDavid Gibson * Get the fd to access the kernel htab, re-opening it if necessary 1216715c5407SDavid Gibson */ 1217715c5407SDavid Gibson static int get_htab_fd(sPAPRMachineState *spapr) 1218715c5407SDavid Gibson { 121914b0d748SGreg Kurz Error *local_err = NULL; 122014b0d748SGreg Kurz 1221715c5407SDavid Gibson if (spapr->htab_fd >= 0) { 1222715c5407SDavid Gibson return spapr->htab_fd; 1223715c5407SDavid Gibson } 1224715c5407SDavid Gibson 122514b0d748SGreg Kurz spapr->htab_fd = kvmppc_get_htab_fd(false, 0, &local_err); 1226715c5407SDavid Gibson if (spapr->htab_fd < 0) { 122714b0d748SGreg Kurz error_report_err(local_err); 1228715c5407SDavid Gibson } 1229715c5407SDavid Gibson 1230715c5407SDavid Gibson return spapr->htab_fd; 1231715c5407SDavid Gibson } 1232715c5407SDavid Gibson 1233b4db5413SSuraj Jitindar Singh void close_htab_fd(sPAPRMachineState *spapr) 1234715c5407SDavid Gibson { 1235715c5407SDavid Gibson if (spapr->htab_fd >= 0) { 1236715c5407SDavid Gibson close(spapr->htab_fd); 1237715c5407SDavid Gibson } 1238715c5407SDavid Gibson spapr->htab_fd = -1; 1239715c5407SDavid Gibson } 1240715c5407SDavid Gibson 1241e57ca75cSDavid Gibson static hwaddr spapr_hpt_mask(PPCVirtualHypervisor *vhyp) 1242e57ca75cSDavid Gibson { 1243e57ca75cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 1244e57ca75cSDavid Gibson 1245e57ca75cSDavid Gibson return HTAB_SIZE(spapr) / HASH_PTEG_SIZE_64 - 1; 1246e57ca75cSDavid Gibson } 1247e57ca75cSDavid Gibson 12481ec26c75SGreg Kurz static target_ulong spapr_encode_hpt_for_kvm_pr(PPCVirtualHypervisor *vhyp) 12491ec26c75SGreg Kurz { 12501ec26c75SGreg Kurz sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 12511ec26c75SGreg Kurz 12521ec26c75SGreg Kurz assert(kvm_enabled()); 12531ec26c75SGreg Kurz 12541ec26c75SGreg Kurz if (!spapr->htab) { 12551ec26c75SGreg Kurz return 0; 12561ec26c75SGreg Kurz } 12571ec26c75SGreg Kurz 12581ec26c75SGreg Kurz return (target_ulong)(uintptr_t)spapr->htab | (spapr->htab_shift - 18); 12591ec26c75SGreg Kurz } 12601ec26c75SGreg Kurz 1261e57ca75cSDavid Gibson static const ppc_hash_pte64_t *spapr_map_hptes(PPCVirtualHypervisor *vhyp, 1262e57ca75cSDavid Gibson hwaddr ptex, int n) 1263e57ca75cSDavid Gibson { 1264e57ca75cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 1265e57ca75cSDavid Gibson hwaddr pte_offset = ptex * HASH_PTE_SIZE_64; 1266e57ca75cSDavid Gibson 1267e57ca75cSDavid Gibson if (!spapr->htab) { 1268e57ca75cSDavid Gibson /* 1269e57ca75cSDavid Gibson * HTAB is controlled by KVM. Fetch into temporary buffer 1270e57ca75cSDavid Gibson */ 1271e57ca75cSDavid Gibson ppc_hash_pte64_t *hptes = g_malloc(n * HASH_PTE_SIZE_64); 1272e57ca75cSDavid Gibson kvmppc_read_hptes(hptes, ptex, n); 1273e57ca75cSDavid Gibson return hptes; 1274e57ca75cSDavid Gibson } 1275e57ca75cSDavid Gibson 1276e57ca75cSDavid Gibson /* 1277e57ca75cSDavid Gibson * HTAB is controlled by QEMU. Just point to the internally 1278e57ca75cSDavid Gibson * accessible PTEG. 1279e57ca75cSDavid Gibson */ 1280e57ca75cSDavid Gibson return (const ppc_hash_pte64_t *)(spapr->htab + pte_offset); 1281e57ca75cSDavid Gibson } 1282e57ca75cSDavid Gibson 1283e57ca75cSDavid Gibson static void spapr_unmap_hptes(PPCVirtualHypervisor *vhyp, 1284e57ca75cSDavid Gibson const ppc_hash_pte64_t *hptes, 1285e57ca75cSDavid Gibson hwaddr ptex, int n) 1286e57ca75cSDavid Gibson { 1287e57ca75cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 1288e57ca75cSDavid Gibson 1289e57ca75cSDavid Gibson if (!spapr->htab) { 1290e57ca75cSDavid Gibson g_free((void *)hptes); 1291e57ca75cSDavid Gibson } 1292e57ca75cSDavid Gibson 1293e57ca75cSDavid Gibson /* Nothing to do for qemu managed HPT */ 1294e57ca75cSDavid Gibson } 1295e57ca75cSDavid Gibson 1296e57ca75cSDavid Gibson static void spapr_store_hpte(PPCVirtualHypervisor *vhyp, hwaddr ptex, 1297e57ca75cSDavid Gibson uint64_t pte0, uint64_t pte1) 1298e57ca75cSDavid Gibson { 1299e57ca75cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 1300e57ca75cSDavid Gibson hwaddr offset = ptex * HASH_PTE_SIZE_64; 1301e57ca75cSDavid Gibson 1302e57ca75cSDavid Gibson if (!spapr->htab) { 1303e57ca75cSDavid Gibson kvmppc_write_hpte(ptex, pte0, pte1); 1304e57ca75cSDavid Gibson } else { 1305e57ca75cSDavid Gibson stq_p(spapr->htab + offset, pte0); 1306e57ca75cSDavid Gibson stq_p(spapr->htab + offset + HASH_PTE_SIZE_64 / 2, pte1); 1307e57ca75cSDavid Gibson } 1308e57ca75cSDavid Gibson } 1309e57ca75cSDavid Gibson 13100b0b8310SDavid Gibson int spapr_hpt_shift_for_ramsize(uint64_t ramsize) 13118dfe8e7fSDavid Gibson { 13128dfe8e7fSDavid Gibson int shift; 13138dfe8e7fSDavid Gibson 13148dfe8e7fSDavid Gibson /* We aim for a hash table of size 1/128 the size of RAM (rounded 13158dfe8e7fSDavid Gibson * up). The PAPR recommendation is actually 1/64 of RAM size, but 13168dfe8e7fSDavid Gibson * that's much more than is needed for Linux guests */ 13178dfe8e7fSDavid Gibson shift = ctz64(pow2ceil(ramsize)) - 7; 13188dfe8e7fSDavid Gibson shift = MAX(shift, 18); /* Minimum architected size */ 13198dfe8e7fSDavid Gibson shift = MIN(shift, 46); /* Maximum architected size */ 13208dfe8e7fSDavid Gibson return shift; 13218dfe8e7fSDavid Gibson } 13228dfe8e7fSDavid Gibson 132306ec79e8SBharata B Rao void spapr_free_hpt(sPAPRMachineState *spapr) 132406ec79e8SBharata B Rao { 132506ec79e8SBharata B Rao g_free(spapr->htab); 132606ec79e8SBharata B Rao spapr->htab = NULL; 132706ec79e8SBharata B Rao spapr->htab_shift = 0; 132806ec79e8SBharata B Rao close_htab_fd(spapr); 132906ec79e8SBharata B Rao } 133006ec79e8SBharata B Rao 13312772cf6bSDavid Gibson void spapr_reallocate_hpt(sPAPRMachineState *spapr, int shift, 1332c5f54f3eSDavid Gibson Error **errp) 133353018216SPaolo Bonzini { 1334c5f54f3eSDavid Gibson long rc; 133553018216SPaolo Bonzini 1336c5f54f3eSDavid Gibson /* Clean up any HPT info from a previous boot */ 133706ec79e8SBharata B Rao spapr_free_hpt(spapr); 133853018216SPaolo Bonzini 1339c5f54f3eSDavid Gibson rc = kvmppc_reset_htab(shift); 1340c5f54f3eSDavid Gibson if (rc < 0) { 1341c5f54f3eSDavid Gibson /* kernel-side HPT needed, but couldn't allocate one */ 1342c5f54f3eSDavid Gibson error_setg_errno(errp, errno, 1343c5f54f3eSDavid Gibson "Failed to allocate KVM HPT of order %d (try smaller maxmem?)", 1344c5f54f3eSDavid Gibson shift); 1345c5f54f3eSDavid Gibson /* This is almost certainly fatal, but if the caller really 1346c5f54f3eSDavid Gibson * wants to carry on with shift == 0, it's welcome to try */ 1347c5f54f3eSDavid Gibson } else if (rc > 0) { 1348c5f54f3eSDavid Gibson /* kernel-side HPT allocated */ 1349c5f54f3eSDavid Gibson if (rc != shift) { 1350c5f54f3eSDavid Gibson error_setg(errp, 1351c5f54f3eSDavid Gibson "Requested order %d HPT, but kernel allocated order %ld (try smaller maxmem?)", 1352c5f54f3eSDavid Gibson shift, rc); 13537735fedaSBharata B Rao } 13547735fedaSBharata B Rao 135553018216SPaolo Bonzini spapr->htab_shift = shift; 1356c18ad9a5SDavid Gibson spapr->htab = NULL; 1357b817772aSBharata B Rao } else { 1358c5f54f3eSDavid Gibson /* kernel-side HPT not needed, allocate in userspace instead */ 1359c5f54f3eSDavid Gibson size_t size = 1ULL << shift; 1360c5f54f3eSDavid Gibson int i; 136101a57972SSamuel Mendoza-Jonas 1362c5f54f3eSDavid Gibson spapr->htab = qemu_memalign(size, size); 1363c5f54f3eSDavid Gibson if (!spapr->htab) { 1364c5f54f3eSDavid Gibson error_setg_errno(errp, errno, 1365c5f54f3eSDavid Gibson "Could not allocate HPT of order %d", shift); 1366c5f54f3eSDavid Gibson return; 1367b817772aSBharata B Rao } 1368b817772aSBharata B Rao 1369c5f54f3eSDavid Gibson memset(spapr->htab, 0, size); 1370c5f54f3eSDavid Gibson spapr->htab_shift = shift; 1371b817772aSBharata B Rao 1372c5f54f3eSDavid Gibson for (i = 0; i < size / HASH_PTE_SIZE_64; i++) { 1373c5f54f3eSDavid Gibson DIRTY_HPTE(HPTE(spapr->htab, i)); 13747735fedaSBharata B Rao } 137553018216SPaolo Bonzini } 1376ee4d9eccSSuraj Jitindar Singh /* We're setting up a hash table, so that means we're not radix */ 1377ee4d9eccSSuraj Jitindar Singh spapr->patb_entry = 0; 137853018216SPaolo Bonzini } 137953018216SPaolo Bonzini 1380b4db5413SSuraj Jitindar Singh void spapr_setup_hpt_and_vrma(sPAPRMachineState *spapr) 1381b4db5413SSuraj Jitindar Singh { 13822772cf6bSDavid Gibson int hpt_shift; 13832772cf6bSDavid Gibson 13842772cf6bSDavid Gibson if ((spapr->resize_hpt == SPAPR_RESIZE_HPT_DISABLED) 13852772cf6bSDavid Gibson || (spapr->cas_reboot 13862772cf6bSDavid Gibson && !spapr_ovec_test(spapr->ov5_cas, OV5_HPT_RESIZE))) { 13872772cf6bSDavid Gibson hpt_shift = spapr_hpt_shift_for_ramsize(MACHINE(spapr)->maxram_size); 13882772cf6bSDavid Gibson } else { 1389768a20f3SDavid Gibson uint64_t current_ram_size; 1390768a20f3SDavid Gibson 1391768a20f3SDavid Gibson current_ram_size = MACHINE(spapr)->ram_size + get_plugged_memory_size(); 1392768a20f3SDavid Gibson hpt_shift = spapr_hpt_shift_for_ramsize(current_ram_size); 13932772cf6bSDavid Gibson } 13942772cf6bSDavid Gibson spapr_reallocate_hpt(spapr, hpt_shift, &error_fatal); 13952772cf6bSDavid Gibson 1396b4db5413SSuraj Jitindar Singh if (spapr->vrma_adjust) { 1397c86c1affSDaniel Henrique Barboza spapr->rma_size = kvmppc_rma_size(spapr_node0_size(MACHINE(spapr)), 1398b4db5413SSuraj Jitindar Singh spapr->htab_shift); 1399b4db5413SSuraj Jitindar Singh } 1400b4db5413SSuraj Jitindar Singh } 1401b4db5413SSuraj Jitindar Singh 14024f01a637SDavid Gibson static void find_unknown_sysbus_device(SysBusDevice *sbdev, void *opaque) 14039e3f9733SAlexander Graf { 14049e3f9733SAlexander Graf bool matched = false; 14059e3f9733SAlexander Graf 14069e3f9733SAlexander Graf if (object_dynamic_cast(OBJECT(sbdev), TYPE_SPAPR_PCI_HOST_BRIDGE)) { 14079e3f9733SAlexander Graf matched = true; 14089e3f9733SAlexander Graf } 14099e3f9733SAlexander Graf 14109e3f9733SAlexander Graf if (!matched) { 14119e3f9733SAlexander Graf error_report("Device %s is not supported by this machine yet.", 14129e3f9733SAlexander Graf qdev_fw_name(DEVICE(sbdev))); 14139e3f9733SAlexander Graf exit(1); 14149e3f9733SAlexander Graf } 14159e3f9733SAlexander Graf } 14169e3f9733SAlexander Graf 141782512483SGreg Kurz static int spapr_reset_drcs(Object *child, void *opaque) 141882512483SGreg Kurz { 141982512483SGreg Kurz sPAPRDRConnector *drc = 142082512483SGreg Kurz (sPAPRDRConnector *) object_dynamic_cast(child, 142182512483SGreg Kurz TYPE_SPAPR_DR_CONNECTOR); 142282512483SGreg Kurz 142382512483SGreg Kurz if (drc) { 142482512483SGreg Kurz spapr_drc_reset(drc); 142582512483SGreg Kurz } 142682512483SGreg Kurz 142782512483SGreg Kurz return 0; 142882512483SGreg Kurz } 142982512483SGreg Kurz 143053018216SPaolo Bonzini static void ppc_spapr_reset(void) 143153018216SPaolo Bonzini { 1432c5f54f3eSDavid Gibson MachineState *machine = MACHINE(qdev_get_machine()); 1433c5f54f3eSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(machine); 1434182735efSAndreas Färber PowerPCCPU *first_ppc_cpu; 1435b7d1f77aSBenjamin Herrenschmidt uint32_t rtas_limit; 1436cae172abSDavid Gibson hwaddr rtas_addr, fdt_addr; 1437997b6cfcSDavid Gibson void *fdt; 1438997b6cfcSDavid Gibson int rc; 1439259186a7SAndreas Färber 14409e3f9733SAlexander Graf /* Check for unknown sysbus devices */ 14419e3f9733SAlexander Graf foreach_dynamic_sysbus_device(find_unknown_sysbus_device, NULL); 14429e3f9733SAlexander Graf 1443b4db5413SSuraj Jitindar Singh if (kvm_enabled() && kvmppc_has_cap_mmu_radix()) { 1444b4db5413SSuraj Jitindar Singh /* If using KVM with radix mode available, VCPUs can be started 1445b4db5413SSuraj Jitindar Singh * without a HPT because KVM will start them in radix mode. 1446b4db5413SSuraj Jitindar Singh * Set the GR bit in PATB so that we know there is no HPT. */ 1447b4db5413SSuraj Jitindar Singh spapr->patb_entry = PATBE1_GR; 1448b4db5413SSuraj Jitindar Singh } else { 1449b4db5413SSuraj Jitindar Singh spapr_setup_hpt_and_vrma(spapr); 1450c5f54f3eSDavid Gibson } 145153018216SPaolo Bonzini 145253018216SPaolo Bonzini qemu_devices_reset(); 145382512483SGreg Kurz 145482512483SGreg Kurz /* DRC reset may cause a device to be unplugged. This will cause troubles 145582512483SGreg Kurz * if this device is used by another device (eg, a running vhost backend 145682512483SGreg Kurz * will crash QEMU if the DIMM holding the vring goes away). To avoid such 145782512483SGreg Kurz * situations, we reset DRCs after all devices have been reset. 145882512483SGreg Kurz */ 145982512483SGreg Kurz object_child_foreach_recursive(object_get_root(), spapr_reset_drcs, NULL); 146082512483SGreg Kurz 146156258174SDaniel Henrique Barboza spapr_clear_pending_events(spapr); 146253018216SPaolo Bonzini 1463b7d1f77aSBenjamin Herrenschmidt /* 1464b7d1f77aSBenjamin Herrenschmidt * We place the device tree and RTAS just below either the top of the RMA, 1465b7d1f77aSBenjamin Herrenschmidt * or just below 2GB, whichever is lowere, so that it can be 1466b7d1f77aSBenjamin Herrenschmidt * processed with 32-bit real mode code if necessary 1467b7d1f77aSBenjamin Herrenschmidt */ 1468b7d1f77aSBenjamin Herrenschmidt rtas_limit = MIN(spapr->rma_size, RTAS_MAX_ADDR); 1469cae172abSDavid Gibson rtas_addr = rtas_limit - RTAS_MAX_SIZE; 1470cae172abSDavid Gibson fdt_addr = rtas_addr - FDT_MAX_SIZE; 1471b7d1f77aSBenjamin Herrenschmidt 14726787d27bSMichael Roth /* if this reset wasn't generated by CAS, we should reset our 14736787d27bSMichael Roth * negotiated options and start from scratch */ 14746787d27bSMichael Roth if (!spapr->cas_reboot) { 14756787d27bSMichael Roth spapr_ovec_cleanup(spapr->ov5_cas); 14766787d27bSMichael Roth spapr->ov5_cas = spapr_ovec_new(); 147766d5c492SDavid Gibson 147866d5c492SDavid Gibson ppc_set_compat_all(spapr->max_compat_pvr, &error_fatal); 14796787d27bSMichael Roth } 14806787d27bSMichael Roth 1481cae172abSDavid Gibson fdt = spapr_build_fdt(spapr, rtas_addr, spapr->rtas_size); 148253018216SPaolo Bonzini 14832cac78c1SDavid Gibson spapr_load_rtas(spapr, fdt, rtas_addr); 1484b7d1f77aSBenjamin Herrenschmidt 1485997b6cfcSDavid Gibson rc = fdt_pack(fdt); 1486997b6cfcSDavid Gibson 1487997b6cfcSDavid Gibson /* Should only fail if we've built a corrupted tree */ 1488997b6cfcSDavid Gibson assert(rc == 0); 1489997b6cfcSDavid Gibson 1490997b6cfcSDavid Gibson if (fdt_totalsize(fdt) > FDT_MAX_SIZE) { 1491997b6cfcSDavid Gibson error_report("FDT too big ! 0x%x bytes (max is 0x%x)", 1492997b6cfcSDavid Gibson fdt_totalsize(fdt), FDT_MAX_SIZE); 1493997b6cfcSDavid Gibson exit(1); 1494997b6cfcSDavid Gibson } 1495997b6cfcSDavid Gibson 1496997b6cfcSDavid Gibson /* Load the fdt */ 1497997b6cfcSDavid Gibson qemu_fdt_dumpdtb(fdt, fdt_totalsize(fdt)); 1498cae172abSDavid Gibson cpu_physical_memory_write(fdt_addr, fdt, fdt_totalsize(fdt)); 1499997b6cfcSDavid Gibson g_free(fdt); 1500997b6cfcSDavid Gibson 150153018216SPaolo Bonzini /* Set up the entry state */ 1502182735efSAndreas Färber first_ppc_cpu = POWERPC_CPU(first_cpu); 1503cae172abSDavid Gibson first_ppc_cpu->env.gpr[3] = fdt_addr; 1504182735efSAndreas Färber first_ppc_cpu->env.gpr[5] = 0; 1505182735efSAndreas Färber first_cpu->halted = 0; 15061b718907SDavid Gibson first_ppc_cpu->env.nip = SPAPR_ENTRY_POINT; 150753018216SPaolo Bonzini 15086787d27bSMichael Roth spapr->cas_reboot = false; 150953018216SPaolo Bonzini } 151053018216SPaolo Bonzini 151128e02042SDavid Gibson static void spapr_create_nvram(sPAPRMachineState *spapr) 151253018216SPaolo Bonzini { 15132ff3de68SMarkus Armbruster DeviceState *dev = qdev_create(&spapr->vio_bus->bus, "spapr-nvram"); 15143978b863SPaolo Bonzini DriveInfo *dinfo = drive_get(IF_PFLASH, 0, 0); 151553018216SPaolo Bonzini 15163978b863SPaolo Bonzini if (dinfo) { 15176231a6daSMarkus Armbruster qdev_prop_set_drive(dev, "drive", blk_by_legacy_dinfo(dinfo), 15186231a6daSMarkus Armbruster &error_fatal); 151953018216SPaolo Bonzini } 152053018216SPaolo Bonzini 152153018216SPaolo Bonzini qdev_init_nofail(dev); 152253018216SPaolo Bonzini 152353018216SPaolo Bonzini spapr->nvram = (struct sPAPRNVRAM *)dev; 152453018216SPaolo Bonzini } 152553018216SPaolo Bonzini 152628e02042SDavid Gibson static void spapr_rtc_create(sPAPRMachineState *spapr) 152728df36a1SDavid Gibson { 1528147ff807SCédric Le Goater object_initialize(&spapr->rtc, sizeof(spapr->rtc), TYPE_SPAPR_RTC); 1529147ff807SCédric Le Goater object_property_add_child(OBJECT(spapr), "rtc", OBJECT(&spapr->rtc), 1530147ff807SCédric Le Goater &error_fatal); 1531147ff807SCédric Le Goater object_property_set_bool(OBJECT(&spapr->rtc), true, "realized", 1532147ff807SCédric Le Goater &error_fatal); 1533147ff807SCédric Le Goater object_property_add_alias(OBJECT(spapr), "rtc-time", OBJECT(&spapr->rtc), 1534147ff807SCédric Le Goater "date", &error_fatal); 153528df36a1SDavid Gibson } 153628df36a1SDavid Gibson 153753018216SPaolo Bonzini /* Returns whether we want to use VGA or not */ 153814c6a894SDavid Gibson static bool spapr_vga_init(PCIBus *pci_bus, Error **errp) 153953018216SPaolo Bonzini { 154053018216SPaolo Bonzini switch (vga_interface_type) { 154153018216SPaolo Bonzini case VGA_NONE: 15427effdaa3SMark Wu return false; 15437effdaa3SMark Wu case VGA_DEVICE: 15447effdaa3SMark Wu return true; 154553018216SPaolo Bonzini case VGA_STD: 1546b798c190SBenjamin Herrenschmidt case VGA_VIRTIO: 154753018216SPaolo Bonzini return pci_vga_init(pci_bus) != NULL; 154853018216SPaolo Bonzini default: 154914c6a894SDavid Gibson error_setg(errp, 155014c6a894SDavid Gibson "Unsupported VGA mode, only -vga std or -vga virtio is supported"); 155114c6a894SDavid Gibson return false; 155253018216SPaolo Bonzini } 155353018216SPaolo Bonzini } 155453018216SPaolo Bonzini 1555880ae7deSDavid Gibson static int spapr_post_load(void *opaque, int version_id) 1556880ae7deSDavid Gibson { 155728e02042SDavid Gibson sPAPRMachineState *spapr = (sPAPRMachineState *)opaque; 1558880ae7deSDavid Gibson int err = 0; 1559880ae7deSDavid Gibson 1560a7ff1212SCédric Le Goater if (!object_dynamic_cast(OBJECT(spapr->ics), TYPE_ICS_KVM)) { 15615bc8d26dSCédric Le Goater CPUState *cs; 15625bc8d26dSCédric Le Goater CPU_FOREACH(cs) { 15635bc8d26dSCédric Le Goater PowerPCCPU *cpu = POWERPC_CPU(cs); 15645bc8d26dSCédric Le Goater icp_resend(ICP(cpu->intc)); 1565a7ff1212SCédric Le Goater } 1566a7ff1212SCédric Le Goater } 1567a7ff1212SCédric Le Goater 1568631b22eaSStefan Weil /* In earlier versions, there was no separate qdev for the PAPR 1569880ae7deSDavid Gibson * RTC, so the RTC offset was stored directly in sPAPREnvironment. 1570880ae7deSDavid Gibson * So when migrating from those versions, poke the incoming offset 1571880ae7deSDavid Gibson * value into the RTC device */ 1572880ae7deSDavid Gibson if (version_id < 3) { 1573147ff807SCédric Le Goater err = spapr_rtc_import_offset(&spapr->rtc, spapr->rtc_offset); 1574880ae7deSDavid Gibson } 1575880ae7deSDavid Gibson 15760c86b2dfSLaurent Vivier if (kvm_enabled() && spapr->patb_entry) { 1577d39c90f5SBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(first_cpu); 1578d39c90f5SBharata B Rao bool radix = !!(spapr->patb_entry & PATBE1_GR); 1579d39c90f5SBharata B Rao bool gtse = !!(cpu->env.spr[SPR_LPCR] & LPCR_GTSE); 1580d39c90f5SBharata B Rao 1581d39c90f5SBharata B Rao err = kvmppc_configure_v3_mmu(cpu, radix, gtse, spapr->patb_entry); 1582d39c90f5SBharata B Rao if (err) { 1583d39c90f5SBharata B Rao error_report("Process table config unsupported by the host"); 1584d39c90f5SBharata B Rao return -EINVAL; 1585d39c90f5SBharata B Rao } 1586d39c90f5SBharata B Rao } 1587d39c90f5SBharata B Rao 1588880ae7deSDavid Gibson return err; 1589880ae7deSDavid Gibson } 1590880ae7deSDavid Gibson 1591880ae7deSDavid Gibson static bool version_before_3(void *opaque, int version_id) 1592880ae7deSDavid Gibson { 1593880ae7deSDavid Gibson return version_id < 3; 1594880ae7deSDavid Gibson } 1595880ae7deSDavid Gibson 1596fd38804bSDaniel Henrique Barboza static bool spapr_pending_events_needed(void *opaque) 1597fd38804bSDaniel Henrique Barboza { 1598fd38804bSDaniel Henrique Barboza sPAPRMachineState *spapr = (sPAPRMachineState *)opaque; 1599fd38804bSDaniel Henrique Barboza return !QTAILQ_EMPTY(&spapr->pending_events); 1600fd38804bSDaniel Henrique Barboza } 1601fd38804bSDaniel Henrique Barboza 1602fd38804bSDaniel Henrique Barboza static const VMStateDescription vmstate_spapr_event_entry = { 1603fd38804bSDaniel Henrique Barboza .name = "spapr_event_log_entry", 1604fd38804bSDaniel Henrique Barboza .version_id = 1, 1605fd38804bSDaniel Henrique Barboza .minimum_version_id = 1, 1606fd38804bSDaniel Henrique Barboza .fields = (VMStateField[]) { 16075341258eSDavid Gibson VMSTATE_UINT32(summary, sPAPREventLogEntry), 16085341258eSDavid Gibson VMSTATE_UINT32(extended_length, sPAPREventLogEntry), 1609fd38804bSDaniel Henrique Barboza VMSTATE_VBUFFER_ALLOC_UINT32(extended_log, sPAPREventLogEntry, 0, 16105341258eSDavid Gibson NULL, extended_length), 1611fd38804bSDaniel Henrique Barboza VMSTATE_END_OF_LIST() 1612fd38804bSDaniel Henrique Barboza }, 1613fd38804bSDaniel Henrique Barboza }; 1614fd38804bSDaniel Henrique Barboza 1615fd38804bSDaniel Henrique Barboza static const VMStateDescription vmstate_spapr_pending_events = { 1616fd38804bSDaniel Henrique Barboza .name = "spapr_pending_events", 1617fd38804bSDaniel Henrique Barboza .version_id = 1, 1618fd38804bSDaniel Henrique Barboza .minimum_version_id = 1, 1619fd38804bSDaniel Henrique Barboza .needed = spapr_pending_events_needed, 1620fd38804bSDaniel Henrique Barboza .fields = (VMStateField[]) { 1621fd38804bSDaniel Henrique Barboza VMSTATE_QTAILQ_V(pending_events, sPAPRMachineState, 1, 1622fd38804bSDaniel Henrique Barboza vmstate_spapr_event_entry, sPAPREventLogEntry, next), 1623fd38804bSDaniel Henrique Barboza VMSTATE_END_OF_LIST() 1624fd38804bSDaniel Henrique Barboza }, 1625fd38804bSDaniel Henrique Barboza }; 1626fd38804bSDaniel Henrique Barboza 162762ef3760SMichael Roth static bool spapr_ov5_cas_needed(void *opaque) 162862ef3760SMichael Roth { 162962ef3760SMichael Roth sPAPRMachineState *spapr = opaque; 163062ef3760SMichael Roth sPAPROptionVector *ov5_mask = spapr_ovec_new(); 163162ef3760SMichael Roth sPAPROptionVector *ov5_legacy = spapr_ovec_new(); 163262ef3760SMichael Roth sPAPROptionVector *ov5_removed = spapr_ovec_new(); 163362ef3760SMichael Roth bool cas_needed; 163462ef3760SMichael Roth 163562ef3760SMichael Roth /* Prior to the introduction of sPAPROptionVector, we had two option 163662ef3760SMichael Roth * vectors we dealt with: OV5_FORM1_AFFINITY, and OV5_DRCONF_MEMORY. 163762ef3760SMichael Roth * Both of these options encode machine topology into the device-tree 163862ef3760SMichael Roth * in such a way that the now-booted OS should still be able to interact 163962ef3760SMichael Roth * appropriately with QEMU regardless of what options were actually 164062ef3760SMichael Roth * negotiatied on the source side. 164162ef3760SMichael Roth * 164262ef3760SMichael Roth * As such, we can avoid migrating the CAS-negotiated options if these 164362ef3760SMichael Roth * are the only options available on the current machine/platform. 164462ef3760SMichael Roth * Since these are the only options available for pseries-2.7 and 164562ef3760SMichael Roth * earlier, this allows us to maintain old->new/new->old migration 164662ef3760SMichael Roth * compatibility. 164762ef3760SMichael Roth * 164862ef3760SMichael Roth * For QEMU 2.8+, there are additional CAS-negotiatable options available 164962ef3760SMichael Roth * via default pseries-2.8 machines and explicit command-line parameters. 165062ef3760SMichael Roth * Some of these options, like OV5_HP_EVT, *do* require QEMU to be aware 165162ef3760SMichael Roth * of the actual CAS-negotiated values to continue working properly. For 165262ef3760SMichael Roth * example, availability of memory unplug depends on knowing whether 165362ef3760SMichael Roth * OV5_HP_EVT was negotiated via CAS. 165462ef3760SMichael Roth * 165562ef3760SMichael Roth * Thus, for any cases where the set of available CAS-negotiatable 165662ef3760SMichael Roth * options extends beyond OV5_FORM1_AFFINITY and OV5_DRCONF_MEMORY, we 165762ef3760SMichael Roth * include the CAS-negotiated options in the migration stream. 165862ef3760SMichael Roth */ 165962ef3760SMichael Roth spapr_ovec_set(ov5_mask, OV5_FORM1_AFFINITY); 166062ef3760SMichael Roth spapr_ovec_set(ov5_mask, OV5_DRCONF_MEMORY); 166162ef3760SMichael Roth 166262ef3760SMichael Roth /* spapr_ovec_diff returns true if bits were removed. we avoid using 166362ef3760SMichael Roth * the mask itself since in the future it's possible "legacy" bits may be 166462ef3760SMichael Roth * removed via machine options, which could generate a false positive 166562ef3760SMichael Roth * that breaks migration. 166662ef3760SMichael Roth */ 166762ef3760SMichael Roth spapr_ovec_intersect(ov5_legacy, spapr->ov5, ov5_mask); 166862ef3760SMichael Roth cas_needed = spapr_ovec_diff(ov5_removed, spapr->ov5, ov5_legacy); 166962ef3760SMichael Roth 167062ef3760SMichael Roth spapr_ovec_cleanup(ov5_mask); 167162ef3760SMichael Roth spapr_ovec_cleanup(ov5_legacy); 167262ef3760SMichael Roth spapr_ovec_cleanup(ov5_removed); 167362ef3760SMichael Roth 167462ef3760SMichael Roth return cas_needed; 167562ef3760SMichael Roth } 167662ef3760SMichael Roth 167762ef3760SMichael Roth static const VMStateDescription vmstate_spapr_ov5_cas = { 167862ef3760SMichael Roth .name = "spapr_option_vector_ov5_cas", 167962ef3760SMichael Roth .version_id = 1, 168062ef3760SMichael Roth .minimum_version_id = 1, 168162ef3760SMichael Roth .needed = spapr_ov5_cas_needed, 168262ef3760SMichael Roth .fields = (VMStateField[]) { 168362ef3760SMichael Roth VMSTATE_STRUCT_POINTER_V(ov5_cas, sPAPRMachineState, 1, 168462ef3760SMichael Roth vmstate_spapr_ovec, sPAPROptionVector), 168562ef3760SMichael Roth VMSTATE_END_OF_LIST() 168662ef3760SMichael Roth }, 168762ef3760SMichael Roth }; 168862ef3760SMichael Roth 16899861bb3eSSuraj Jitindar Singh static bool spapr_patb_entry_needed(void *opaque) 16909861bb3eSSuraj Jitindar Singh { 16919861bb3eSSuraj Jitindar Singh sPAPRMachineState *spapr = opaque; 16929861bb3eSSuraj Jitindar Singh 16939861bb3eSSuraj Jitindar Singh return !!spapr->patb_entry; 16949861bb3eSSuraj Jitindar Singh } 16959861bb3eSSuraj Jitindar Singh 16969861bb3eSSuraj Jitindar Singh static const VMStateDescription vmstate_spapr_patb_entry = { 16979861bb3eSSuraj Jitindar Singh .name = "spapr_patb_entry", 16989861bb3eSSuraj Jitindar Singh .version_id = 1, 16999861bb3eSSuraj Jitindar Singh .minimum_version_id = 1, 17009861bb3eSSuraj Jitindar Singh .needed = spapr_patb_entry_needed, 17019861bb3eSSuraj Jitindar Singh .fields = (VMStateField[]) { 17029861bb3eSSuraj Jitindar Singh VMSTATE_UINT64(patb_entry, sPAPRMachineState), 17039861bb3eSSuraj Jitindar Singh VMSTATE_END_OF_LIST() 17049861bb3eSSuraj Jitindar Singh }, 17059861bb3eSSuraj Jitindar Singh }; 17069861bb3eSSuraj Jitindar Singh 17074be21d56SDavid Gibson static const VMStateDescription vmstate_spapr = { 17084be21d56SDavid Gibson .name = "spapr", 1709880ae7deSDavid Gibson .version_id = 3, 17104be21d56SDavid Gibson .minimum_version_id = 1, 1711880ae7deSDavid Gibson .post_load = spapr_post_load, 17124be21d56SDavid Gibson .fields = (VMStateField[]) { 1713880ae7deSDavid Gibson /* used to be @next_irq */ 1714880ae7deSDavid Gibson VMSTATE_UNUSED_BUFFER(version_before_3, 0, 4), 17154be21d56SDavid Gibson 17164be21d56SDavid Gibson /* RTC offset */ 171728e02042SDavid Gibson VMSTATE_UINT64_TEST(rtc_offset, sPAPRMachineState, version_before_3), 1718880ae7deSDavid Gibson 171928e02042SDavid Gibson VMSTATE_PPC_TIMEBASE_V(tb, sPAPRMachineState, 2), 17204be21d56SDavid Gibson VMSTATE_END_OF_LIST() 17214be21d56SDavid Gibson }, 172262ef3760SMichael Roth .subsections = (const VMStateDescription*[]) { 172362ef3760SMichael Roth &vmstate_spapr_ov5_cas, 17249861bb3eSSuraj Jitindar Singh &vmstate_spapr_patb_entry, 1725fd38804bSDaniel Henrique Barboza &vmstate_spapr_pending_events, 172662ef3760SMichael Roth NULL 172762ef3760SMichael Roth } 17284be21d56SDavid Gibson }; 17294be21d56SDavid Gibson 17304be21d56SDavid Gibson static int htab_save_setup(QEMUFile *f, void *opaque) 17314be21d56SDavid Gibson { 173228e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 17334be21d56SDavid Gibson 17344be21d56SDavid Gibson /* "Iteration" header */ 17353a384297SBharata B Rao if (!spapr->htab_shift) { 17363a384297SBharata B Rao qemu_put_be32(f, -1); 17373a384297SBharata B Rao } else { 17384be21d56SDavid Gibson qemu_put_be32(f, spapr->htab_shift); 17393a384297SBharata B Rao } 17404be21d56SDavid Gibson 1741e68cb8b4SAlexey Kardashevskiy if (spapr->htab) { 1742e68cb8b4SAlexey Kardashevskiy spapr->htab_save_index = 0; 1743e68cb8b4SAlexey Kardashevskiy spapr->htab_first_pass = true; 1744e68cb8b4SAlexey Kardashevskiy } else { 17453a384297SBharata B Rao if (spapr->htab_shift) { 1746e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 17474be21d56SDavid Gibson } 17483a384297SBharata B Rao } 17494be21d56SDavid Gibson 1750e68cb8b4SAlexey Kardashevskiy 1751e68cb8b4SAlexey Kardashevskiy return 0; 1752e68cb8b4SAlexey Kardashevskiy } 17534be21d56SDavid Gibson 1754332f7721SGreg Kurz static void htab_save_chunk(QEMUFile *f, sPAPRMachineState *spapr, 1755332f7721SGreg Kurz int chunkstart, int n_valid, int n_invalid) 1756332f7721SGreg Kurz { 1757332f7721SGreg Kurz qemu_put_be32(f, chunkstart); 1758332f7721SGreg Kurz qemu_put_be16(f, n_valid); 1759332f7721SGreg Kurz qemu_put_be16(f, n_invalid); 1760332f7721SGreg Kurz qemu_put_buffer(f, HPTE(spapr->htab, chunkstart), 1761332f7721SGreg Kurz HASH_PTE_SIZE_64 * n_valid); 1762332f7721SGreg Kurz } 1763332f7721SGreg Kurz 1764332f7721SGreg Kurz static void htab_save_end_marker(QEMUFile *f) 1765332f7721SGreg Kurz { 1766332f7721SGreg Kurz qemu_put_be32(f, 0); 1767332f7721SGreg Kurz qemu_put_be16(f, 0); 1768332f7721SGreg Kurz qemu_put_be16(f, 0); 1769332f7721SGreg Kurz } 1770332f7721SGreg Kurz 177128e02042SDavid Gibson static void htab_save_first_pass(QEMUFile *f, sPAPRMachineState *spapr, 17724be21d56SDavid Gibson int64_t max_ns) 17734be21d56SDavid Gibson { 1774378bc217SDavid Gibson bool has_timeout = max_ns != -1; 17754be21d56SDavid Gibson int htabslots = HTAB_SIZE(spapr) / HASH_PTE_SIZE_64; 17764be21d56SDavid Gibson int index = spapr->htab_save_index; 1777bc72ad67SAlex Bligh int64_t starttime = qemu_clock_get_ns(QEMU_CLOCK_REALTIME); 17784be21d56SDavid Gibson 17794be21d56SDavid Gibson assert(spapr->htab_first_pass); 17804be21d56SDavid Gibson 17814be21d56SDavid Gibson do { 17824be21d56SDavid Gibson int chunkstart; 17834be21d56SDavid Gibson 17844be21d56SDavid Gibson /* Consume invalid HPTEs */ 17854be21d56SDavid Gibson while ((index < htabslots) 17864be21d56SDavid Gibson && !HPTE_VALID(HPTE(spapr->htab, index))) { 17874be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 178824ec2863SMarc-André Lureau index++; 17894be21d56SDavid Gibson } 17904be21d56SDavid Gibson 17914be21d56SDavid Gibson /* Consume valid HPTEs */ 17924be21d56SDavid Gibson chunkstart = index; 1793338c25b6SSamuel Mendoza-Jonas while ((index < htabslots) && (index - chunkstart < USHRT_MAX) 17944be21d56SDavid Gibson && HPTE_VALID(HPTE(spapr->htab, index))) { 17954be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 179624ec2863SMarc-André Lureau index++; 17974be21d56SDavid Gibson } 17984be21d56SDavid Gibson 17994be21d56SDavid Gibson if (index > chunkstart) { 18004be21d56SDavid Gibson int n_valid = index - chunkstart; 18014be21d56SDavid Gibson 1802332f7721SGreg Kurz htab_save_chunk(f, spapr, chunkstart, n_valid, 0); 18034be21d56SDavid Gibson 1804378bc217SDavid Gibson if (has_timeout && 1805378bc217SDavid Gibson (qemu_clock_get_ns(QEMU_CLOCK_REALTIME) - starttime) > max_ns) { 18064be21d56SDavid Gibson break; 18074be21d56SDavid Gibson } 18084be21d56SDavid Gibson } 18094be21d56SDavid Gibson } while ((index < htabslots) && !qemu_file_rate_limit(f)); 18104be21d56SDavid Gibson 18114be21d56SDavid Gibson if (index >= htabslots) { 18124be21d56SDavid Gibson assert(index == htabslots); 18134be21d56SDavid Gibson index = 0; 18144be21d56SDavid Gibson spapr->htab_first_pass = false; 18154be21d56SDavid Gibson } 18164be21d56SDavid Gibson spapr->htab_save_index = index; 18174be21d56SDavid Gibson } 18184be21d56SDavid Gibson 181928e02042SDavid Gibson static int htab_save_later_pass(QEMUFile *f, sPAPRMachineState *spapr, 18204be21d56SDavid Gibson int64_t max_ns) 18214be21d56SDavid Gibson { 18224be21d56SDavid Gibson bool final = max_ns < 0; 18234be21d56SDavid Gibson int htabslots = HTAB_SIZE(spapr) / HASH_PTE_SIZE_64; 18244be21d56SDavid Gibson int examined = 0, sent = 0; 18254be21d56SDavid Gibson int index = spapr->htab_save_index; 1826bc72ad67SAlex Bligh int64_t starttime = qemu_clock_get_ns(QEMU_CLOCK_REALTIME); 18274be21d56SDavid Gibson 18284be21d56SDavid Gibson assert(!spapr->htab_first_pass); 18294be21d56SDavid Gibson 18304be21d56SDavid Gibson do { 18314be21d56SDavid Gibson int chunkstart, invalidstart; 18324be21d56SDavid Gibson 18334be21d56SDavid Gibson /* Consume non-dirty HPTEs */ 18344be21d56SDavid Gibson while ((index < htabslots) 18354be21d56SDavid Gibson && !HPTE_DIRTY(HPTE(spapr->htab, index))) { 18364be21d56SDavid Gibson index++; 18374be21d56SDavid Gibson examined++; 18384be21d56SDavid Gibson } 18394be21d56SDavid Gibson 18404be21d56SDavid Gibson chunkstart = index; 18414be21d56SDavid Gibson /* Consume valid dirty HPTEs */ 1842338c25b6SSamuel Mendoza-Jonas while ((index < htabslots) && (index - chunkstart < USHRT_MAX) 18434be21d56SDavid Gibson && HPTE_DIRTY(HPTE(spapr->htab, index)) 18444be21d56SDavid Gibson && HPTE_VALID(HPTE(spapr->htab, index))) { 18454be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 18464be21d56SDavid Gibson index++; 18474be21d56SDavid Gibson examined++; 18484be21d56SDavid Gibson } 18494be21d56SDavid Gibson 18504be21d56SDavid Gibson invalidstart = index; 18514be21d56SDavid Gibson /* Consume invalid dirty HPTEs */ 1852338c25b6SSamuel Mendoza-Jonas while ((index < htabslots) && (index - invalidstart < USHRT_MAX) 18534be21d56SDavid Gibson && HPTE_DIRTY(HPTE(spapr->htab, index)) 18544be21d56SDavid Gibson && !HPTE_VALID(HPTE(spapr->htab, index))) { 18554be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 18564be21d56SDavid Gibson index++; 18574be21d56SDavid Gibson examined++; 18584be21d56SDavid Gibson } 18594be21d56SDavid Gibson 18604be21d56SDavid Gibson if (index > chunkstart) { 18614be21d56SDavid Gibson int n_valid = invalidstart - chunkstart; 18624be21d56SDavid Gibson int n_invalid = index - invalidstart; 18634be21d56SDavid Gibson 1864332f7721SGreg Kurz htab_save_chunk(f, spapr, chunkstart, n_valid, n_invalid); 18654be21d56SDavid Gibson sent += index - chunkstart; 18664be21d56SDavid Gibson 1867bc72ad67SAlex Bligh if (!final && (qemu_clock_get_ns(QEMU_CLOCK_REALTIME) - starttime) > max_ns) { 18684be21d56SDavid Gibson break; 18694be21d56SDavid Gibson } 18704be21d56SDavid Gibson } 18714be21d56SDavid Gibson 18724be21d56SDavid Gibson if (examined >= htabslots) { 18734be21d56SDavid Gibson break; 18744be21d56SDavid Gibson } 18754be21d56SDavid Gibson 18764be21d56SDavid Gibson if (index >= htabslots) { 18774be21d56SDavid Gibson assert(index == htabslots); 18784be21d56SDavid Gibson index = 0; 18794be21d56SDavid Gibson } 18804be21d56SDavid Gibson } while ((examined < htabslots) && (!qemu_file_rate_limit(f) || final)); 18814be21d56SDavid Gibson 18824be21d56SDavid Gibson if (index >= htabslots) { 18834be21d56SDavid Gibson assert(index == htabslots); 18844be21d56SDavid Gibson index = 0; 18854be21d56SDavid Gibson } 18864be21d56SDavid Gibson 18874be21d56SDavid Gibson spapr->htab_save_index = index; 18884be21d56SDavid Gibson 1889e68cb8b4SAlexey Kardashevskiy return (examined >= htabslots) && (sent == 0) ? 1 : 0; 18904be21d56SDavid Gibson } 18914be21d56SDavid Gibson 1892e68cb8b4SAlexey Kardashevskiy #define MAX_ITERATION_NS 5000000 /* 5 ms */ 1893e68cb8b4SAlexey Kardashevskiy #define MAX_KVM_BUF_SIZE 2048 1894e68cb8b4SAlexey Kardashevskiy 18954be21d56SDavid Gibson static int htab_save_iterate(QEMUFile *f, void *opaque) 18964be21d56SDavid Gibson { 189728e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 1898715c5407SDavid Gibson int fd; 1899e68cb8b4SAlexey Kardashevskiy int rc = 0; 19004be21d56SDavid Gibson 19014be21d56SDavid Gibson /* Iteration header */ 19023a384297SBharata B Rao if (!spapr->htab_shift) { 19033a384297SBharata B Rao qemu_put_be32(f, -1); 1904e8cd4247SLaurent Vivier return 1; 19053a384297SBharata B Rao } else { 19064be21d56SDavid Gibson qemu_put_be32(f, 0); 19073a384297SBharata B Rao } 19084be21d56SDavid Gibson 1909e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1910e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 1911e68cb8b4SAlexey Kardashevskiy 1912715c5407SDavid Gibson fd = get_htab_fd(spapr); 1913715c5407SDavid Gibson if (fd < 0) { 1914715c5407SDavid Gibson return fd; 191501a57972SSamuel Mendoza-Jonas } 191601a57972SSamuel Mendoza-Jonas 1917715c5407SDavid Gibson rc = kvmppc_save_htab(f, fd, MAX_KVM_BUF_SIZE, MAX_ITERATION_NS); 1918e68cb8b4SAlexey Kardashevskiy if (rc < 0) { 1919e68cb8b4SAlexey Kardashevskiy return rc; 1920e68cb8b4SAlexey Kardashevskiy } 1921e68cb8b4SAlexey Kardashevskiy } else if (spapr->htab_first_pass) { 19224be21d56SDavid Gibson htab_save_first_pass(f, spapr, MAX_ITERATION_NS); 19234be21d56SDavid Gibson } else { 1924e68cb8b4SAlexey Kardashevskiy rc = htab_save_later_pass(f, spapr, MAX_ITERATION_NS); 19254be21d56SDavid Gibson } 19264be21d56SDavid Gibson 1927332f7721SGreg Kurz htab_save_end_marker(f); 19284be21d56SDavid Gibson 1929e68cb8b4SAlexey Kardashevskiy return rc; 19304be21d56SDavid Gibson } 19314be21d56SDavid Gibson 19324be21d56SDavid Gibson static int htab_save_complete(QEMUFile *f, void *opaque) 19334be21d56SDavid Gibson { 193428e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 1935715c5407SDavid Gibson int fd; 19364be21d56SDavid Gibson 19374be21d56SDavid Gibson /* Iteration header */ 19383a384297SBharata B Rao if (!spapr->htab_shift) { 19393a384297SBharata B Rao qemu_put_be32(f, -1); 19403a384297SBharata B Rao return 0; 19413a384297SBharata B Rao } else { 19424be21d56SDavid Gibson qemu_put_be32(f, 0); 19433a384297SBharata B Rao } 19444be21d56SDavid Gibson 1945e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1946e68cb8b4SAlexey Kardashevskiy int rc; 1947e68cb8b4SAlexey Kardashevskiy 1948e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 1949e68cb8b4SAlexey Kardashevskiy 1950715c5407SDavid Gibson fd = get_htab_fd(spapr); 1951715c5407SDavid Gibson if (fd < 0) { 1952715c5407SDavid Gibson return fd; 195301a57972SSamuel Mendoza-Jonas } 195401a57972SSamuel Mendoza-Jonas 1955715c5407SDavid Gibson rc = kvmppc_save_htab(f, fd, MAX_KVM_BUF_SIZE, -1); 1956e68cb8b4SAlexey Kardashevskiy if (rc < 0) { 1957e68cb8b4SAlexey Kardashevskiy return rc; 1958e68cb8b4SAlexey Kardashevskiy } 1959e68cb8b4SAlexey Kardashevskiy } else { 1960378bc217SDavid Gibson if (spapr->htab_first_pass) { 1961378bc217SDavid Gibson htab_save_first_pass(f, spapr, -1); 1962378bc217SDavid Gibson } 19634be21d56SDavid Gibson htab_save_later_pass(f, spapr, -1); 1964e68cb8b4SAlexey Kardashevskiy } 19654be21d56SDavid Gibson 19664be21d56SDavid Gibson /* End marker */ 1967332f7721SGreg Kurz htab_save_end_marker(f); 19684be21d56SDavid Gibson 19694be21d56SDavid Gibson return 0; 19704be21d56SDavid Gibson } 19714be21d56SDavid Gibson 19724be21d56SDavid Gibson static int htab_load(QEMUFile *f, void *opaque, int version_id) 19734be21d56SDavid Gibson { 197428e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 19754be21d56SDavid Gibson uint32_t section_hdr; 1976e68cb8b4SAlexey Kardashevskiy int fd = -1; 197714b0d748SGreg Kurz Error *local_err = NULL; 19784be21d56SDavid Gibson 19794be21d56SDavid Gibson if (version_id < 1 || version_id > 1) { 198098a5d100SDavid Gibson error_report("htab_load() bad version"); 19814be21d56SDavid Gibson return -EINVAL; 19824be21d56SDavid Gibson } 19834be21d56SDavid Gibson 19844be21d56SDavid Gibson section_hdr = qemu_get_be32(f); 19854be21d56SDavid Gibson 19863a384297SBharata B Rao if (section_hdr == -1) { 19873a384297SBharata B Rao spapr_free_hpt(spapr); 19883a384297SBharata B Rao return 0; 19893a384297SBharata B Rao } 19903a384297SBharata B Rao 19914be21d56SDavid Gibson if (section_hdr) { 1992c5f54f3eSDavid Gibson /* First section gives the htab size */ 1993c5f54f3eSDavid Gibson spapr_reallocate_hpt(spapr, section_hdr, &local_err); 1994c5f54f3eSDavid Gibson if (local_err) { 1995c5f54f3eSDavid Gibson error_report_err(local_err); 19964be21d56SDavid Gibson return -EINVAL; 19974be21d56SDavid Gibson } 19984be21d56SDavid Gibson return 0; 19994be21d56SDavid Gibson } 20004be21d56SDavid Gibson 2001e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 2002e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 2003e68cb8b4SAlexey Kardashevskiy 200414b0d748SGreg Kurz fd = kvmppc_get_htab_fd(true, 0, &local_err); 2005e68cb8b4SAlexey Kardashevskiy if (fd < 0) { 200614b0d748SGreg Kurz error_report_err(local_err); 200782be8e73SGreg Kurz return fd; 2008e68cb8b4SAlexey Kardashevskiy } 2009e68cb8b4SAlexey Kardashevskiy } 2010e68cb8b4SAlexey Kardashevskiy 20114be21d56SDavid Gibson while (true) { 20124be21d56SDavid Gibson uint32_t index; 20134be21d56SDavid Gibson uint16_t n_valid, n_invalid; 20144be21d56SDavid Gibson 20154be21d56SDavid Gibson index = qemu_get_be32(f); 20164be21d56SDavid Gibson n_valid = qemu_get_be16(f); 20174be21d56SDavid Gibson n_invalid = qemu_get_be16(f); 20184be21d56SDavid Gibson 20194be21d56SDavid Gibson if ((index == 0) && (n_valid == 0) && (n_invalid == 0)) { 20204be21d56SDavid Gibson /* End of Stream */ 20214be21d56SDavid Gibson break; 20224be21d56SDavid Gibson } 20234be21d56SDavid Gibson 2024e68cb8b4SAlexey Kardashevskiy if ((index + n_valid + n_invalid) > 20254be21d56SDavid Gibson (HTAB_SIZE(spapr) / HASH_PTE_SIZE_64)) { 20264be21d56SDavid Gibson /* Bad index in stream */ 202798a5d100SDavid Gibson error_report( 202898a5d100SDavid Gibson "htab_load() bad index %d (%hd+%hd entries) in htab stream (htab_shift=%d)", 202998a5d100SDavid Gibson index, n_valid, n_invalid, spapr->htab_shift); 20304be21d56SDavid Gibson return -EINVAL; 20314be21d56SDavid Gibson } 20324be21d56SDavid Gibson 2033e68cb8b4SAlexey Kardashevskiy if (spapr->htab) { 20344be21d56SDavid Gibson if (n_valid) { 20354be21d56SDavid Gibson qemu_get_buffer(f, HPTE(spapr->htab, index), 20364be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_valid); 20374be21d56SDavid Gibson } 20384be21d56SDavid Gibson if (n_invalid) { 20394be21d56SDavid Gibson memset(HPTE(spapr->htab, index + n_valid), 0, 20404be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_invalid); 20414be21d56SDavid Gibson } 2042e68cb8b4SAlexey Kardashevskiy } else { 2043e68cb8b4SAlexey Kardashevskiy int rc; 2044e68cb8b4SAlexey Kardashevskiy 2045e68cb8b4SAlexey Kardashevskiy assert(fd >= 0); 2046e68cb8b4SAlexey Kardashevskiy 2047e68cb8b4SAlexey Kardashevskiy rc = kvmppc_load_htab_chunk(f, fd, index, n_valid, n_invalid); 2048e68cb8b4SAlexey Kardashevskiy if (rc < 0) { 2049e68cb8b4SAlexey Kardashevskiy return rc; 2050e68cb8b4SAlexey Kardashevskiy } 2051e68cb8b4SAlexey Kardashevskiy } 2052e68cb8b4SAlexey Kardashevskiy } 2053e68cb8b4SAlexey Kardashevskiy 2054e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 2055e68cb8b4SAlexey Kardashevskiy assert(fd >= 0); 2056e68cb8b4SAlexey Kardashevskiy close(fd); 20574be21d56SDavid Gibson } 20584be21d56SDavid Gibson 20594be21d56SDavid Gibson return 0; 20604be21d56SDavid Gibson } 20614be21d56SDavid Gibson 206270f794fcSJuan Quintela static void htab_save_cleanup(void *opaque) 2063c573fc03SThomas Huth { 2064c573fc03SThomas Huth sPAPRMachineState *spapr = opaque; 2065c573fc03SThomas Huth 2066c573fc03SThomas Huth close_htab_fd(spapr); 2067c573fc03SThomas Huth } 2068c573fc03SThomas Huth 20694be21d56SDavid Gibson static SaveVMHandlers savevm_htab_handlers = { 20709907e842SJuan Quintela .save_setup = htab_save_setup, 20714be21d56SDavid Gibson .save_live_iterate = htab_save_iterate, 2072a3e06c3dSDr. David Alan Gilbert .save_live_complete_precopy = htab_save_complete, 207370f794fcSJuan Quintela .save_cleanup = htab_save_cleanup, 20744be21d56SDavid Gibson .load_state = htab_load, 20754be21d56SDavid Gibson }; 20764be21d56SDavid Gibson 20775b2128d2SAlexander Graf static void spapr_boot_set(void *opaque, const char *boot_device, 20785b2128d2SAlexander Graf Error **errp) 20795b2128d2SAlexander Graf { 2080c86c1affSDaniel Henrique Barboza MachineState *machine = MACHINE(opaque); 20815b2128d2SAlexander Graf machine->boot_order = g_strdup(boot_device); 20825b2128d2SAlexander Graf } 20835b2128d2SAlexander Graf 2084224245bfSDavid Gibson static void spapr_create_lmb_dr_connectors(sPAPRMachineState *spapr) 2085224245bfSDavid Gibson { 2086224245bfSDavid Gibson MachineState *machine = MACHINE(spapr); 2087224245bfSDavid Gibson uint64_t lmb_size = SPAPR_MEMORY_BLOCK_SIZE; 2088e8f986fcSBharata B Rao uint32_t nr_lmbs = (machine->maxram_size - machine->ram_size)/lmb_size; 2089224245bfSDavid Gibson int i; 2090224245bfSDavid Gibson 2091224245bfSDavid Gibson for (i = 0; i < nr_lmbs; i++) { 2092224245bfSDavid Gibson uint64_t addr; 2093224245bfSDavid Gibson 2094e8f986fcSBharata B Rao addr = i * lmb_size + spapr->hotplug_memory.base; 20956caf3ac6SDavid Gibson spapr_dr_connector_new(OBJECT(spapr), TYPE_SPAPR_DRC_LMB, 2096224245bfSDavid Gibson addr / lmb_size); 2097224245bfSDavid Gibson } 2098224245bfSDavid Gibson } 2099224245bfSDavid Gibson 2100224245bfSDavid Gibson /* 2101224245bfSDavid Gibson * If RAM size, maxmem size and individual node mem sizes aren't aligned 2102224245bfSDavid Gibson * to SPAPR_MEMORY_BLOCK_SIZE(256MB), then refuse to start the guest 2103224245bfSDavid Gibson * since we can't support such unaligned sizes with DRCONF_MEMORY. 2104224245bfSDavid Gibson */ 21057c150d6fSDavid Gibson static void spapr_validate_node_memory(MachineState *machine, Error **errp) 2106224245bfSDavid Gibson { 2107224245bfSDavid Gibson int i; 2108224245bfSDavid Gibson 21097c150d6fSDavid Gibson if (machine->ram_size % SPAPR_MEMORY_BLOCK_SIZE) { 21107c150d6fSDavid Gibson error_setg(errp, "Memory size 0x" RAM_ADDR_FMT 21117c150d6fSDavid Gibson " is not aligned to %llu MiB", 21127c150d6fSDavid Gibson machine->ram_size, 2113224245bfSDavid Gibson SPAPR_MEMORY_BLOCK_SIZE / M_BYTE); 21147c150d6fSDavid Gibson return; 21157c150d6fSDavid Gibson } 21167c150d6fSDavid Gibson 21177c150d6fSDavid Gibson if (machine->maxram_size % SPAPR_MEMORY_BLOCK_SIZE) { 21187c150d6fSDavid Gibson error_setg(errp, "Maximum memory size 0x" RAM_ADDR_FMT 21197c150d6fSDavid Gibson " is not aligned to %llu MiB", 21207c150d6fSDavid Gibson machine->ram_size, 21217c150d6fSDavid Gibson SPAPR_MEMORY_BLOCK_SIZE / M_BYTE); 21227c150d6fSDavid Gibson return; 2123224245bfSDavid Gibson } 2124224245bfSDavid Gibson 2125224245bfSDavid Gibson for (i = 0; i < nb_numa_nodes; i++) { 2126224245bfSDavid Gibson if (numa_info[i].node_mem % SPAPR_MEMORY_BLOCK_SIZE) { 21277c150d6fSDavid Gibson error_setg(errp, 21287c150d6fSDavid Gibson "Node %d memory size 0x%" PRIx64 21297c150d6fSDavid Gibson " is not aligned to %llu MiB", 21307c150d6fSDavid Gibson i, numa_info[i].node_mem, 2131224245bfSDavid Gibson SPAPR_MEMORY_BLOCK_SIZE / M_BYTE); 21327c150d6fSDavid Gibson return; 2133224245bfSDavid Gibson } 2134224245bfSDavid Gibson } 2135224245bfSDavid Gibson } 2136224245bfSDavid Gibson 2137535455fdSIgor Mammedov /* find cpu slot in machine->possible_cpus by core_id */ 2138535455fdSIgor Mammedov static CPUArchId *spapr_find_cpu_slot(MachineState *ms, uint32_t id, int *idx) 2139535455fdSIgor Mammedov { 2140535455fdSIgor Mammedov int index = id / smp_threads; 2141535455fdSIgor Mammedov 2142535455fdSIgor Mammedov if (index >= ms->possible_cpus->len) { 2143535455fdSIgor Mammedov return NULL; 2144535455fdSIgor Mammedov } 2145535455fdSIgor Mammedov if (idx) { 2146535455fdSIgor Mammedov *idx = index; 2147535455fdSIgor Mammedov } 2148535455fdSIgor Mammedov return &ms->possible_cpus->cpus[index]; 2149535455fdSIgor Mammedov } 2150535455fdSIgor Mammedov 21510c86d0fdSDavid Gibson static void spapr_init_cpus(sPAPRMachineState *spapr) 21520c86d0fdSDavid Gibson { 21530c86d0fdSDavid Gibson MachineState *machine = MACHINE(spapr); 21540c86d0fdSDavid Gibson MachineClass *mc = MACHINE_GET_CLASS(machine); 21552e9c10ebSIgor Mammedov const char *type = spapr_get_cpu_core_type(machine->cpu_type); 21560c86d0fdSDavid Gibson int smt = kvmppc_smt_threads(); 2157535455fdSIgor Mammedov const CPUArchIdList *possible_cpus; 2158535455fdSIgor Mammedov int boot_cores_nr = smp_cpus / smp_threads; 21590c86d0fdSDavid Gibson int i; 21600c86d0fdSDavid Gibson 21610c86d0fdSDavid Gibson if (!type) { 21620c86d0fdSDavid Gibson error_report("Unable to find sPAPR CPU Core definition"); 21630c86d0fdSDavid Gibson exit(1); 21640c86d0fdSDavid Gibson } 21650c86d0fdSDavid Gibson 2166535455fdSIgor Mammedov possible_cpus = mc->possible_cpu_arch_ids(machine); 2167c5514d0eSIgor Mammedov if (mc->has_hotpluggable_cpus) { 21680c86d0fdSDavid Gibson if (smp_cpus % smp_threads) { 21690c86d0fdSDavid Gibson error_report("smp_cpus (%u) must be multiple of threads (%u)", 21700c86d0fdSDavid Gibson smp_cpus, smp_threads); 21710c86d0fdSDavid Gibson exit(1); 21720c86d0fdSDavid Gibson } 21730c86d0fdSDavid Gibson if (max_cpus % smp_threads) { 21740c86d0fdSDavid Gibson error_report("max_cpus (%u) must be multiple of threads (%u)", 21750c86d0fdSDavid Gibson max_cpus, smp_threads); 21760c86d0fdSDavid Gibson exit(1); 21770c86d0fdSDavid Gibson } 21780c86d0fdSDavid Gibson } else { 21790c86d0fdSDavid Gibson if (max_cpus != smp_cpus) { 21800c86d0fdSDavid Gibson error_report("This machine version does not support CPU hotplug"); 21810c86d0fdSDavid Gibson exit(1); 21820c86d0fdSDavid Gibson } 2183535455fdSIgor Mammedov boot_cores_nr = possible_cpus->len; 21840c86d0fdSDavid Gibson } 21850c86d0fdSDavid Gibson 2186535455fdSIgor Mammedov for (i = 0; i < possible_cpus->len; i++) { 21870c86d0fdSDavid Gibson int core_id = i * smp_threads; 21880c86d0fdSDavid Gibson 2189c5514d0eSIgor Mammedov if (mc->has_hotpluggable_cpus) { 21902d335818SDavid Gibson spapr_dr_connector_new(OBJECT(spapr), TYPE_SPAPR_DRC_CPU, 21910c86d0fdSDavid Gibson (core_id / smp_threads) * smt); 21920c86d0fdSDavid Gibson } 21930c86d0fdSDavid Gibson 2194535455fdSIgor Mammedov if (i < boot_cores_nr) { 21950c86d0fdSDavid Gibson Object *core = object_new(type); 21960c86d0fdSDavid Gibson int nr_threads = smp_threads; 21970c86d0fdSDavid Gibson 21980c86d0fdSDavid Gibson /* Handle the partially filled core for older machine types */ 21990c86d0fdSDavid Gibson if ((i + 1) * smp_threads >= smp_cpus) { 22000c86d0fdSDavid Gibson nr_threads = smp_cpus - i * smp_threads; 22010c86d0fdSDavid Gibson } 22020c86d0fdSDavid Gibson 22030c86d0fdSDavid Gibson object_property_set_int(core, nr_threads, "nr-threads", 22040c86d0fdSDavid Gibson &error_fatal); 22050c86d0fdSDavid Gibson object_property_set_int(core, core_id, CPU_CORE_PROP_CORE_ID, 22060c86d0fdSDavid Gibson &error_fatal); 22070c86d0fdSDavid Gibson object_property_set_bool(core, true, "realized", &error_fatal); 22080c86d0fdSDavid Gibson } 22090c86d0fdSDavid Gibson } 22100c86d0fdSDavid Gibson } 22110c86d0fdSDavid Gibson 2212fa98fbfcSSam Bobroff static void spapr_set_vsmt_mode(sPAPRMachineState *spapr, Error **errp) 2213fa98fbfcSSam Bobroff { 2214fa98fbfcSSam Bobroff Error *local_err = NULL; 2215fa98fbfcSSam Bobroff bool vsmt_user = !!spapr->vsmt; 2216fa98fbfcSSam Bobroff int kvm_smt = kvmppc_smt_threads(); 2217fa98fbfcSSam Bobroff int ret; 2218fa98fbfcSSam Bobroff 2219fa98fbfcSSam Bobroff if (!kvm_enabled() && (smp_threads > 1)) { 2220fa98fbfcSSam Bobroff error_setg(&local_err, "TCG cannot support more than 1 thread/core " 2221fa98fbfcSSam Bobroff "on a pseries machine"); 2222fa98fbfcSSam Bobroff goto out; 2223fa98fbfcSSam Bobroff } 2224fa98fbfcSSam Bobroff if (!is_power_of_2(smp_threads)) { 2225fa98fbfcSSam Bobroff error_setg(&local_err, "Cannot support %d threads/core on a pseries " 2226fa98fbfcSSam Bobroff "machine because it must be a power of 2", smp_threads); 2227fa98fbfcSSam Bobroff goto out; 2228fa98fbfcSSam Bobroff } 2229fa98fbfcSSam Bobroff 2230fa98fbfcSSam Bobroff /* Detemine the VSMT mode to use: */ 2231fa98fbfcSSam Bobroff if (vsmt_user) { 2232fa98fbfcSSam Bobroff if (spapr->vsmt < smp_threads) { 2233fa98fbfcSSam Bobroff error_setg(&local_err, "Cannot support VSMT mode %d" 2234fa98fbfcSSam Bobroff " because it must be >= threads/core (%d)", 2235fa98fbfcSSam Bobroff spapr->vsmt, smp_threads); 2236fa98fbfcSSam Bobroff goto out; 2237fa98fbfcSSam Bobroff } 2238fa98fbfcSSam Bobroff /* In this case, spapr->vsmt has been set by the command line */ 2239fa98fbfcSSam Bobroff } else { 2240fa98fbfcSSam Bobroff /* Choose a VSMT mode that may be higher than necessary but is 2241fa98fbfcSSam Bobroff * likely to be compatible with hosts that don't have VSMT. */ 2242fa98fbfcSSam Bobroff spapr->vsmt = MAX(kvm_smt, smp_threads); 2243fa98fbfcSSam Bobroff } 2244fa98fbfcSSam Bobroff 2245fa98fbfcSSam Bobroff /* KVM: If necessary, set the SMT mode: */ 2246fa98fbfcSSam Bobroff if (kvm_enabled() && (spapr->vsmt != kvm_smt)) { 2247fa98fbfcSSam Bobroff ret = kvmppc_set_smt_threads(spapr->vsmt); 2248fa98fbfcSSam Bobroff if (ret) { 2249fa98fbfcSSam Bobroff error_setg(&local_err, 2250fa98fbfcSSam Bobroff "Failed to set KVM's VSMT mode to %d (errno %d)", 2251fa98fbfcSSam Bobroff spapr->vsmt, ret); 2252fa98fbfcSSam Bobroff if (!vsmt_user) { 2253fa98fbfcSSam Bobroff error_append_hint(&local_err, "On PPC, a VM with %d threads/" 2254fa98fbfcSSam Bobroff "core on a host with %d threads/core requires " 2255fa98fbfcSSam Bobroff " the use of VSMT mode %d.\n", 2256fa98fbfcSSam Bobroff smp_threads, kvm_smt, spapr->vsmt); 2257fa98fbfcSSam Bobroff } 2258fa98fbfcSSam Bobroff kvmppc_hint_smt_possible(&local_err); 2259fa98fbfcSSam Bobroff goto out; 2260fa98fbfcSSam Bobroff } 2261fa98fbfcSSam Bobroff } 2262fa98fbfcSSam Bobroff /* else TCG: nothing to do currently */ 2263fa98fbfcSSam Bobroff out: 2264fa98fbfcSSam Bobroff error_propagate(errp, local_err); 2265fa98fbfcSSam Bobroff } 2266fa98fbfcSSam Bobroff 226753018216SPaolo Bonzini /* pSeries LPAR / sPAPR hardware init */ 22683ef96221SMarcel Apfelbaum static void ppc_spapr_init(MachineState *machine) 226953018216SPaolo Bonzini { 227028e02042SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(machine); 2271224245bfSDavid Gibson sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(machine); 22723ef96221SMarcel Apfelbaum const char *kernel_filename = machine->kernel_filename; 22733ef96221SMarcel Apfelbaum const char *initrd_filename = machine->initrd_filename; 227453018216SPaolo Bonzini PCIHostState *phb; 227553018216SPaolo Bonzini int i; 227653018216SPaolo Bonzini MemoryRegion *sysmem = get_system_memory(); 227753018216SPaolo Bonzini MemoryRegion *ram = g_new(MemoryRegion, 1); 2278658fa66bSAlexey Kardashevskiy MemoryRegion *rma_region; 2279658fa66bSAlexey Kardashevskiy void *rma = NULL; 228053018216SPaolo Bonzini hwaddr rma_alloc_size; 2281c86c1affSDaniel Henrique Barboza hwaddr node0_size = spapr_node0_size(machine); 2282b7d1f77aSBenjamin Herrenschmidt long load_limit, fw_size; 228353018216SPaolo Bonzini char *filename; 228430f4b05bSDavid Gibson Error *resize_hpt_err = NULL; 228553018216SPaolo Bonzini 2286226419d6SMichael S. Tsirkin msi_nonbroken = true; 228753018216SPaolo Bonzini 228853018216SPaolo Bonzini QLIST_INIT(&spapr->phbs); 22890cffce56SDavid Gibson QTAILQ_INIT(&spapr->pending_dimm_unplugs); 229053018216SPaolo Bonzini 229130f4b05bSDavid Gibson /* Check HPT resizing availability */ 229230f4b05bSDavid Gibson kvmppc_check_papr_resize_hpt(&resize_hpt_err); 229330f4b05bSDavid Gibson if (spapr->resize_hpt == SPAPR_RESIZE_HPT_DEFAULT) { 229430f4b05bSDavid Gibson /* 229530f4b05bSDavid Gibson * If the user explicitly requested a mode we should either 229630f4b05bSDavid Gibson * supply it, or fail completely (which we do below). But if 229730f4b05bSDavid Gibson * it's not set explicitly, we reset our mode to something 229830f4b05bSDavid Gibson * that works 229930f4b05bSDavid Gibson */ 230030f4b05bSDavid Gibson if (resize_hpt_err) { 230130f4b05bSDavid Gibson spapr->resize_hpt = SPAPR_RESIZE_HPT_DISABLED; 230230f4b05bSDavid Gibson error_free(resize_hpt_err); 230330f4b05bSDavid Gibson resize_hpt_err = NULL; 230430f4b05bSDavid Gibson } else { 230530f4b05bSDavid Gibson spapr->resize_hpt = smc->resize_hpt_default; 230630f4b05bSDavid Gibson } 230730f4b05bSDavid Gibson } 230830f4b05bSDavid Gibson 230930f4b05bSDavid Gibson assert(spapr->resize_hpt != SPAPR_RESIZE_HPT_DEFAULT); 231030f4b05bSDavid Gibson 231130f4b05bSDavid Gibson if ((spapr->resize_hpt != SPAPR_RESIZE_HPT_DISABLED) && resize_hpt_err) { 231230f4b05bSDavid Gibson /* 231330f4b05bSDavid Gibson * User requested HPT resize, but this host can't supply it. Bail out 231430f4b05bSDavid Gibson */ 231530f4b05bSDavid Gibson error_report_err(resize_hpt_err); 231630f4b05bSDavid Gibson exit(1); 231730f4b05bSDavid Gibson } 231830f4b05bSDavid Gibson 231953018216SPaolo Bonzini /* Allocate RMA if necessary */ 2320658fa66bSAlexey Kardashevskiy rma_alloc_size = kvmppc_alloc_rma(&rma); 232153018216SPaolo Bonzini 232253018216SPaolo Bonzini if (rma_alloc_size == -1) { 2323730fce59SThomas Huth error_report("Unable to create RMA"); 232453018216SPaolo Bonzini exit(1); 232553018216SPaolo Bonzini } 232653018216SPaolo Bonzini 2327c4177479SAlexey Kardashevskiy if (rma_alloc_size && (rma_alloc_size < node0_size)) { 232853018216SPaolo Bonzini spapr->rma_size = rma_alloc_size; 232953018216SPaolo Bonzini } else { 2330c4177479SAlexey Kardashevskiy spapr->rma_size = node0_size; 233153018216SPaolo Bonzini 233253018216SPaolo Bonzini /* With KVM, we don't actually know whether KVM supports an 233353018216SPaolo Bonzini * unbounded RMA (PR KVM) or is limited by the hash table size 233453018216SPaolo Bonzini * (HV KVM using VRMA), so we always assume the latter 233553018216SPaolo Bonzini * 233653018216SPaolo Bonzini * In that case, we also limit the initial allocations for RTAS 233753018216SPaolo Bonzini * etc... to 256M since we have no way to know what the VRMA size 233853018216SPaolo Bonzini * is going to be as it depends on the size of the hash table 233953018216SPaolo Bonzini * isn't determined yet. 234053018216SPaolo Bonzini */ 234153018216SPaolo Bonzini if (kvm_enabled()) { 234253018216SPaolo Bonzini spapr->vrma_adjust = 1; 234353018216SPaolo Bonzini spapr->rma_size = MIN(spapr->rma_size, 0x10000000); 234453018216SPaolo Bonzini } 2345912acdf4SBenjamin Herrenschmidt 2346912acdf4SBenjamin Herrenschmidt /* Actually we don't support unbounded RMA anymore since we 2347912acdf4SBenjamin Herrenschmidt * added proper emulation of HV mode. The max we can get is 2348912acdf4SBenjamin Herrenschmidt * 16G which also happens to be what we configure for PAPR 2349912acdf4SBenjamin Herrenschmidt * mode so make sure we don't do anything bigger than that 2350912acdf4SBenjamin Herrenschmidt */ 2351912acdf4SBenjamin Herrenschmidt spapr->rma_size = MIN(spapr->rma_size, 0x400000000ull); 235253018216SPaolo Bonzini } 235353018216SPaolo Bonzini 2354c4177479SAlexey Kardashevskiy if (spapr->rma_size > node0_size) { 2355d54e4d76SDavid Gibson error_report("Numa node 0 has to span the RMA (%#08"HWADDR_PRIx")", 2356c4177479SAlexey Kardashevskiy spapr->rma_size); 2357c4177479SAlexey Kardashevskiy exit(1); 2358c4177479SAlexey Kardashevskiy } 2359c4177479SAlexey Kardashevskiy 2360b7d1f77aSBenjamin Herrenschmidt /* Setup a load limit for the ramdisk leaving room for SLOF and FDT */ 2361b7d1f77aSBenjamin Herrenschmidt load_limit = MIN(spapr->rma_size, RTAS_MAX_ADDR) - FW_OVERHEAD; 236253018216SPaolo Bonzini 23637b565160SDavid Gibson /* Set up Interrupt Controller before we create the VCPUs */ 236471cd4dacSCédric Le Goater xics_system_init(machine, XICS_IRQS_SPAPR, &error_fatal); 23657b565160SDavid Gibson 2366dc1b5eeeSGreg Kurz /* Set up containers for ibm,client-architecture-support negotiated options 2367dc1b5eeeSGreg Kurz */ 2368facdb8b6SMichael Roth spapr->ov5 = spapr_ovec_new(); 2369facdb8b6SMichael Roth spapr->ov5_cas = spapr_ovec_new(); 2370facdb8b6SMichael Roth 2371224245bfSDavid Gibson if (smc->dr_lmb_enabled) { 2372facdb8b6SMichael Roth spapr_ovec_set(spapr->ov5, OV5_DRCONF_MEMORY); 23737c150d6fSDavid Gibson spapr_validate_node_memory(machine, &error_fatal); 2374224245bfSDavid Gibson } 2375224245bfSDavid Gibson 2376417ece33SMichael Roth spapr_ovec_set(spapr->ov5, OV5_FORM1_AFFINITY); 2377545d6e2bSSuraj Jitindar Singh if (!kvm_enabled() || kvmppc_has_cap_mmu_radix()) { 2378545d6e2bSSuraj Jitindar Singh /* KVM and TCG always allow GTSE with radix... */ 23799fb4541fSSam Bobroff spapr_ovec_set(spapr->ov5, OV5_MMU_RADIX_GTSE); 23809fb4541fSSam Bobroff } 23819fb4541fSSam Bobroff /* ... but not with hash (currently). */ 2382417ece33SMichael Roth 2383ffbb1705SMichael Roth /* advertise support for dedicated HP event source to guests */ 2384ffbb1705SMichael Roth if (spapr->use_hotplug_event_source) { 2385ffbb1705SMichael Roth spapr_ovec_set(spapr->ov5, OV5_HP_EVT); 2386ffbb1705SMichael Roth } 2387ffbb1705SMichael Roth 23882772cf6bSDavid Gibson /* advertise support for HPT resizing */ 23892772cf6bSDavid Gibson if (spapr->resize_hpt != SPAPR_RESIZE_HPT_DISABLED) { 23902772cf6bSDavid Gibson spapr_ovec_set(spapr->ov5, OV5_HPT_RESIZE); 23912772cf6bSDavid Gibson } 23922772cf6bSDavid Gibson 239353018216SPaolo Bonzini /* init CPUs */ 2394fa98fbfcSSam Bobroff spapr_set_vsmt_mode(spapr, &error_fatal); 2395fa98fbfcSSam Bobroff 23960c86d0fdSDavid Gibson spapr_init_cpus(spapr); 239753018216SPaolo Bonzini 2398026bfd89SDavid Gibson if (kvm_enabled()) { 2399026bfd89SDavid Gibson /* Enable H_LOGICAL_CI_* so SLOF can talk to in-kernel devices */ 2400026bfd89SDavid Gibson kvmppc_enable_logical_ci_hcalls(); 2401ef9971ddSAlexey Kardashevskiy kvmppc_enable_set_mode_hcall(); 24025145ad4fSNathan Whitehorn 24035145ad4fSNathan Whitehorn /* H_CLEAR_MOD/_REF are mandatory in PAPR, but off by default */ 24045145ad4fSNathan Whitehorn kvmppc_enable_clear_ref_mod_hcalls(); 2405026bfd89SDavid Gibson } 2406026bfd89SDavid Gibson 240753018216SPaolo Bonzini /* allocate RAM */ 2408f92f5da1SAlexey Kardashevskiy memory_region_allocate_system_memory(ram, NULL, "ppc_spapr.ram", 2409fb164994SDavid Gibson machine->ram_size); 2410f92f5da1SAlexey Kardashevskiy memory_region_add_subregion(sysmem, 0, ram); 241153018216SPaolo Bonzini 2412658fa66bSAlexey Kardashevskiy if (rma_alloc_size && rma) { 2413658fa66bSAlexey Kardashevskiy rma_region = g_new(MemoryRegion, 1); 2414658fa66bSAlexey Kardashevskiy memory_region_init_ram_ptr(rma_region, NULL, "ppc_spapr.rma", 2415658fa66bSAlexey Kardashevskiy rma_alloc_size, rma); 2416658fa66bSAlexey Kardashevskiy vmstate_register_ram_global(rma_region); 2417658fa66bSAlexey Kardashevskiy memory_region_add_subregion(sysmem, 0, rma_region); 2418658fa66bSAlexey Kardashevskiy } 2419658fa66bSAlexey Kardashevskiy 24204a1c9cf0SBharata B Rao /* initialize hotplug memory address space */ 24214a1c9cf0SBharata B Rao if (machine->ram_size < machine->maxram_size) { 24224a1c9cf0SBharata B Rao ram_addr_t hotplug_mem_size = machine->maxram_size - machine->ram_size; 242371c9a3ddSBharata B Rao /* 242471c9a3ddSBharata B Rao * Limit the number of hotpluggable memory slots to half the number 242571c9a3ddSBharata B Rao * slots that KVM supports, leaving the other half for PCI and other 242671c9a3ddSBharata B Rao * devices. However ensure that number of slots doesn't drop below 32. 242771c9a3ddSBharata B Rao */ 242871c9a3ddSBharata B Rao int max_memslots = kvm_enabled() ? kvm_get_max_memslots() / 2 : 242971c9a3ddSBharata B Rao SPAPR_MAX_RAM_SLOTS; 24304a1c9cf0SBharata B Rao 243171c9a3ddSBharata B Rao if (max_memslots < SPAPR_MAX_RAM_SLOTS) { 243271c9a3ddSBharata B Rao max_memslots = SPAPR_MAX_RAM_SLOTS; 243371c9a3ddSBharata B Rao } 243471c9a3ddSBharata B Rao if (machine->ram_slots > max_memslots) { 2435d54e4d76SDavid Gibson error_report("Specified number of memory slots %" 2436d54e4d76SDavid Gibson PRIu64" exceeds max supported %d", 243771c9a3ddSBharata B Rao machine->ram_slots, max_memslots); 2438d54e4d76SDavid Gibson exit(1); 24394a1c9cf0SBharata B Rao } 24404a1c9cf0SBharata B Rao 24414a1c9cf0SBharata B Rao spapr->hotplug_memory.base = ROUND_UP(machine->ram_size, 24424a1c9cf0SBharata B Rao SPAPR_HOTPLUG_MEM_ALIGN); 24434a1c9cf0SBharata B Rao memory_region_init(&spapr->hotplug_memory.mr, OBJECT(spapr), 24444a1c9cf0SBharata B Rao "hotplug-memory", hotplug_mem_size); 24454a1c9cf0SBharata B Rao memory_region_add_subregion(sysmem, spapr->hotplug_memory.base, 24464a1c9cf0SBharata B Rao &spapr->hotplug_memory.mr); 24474a1c9cf0SBharata B Rao } 24484a1c9cf0SBharata B Rao 2449224245bfSDavid Gibson if (smc->dr_lmb_enabled) { 2450224245bfSDavid Gibson spapr_create_lmb_dr_connectors(spapr); 2451224245bfSDavid Gibson } 2452224245bfSDavid Gibson 245353018216SPaolo Bonzini filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, "spapr-rtas.bin"); 24544c56440dSStefan Weil if (!filename) { 2455730fce59SThomas Huth error_report("Could not find LPAR rtas '%s'", "spapr-rtas.bin"); 24564c56440dSStefan Weil exit(1); 24574c56440dSStefan Weil } 2458b7d1f77aSBenjamin Herrenschmidt spapr->rtas_size = get_image_size(filename); 24598afc22a2SZhou Jie if (spapr->rtas_size < 0) { 24608afc22a2SZhou Jie error_report("Could not get size of LPAR rtas '%s'", filename); 24618afc22a2SZhou Jie exit(1); 24628afc22a2SZhou Jie } 2463b7d1f77aSBenjamin Herrenschmidt spapr->rtas_blob = g_malloc(spapr->rtas_size); 2464b7d1f77aSBenjamin Herrenschmidt if (load_image_size(filename, spapr->rtas_blob, spapr->rtas_size) < 0) { 2465730fce59SThomas Huth error_report("Could not load LPAR rtas '%s'", filename); 246653018216SPaolo Bonzini exit(1); 246753018216SPaolo Bonzini } 246853018216SPaolo Bonzini if (spapr->rtas_size > RTAS_MAX_SIZE) { 2469730fce59SThomas Huth error_report("RTAS too big ! 0x%zx bytes (max is 0x%x)", 24702f285bddSPeter Maydell (size_t)spapr->rtas_size, RTAS_MAX_SIZE); 247153018216SPaolo Bonzini exit(1); 247253018216SPaolo Bonzini } 247353018216SPaolo Bonzini g_free(filename); 247453018216SPaolo Bonzini 2475ffbb1705SMichael Roth /* Set up RTAS event infrastructure */ 247653018216SPaolo Bonzini spapr_events_init(spapr); 247753018216SPaolo Bonzini 247812f42174SDavid Gibson /* Set up the RTC RTAS interfaces */ 247928df36a1SDavid Gibson spapr_rtc_create(spapr); 248012f42174SDavid Gibson 248153018216SPaolo Bonzini /* Set up VIO bus */ 248253018216SPaolo Bonzini spapr->vio_bus = spapr_vio_bus_init(); 248353018216SPaolo Bonzini 248453018216SPaolo Bonzini for (i = 0; i < MAX_SERIAL_PORTS; i++) { 248553018216SPaolo Bonzini if (serial_hds[i]) { 248653018216SPaolo Bonzini spapr_vty_create(spapr->vio_bus, serial_hds[i]); 248753018216SPaolo Bonzini } 248853018216SPaolo Bonzini } 248953018216SPaolo Bonzini 249053018216SPaolo Bonzini /* We always have at least the nvram device on VIO */ 249153018216SPaolo Bonzini spapr_create_nvram(spapr); 249253018216SPaolo Bonzini 249353018216SPaolo Bonzini /* Set up PCI */ 249453018216SPaolo Bonzini spapr_pci_rtas_init(); 249553018216SPaolo Bonzini 249689dfd6e1SDavid Gibson phb = spapr_create_phb(spapr, 0); 249753018216SPaolo Bonzini 249853018216SPaolo Bonzini for (i = 0; i < nb_nics; i++) { 249953018216SPaolo Bonzini NICInfo *nd = &nd_table[i]; 250053018216SPaolo Bonzini 250153018216SPaolo Bonzini if (!nd->model) { 250253018216SPaolo Bonzini nd->model = g_strdup("ibmveth"); 250353018216SPaolo Bonzini } 250453018216SPaolo Bonzini 250553018216SPaolo Bonzini if (strcmp(nd->model, "ibmveth") == 0) { 250653018216SPaolo Bonzini spapr_vlan_create(spapr->vio_bus, nd); 250753018216SPaolo Bonzini } else { 250829b358f9SDavid Gibson pci_nic_init_nofail(&nd_table[i], phb->bus, nd->model, NULL); 250953018216SPaolo Bonzini } 251053018216SPaolo Bonzini } 251153018216SPaolo Bonzini 251253018216SPaolo Bonzini for (i = 0; i <= drive_get_max_bus(IF_SCSI); i++) { 251353018216SPaolo Bonzini spapr_vscsi_create(spapr->vio_bus); 251453018216SPaolo Bonzini } 251553018216SPaolo Bonzini 251653018216SPaolo Bonzini /* Graphics */ 251714c6a894SDavid Gibson if (spapr_vga_init(phb->bus, &error_fatal)) { 251853018216SPaolo Bonzini spapr->has_graphics = true; 2519c6e76503SPaolo Bonzini machine->usb |= defaults_enabled() && !machine->usb_disabled; 252053018216SPaolo Bonzini } 252153018216SPaolo Bonzini 25224ee9ced9SMarcel Apfelbaum if (machine->usb) { 252357040d45SThomas Huth if (smc->use_ohci_by_default) { 252453018216SPaolo Bonzini pci_create_simple(phb->bus, -1, "pci-ohci"); 252557040d45SThomas Huth } else { 252657040d45SThomas Huth pci_create_simple(phb->bus, -1, "nec-usb-xhci"); 252757040d45SThomas Huth } 2528c86580b8SMarkus Armbruster 252953018216SPaolo Bonzini if (spapr->has_graphics) { 2530c86580b8SMarkus Armbruster USBBus *usb_bus = usb_bus_find(-1); 2531c86580b8SMarkus Armbruster 2532c86580b8SMarkus Armbruster usb_create_simple(usb_bus, "usb-kbd"); 2533c86580b8SMarkus Armbruster usb_create_simple(usb_bus, "usb-mouse"); 253453018216SPaolo Bonzini } 253553018216SPaolo Bonzini } 253653018216SPaolo Bonzini 253753018216SPaolo Bonzini if (spapr->rma_size < (MIN_RMA_SLOF << 20)) { 2538d54e4d76SDavid Gibson error_report( 2539d54e4d76SDavid Gibson "pSeries SLOF firmware requires >= %ldM guest RMA (Real Mode Area memory)", 2540d54e4d76SDavid Gibson MIN_RMA_SLOF); 254153018216SPaolo Bonzini exit(1); 254253018216SPaolo Bonzini } 254353018216SPaolo Bonzini 254453018216SPaolo Bonzini if (kernel_filename) { 254553018216SPaolo Bonzini uint64_t lowaddr = 0; 254653018216SPaolo Bonzini 2547a19f7fb0SDavid Gibson spapr->kernel_size = load_elf(kernel_filename, translate_kernel_address, 2548a19f7fb0SDavid Gibson NULL, NULL, &lowaddr, NULL, 1, 2549a19f7fb0SDavid Gibson PPC_ELF_MACHINE, 0, 0); 2550a19f7fb0SDavid Gibson if (spapr->kernel_size == ELF_LOAD_WRONG_ENDIAN) { 2551a19f7fb0SDavid Gibson spapr->kernel_size = load_elf(kernel_filename, 2552a19f7fb0SDavid Gibson translate_kernel_address, NULL, NULL, 2553a19f7fb0SDavid Gibson &lowaddr, NULL, 0, PPC_ELF_MACHINE, 25547ef295eaSPeter Crosthwaite 0, 0); 2555a19f7fb0SDavid Gibson spapr->kernel_le = spapr->kernel_size > 0; 255616457e7fSBenjamin Herrenschmidt } 2557a19f7fb0SDavid Gibson if (spapr->kernel_size < 0) { 2558a19f7fb0SDavid Gibson error_report("error loading %s: %s", kernel_filename, 2559a19f7fb0SDavid Gibson load_elf_strerror(spapr->kernel_size)); 256053018216SPaolo Bonzini exit(1); 256153018216SPaolo Bonzini } 256253018216SPaolo Bonzini 256353018216SPaolo Bonzini /* load initrd */ 256453018216SPaolo Bonzini if (initrd_filename) { 256553018216SPaolo Bonzini /* Try to locate the initrd in the gap between the kernel 256653018216SPaolo Bonzini * and the firmware. Add a bit of space just in case 256753018216SPaolo Bonzini */ 2568a19f7fb0SDavid Gibson spapr->initrd_base = (KERNEL_LOAD_ADDR + spapr->kernel_size 2569a19f7fb0SDavid Gibson + 0x1ffff) & ~0xffff; 2570a19f7fb0SDavid Gibson spapr->initrd_size = load_image_targphys(initrd_filename, 2571a19f7fb0SDavid Gibson spapr->initrd_base, 2572a19f7fb0SDavid Gibson load_limit 2573a19f7fb0SDavid Gibson - spapr->initrd_base); 2574a19f7fb0SDavid Gibson if (spapr->initrd_size < 0) { 2575d54e4d76SDavid Gibson error_report("could not load initial ram disk '%s'", 257653018216SPaolo Bonzini initrd_filename); 257753018216SPaolo Bonzini exit(1); 257853018216SPaolo Bonzini } 257953018216SPaolo Bonzini } 258053018216SPaolo Bonzini } 258153018216SPaolo Bonzini 25828e7ea787SAndreas Färber if (bios_name == NULL) { 25838e7ea787SAndreas Färber bios_name = FW_FILE_NAME; 25848e7ea787SAndreas Färber } 25858e7ea787SAndreas Färber filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name); 25864c56440dSStefan Weil if (!filename) { 258768fea5a0SThomas Huth error_report("Could not find LPAR firmware '%s'", bios_name); 25884c56440dSStefan Weil exit(1); 25894c56440dSStefan Weil } 259053018216SPaolo Bonzini fw_size = load_image_targphys(filename, 0, FW_MAX_SIZE); 259168fea5a0SThomas Huth if (fw_size <= 0) { 259268fea5a0SThomas Huth error_report("Could not load LPAR firmware '%s'", filename); 259353018216SPaolo Bonzini exit(1); 259453018216SPaolo Bonzini } 259553018216SPaolo Bonzini g_free(filename); 259653018216SPaolo Bonzini 259728e02042SDavid Gibson /* FIXME: Should register things through the MachineState's qdev 259828e02042SDavid Gibson * interface, this is a legacy from the sPAPREnvironment structure 259928e02042SDavid Gibson * which predated MachineState but had a similar function */ 26004be21d56SDavid Gibson vmstate_register(NULL, 0, &vmstate_spapr, spapr); 26014be21d56SDavid Gibson register_savevm_live(NULL, "spapr/htab", -1, 1, 26024be21d56SDavid Gibson &savevm_htab_handlers, spapr); 26034be21d56SDavid Gibson 26045b2128d2SAlexander Graf qemu_register_boot_set(spapr_boot_set, spapr); 260542043e4fSLaurent Vivier 260642043e4fSLaurent Vivier if (kvm_enabled()) { 26073dc410aeSAlexey Kardashevskiy /* to stop and start vmclock */ 260842043e4fSLaurent Vivier qemu_add_vm_change_state_handler(cpu_ppc_clock_vm_state_change, 260942043e4fSLaurent Vivier &spapr->tb); 26103dc410aeSAlexey Kardashevskiy 26113dc410aeSAlexey Kardashevskiy kvmppc_spapr_enable_inkernel_multitce(); 261242043e4fSLaurent Vivier } 261353018216SPaolo Bonzini } 261453018216SPaolo Bonzini 2615135a129aSAneesh Kumar K.V static int spapr_kvm_type(const char *vm_type) 2616135a129aSAneesh Kumar K.V { 2617135a129aSAneesh Kumar K.V if (!vm_type) { 2618135a129aSAneesh Kumar K.V return 0; 2619135a129aSAneesh Kumar K.V } 2620135a129aSAneesh Kumar K.V 2621135a129aSAneesh Kumar K.V if (!strcmp(vm_type, "HV")) { 2622135a129aSAneesh Kumar K.V return 1; 2623135a129aSAneesh Kumar K.V } 2624135a129aSAneesh Kumar K.V 2625135a129aSAneesh Kumar K.V if (!strcmp(vm_type, "PR")) { 2626135a129aSAneesh Kumar K.V return 2; 2627135a129aSAneesh Kumar K.V } 2628135a129aSAneesh Kumar K.V 2629135a129aSAneesh Kumar K.V error_report("Unknown kvm-type specified '%s'", vm_type); 2630135a129aSAneesh Kumar K.V exit(1); 2631135a129aSAneesh Kumar K.V } 2632135a129aSAneesh Kumar K.V 263371461b0fSAlexey Kardashevskiy /* 2634627b84f4SGonglei * Implementation of an interface to adjust firmware path 263571461b0fSAlexey Kardashevskiy * for the bootindex property handling. 263671461b0fSAlexey Kardashevskiy */ 263771461b0fSAlexey Kardashevskiy static char *spapr_get_fw_dev_path(FWPathProvider *p, BusState *bus, 263871461b0fSAlexey Kardashevskiy DeviceState *dev) 263971461b0fSAlexey Kardashevskiy { 264071461b0fSAlexey Kardashevskiy #define CAST(type, obj, name) \ 264171461b0fSAlexey Kardashevskiy ((type *)object_dynamic_cast(OBJECT(obj), (name))) 264271461b0fSAlexey Kardashevskiy SCSIDevice *d = CAST(SCSIDevice, dev, TYPE_SCSI_DEVICE); 264371461b0fSAlexey Kardashevskiy sPAPRPHBState *phb = CAST(sPAPRPHBState, dev, TYPE_SPAPR_PCI_HOST_BRIDGE); 2644c4e13492SFelipe Franciosi VHostSCSICommon *vsc = CAST(VHostSCSICommon, dev, TYPE_VHOST_SCSI_COMMON); 264571461b0fSAlexey Kardashevskiy 264671461b0fSAlexey Kardashevskiy if (d) { 264771461b0fSAlexey Kardashevskiy void *spapr = CAST(void, bus->parent, "spapr-vscsi"); 264871461b0fSAlexey Kardashevskiy VirtIOSCSI *virtio = CAST(VirtIOSCSI, bus->parent, TYPE_VIRTIO_SCSI); 264971461b0fSAlexey Kardashevskiy USBDevice *usb = CAST(USBDevice, bus->parent, TYPE_USB_DEVICE); 265071461b0fSAlexey Kardashevskiy 265171461b0fSAlexey Kardashevskiy if (spapr) { 265271461b0fSAlexey Kardashevskiy /* 265371461b0fSAlexey Kardashevskiy * Replace "channel@0/disk@0,0" with "disk@8000000000000000": 265471461b0fSAlexey Kardashevskiy * We use SRP luns of the form 8000 | (bus << 8) | (id << 5) | lun 265571461b0fSAlexey Kardashevskiy * in the top 16 bits of the 64-bit LUN 265671461b0fSAlexey Kardashevskiy */ 265771461b0fSAlexey Kardashevskiy unsigned id = 0x8000 | (d->id << 8) | d->lun; 265871461b0fSAlexey Kardashevskiy return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev), 265971461b0fSAlexey Kardashevskiy (uint64_t)id << 48); 266071461b0fSAlexey Kardashevskiy } else if (virtio) { 266171461b0fSAlexey Kardashevskiy /* 266271461b0fSAlexey Kardashevskiy * We use SRP luns of the form 01000000 | (target << 8) | lun 266371461b0fSAlexey Kardashevskiy * in the top 32 bits of the 64-bit LUN 266471461b0fSAlexey Kardashevskiy * Note: the quote above is from SLOF and it is wrong, 266571461b0fSAlexey Kardashevskiy * the actual binding is: 266671461b0fSAlexey Kardashevskiy * swap 0100 or 10 << or 20 << ( target lun-id -- srplun ) 266771461b0fSAlexey Kardashevskiy */ 266871461b0fSAlexey Kardashevskiy unsigned id = 0x1000000 | (d->id << 16) | d->lun; 2669bac658d1SThomas Huth if (d->lun >= 256) { 2670bac658d1SThomas Huth /* Use the LUN "flat space addressing method" */ 2671bac658d1SThomas Huth id |= 0x4000; 2672bac658d1SThomas Huth } 267371461b0fSAlexey Kardashevskiy return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev), 267471461b0fSAlexey Kardashevskiy (uint64_t)id << 32); 267571461b0fSAlexey Kardashevskiy } else if (usb) { 267671461b0fSAlexey Kardashevskiy /* 267771461b0fSAlexey Kardashevskiy * We use SRP luns of the form 01000000 | (usb-port << 16) | lun 267871461b0fSAlexey Kardashevskiy * in the top 32 bits of the 64-bit LUN 267971461b0fSAlexey Kardashevskiy */ 268071461b0fSAlexey Kardashevskiy unsigned usb_port = atoi(usb->port->path); 268171461b0fSAlexey Kardashevskiy unsigned id = 0x1000000 | (usb_port << 16) | d->lun; 268271461b0fSAlexey Kardashevskiy return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev), 268371461b0fSAlexey Kardashevskiy (uint64_t)id << 32); 268471461b0fSAlexey Kardashevskiy } 268571461b0fSAlexey Kardashevskiy } 268671461b0fSAlexey Kardashevskiy 2687b99260ebSThomas Huth /* 2688b99260ebSThomas Huth * SLOF probes the USB devices, and if it recognizes that the device is a 2689b99260ebSThomas Huth * storage device, it changes its name to "storage" instead of "usb-host", 2690b99260ebSThomas Huth * and additionally adds a child node for the SCSI LUN, so the correct 2691b99260ebSThomas Huth * boot path in SLOF is something like .../storage@1/disk@xxx" instead. 2692b99260ebSThomas Huth */ 2693b99260ebSThomas Huth if (strcmp("usb-host", qdev_fw_name(dev)) == 0) { 2694b99260ebSThomas Huth USBDevice *usbdev = CAST(USBDevice, dev, TYPE_USB_DEVICE); 2695b99260ebSThomas Huth if (usb_host_dev_is_scsi_storage(usbdev)) { 2696b99260ebSThomas Huth return g_strdup_printf("storage@%s/disk", usbdev->port->path); 2697b99260ebSThomas Huth } 2698b99260ebSThomas Huth } 2699b99260ebSThomas Huth 270071461b0fSAlexey Kardashevskiy if (phb) { 270171461b0fSAlexey Kardashevskiy /* Replace "pci" with "pci@800000020000000" */ 270271461b0fSAlexey Kardashevskiy return g_strdup_printf("pci@%"PRIX64, phb->buid); 270371461b0fSAlexey Kardashevskiy } 270471461b0fSAlexey Kardashevskiy 2705c4e13492SFelipe Franciosi if (vsc) { 2706c4e13492SFelipe Franciosi /* Same logic as virtio above */ 2707c4e13492SFelipe Franciosi unsigned id = 0x1000000 | (vsc->target << 16) | vsc->lun; 2708c4e13492SFelipe Franciosi return g_strdup_printf("disk@%"PRIX64, (uint64_t)id << 32); 2709c4e13492SFelipe Franciosi } 2710c4e13492SFelipe Franciosi 27114871dd4cSThomas Huth if (g_str_equal("pci-bridge", qdev_fw_name(dev))) { 27124871dd4cSThomas Huth /* SLOF uses "pci" instead of "pci-bridge" for PCI bridges */ 27134871dd4cSThomas Huth PCIDevice *pcidev = CAST(PCIDevice, dev, TYPE_PCI_DEVICE); 27144871dd4cSThomas Huth return g_strdup_printf("pci@%x", PCI_SLOT(pcidev->devfn)); 27154871dd4cSThomas Huth } 27164871dd4cSThomas Huth 271771461b0fSAlexey Kardashevskiy return NULL; 271871461b0fSAlexey Kardashevskiy } 271971461b0fSAlexey Kardashevskiy 272023825581SEduardo Habkost static char *spapr_get_kvm_type(Object *obj, Error **errp) 272123825581SEduardo Habkost { 272228e02042SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 272323825581SEduardo Habkost 272428e02042SDavid Gibson return g_strdup(spapr->kvm_type); 272523825581SEduardo Habkost } 272623825581SEduardo Habkost 272723825581SEduardo Habkost static void spapr_set_kvm_type(Object *obj, const char *value, Error **errp) 272823825581SEduardo Habkost { 272928e02042SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 273023825581SEduardo Habkost 273128e02042SDavid Gibson g_free(spapr->kvm_type); 273228e02042SDavid Gibson spapr->kvm_type = g_strdup(value); 273323825581SEduardo Habkost } 273423825581SEduardo Habkost 2735f6229214SMichael Roth static bool spapr_get_modern_hotplug_events(Object *obj, Error **errp) 2736f6229214SMichael Roth { 2737f6229214SMichael Roth sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 2738f6229214SMichael Roth 2739f6229214SMichael Roth return spapr->use_hotplug_event_source; 2740f6229214SMichael Roth } 2741f6229214SMichael Roth 2742f6229214SMichael Roth static void spapr_set_modern_hotplug_events(Object *obj, bool value, 2743f6229214SMichael Roth Error **errp) 2744f6229214SMichael Roth { 2745f6229214SMichael Roth sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 2746f6229214SMichael Roth 2747f6229214SMichael Roth spapr->use_hotplug_event_source = value; 2748f6229214SMichael Roth } 2749f6229214SMichael Roth 275030f4b05bSDavid Gibson static char *spapr_get_resize_hpt(Object *obj, Error **errp) 275130f4b05bSDavid Gibson { 275230f4b05bSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 275330f4b05bSDavid Gibson 275430f4b05bSDavid Gibson switch (spapr->resize_hpt) { 275530f4b05bSDavid Gibson case SPAPR_RESIZE_HPT_DEFAULT: 275630f4b05bSDavid Gibson return g_strdup("default"); 275730f4b05bSDavid Gibson case SPAPR_RESIZE_HPT_DISABLED: 275830f4b05bSDavid Gibson return g_strdup("disabled"); 275930f4b05bSDavid Gibson case SPAPR_RESIZE_HPT_ENABLED: 276030f4b05bSDavid Gibson return g_strdup("enabled"); 276130f4b05bSDavid Gibson case SPAPR_RESIZE_HPT_REQUIRED: 276230f4b05bSDavid Gibson return g_strdup("required"); 276330f4b05bSDavid Gibson } 276430f4b05bSDavid Gibson g_assert_not_reached(); 276530f4b05bSDavid Gibson } 276630f4b05bSDavid Gibson 276730f4b05bSDavid Gibson static void spapr_set_resize_hpt(Object *obj, const char *value, Error **errp) 276830f4b05bSDavid Gibson { 276930f4b05bSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 277030f4b05bSDavid Gibson 277130f4b05bSDavid Gibson if (strcmp(value, "default") == 0) { 277230f4b05bSDavid Gibson spapr->resize_hpt = SPAPR_RESIZE_HPT_DEFAULT; 277330f4b05bSDavid Gibson } else if (strcmp(value, "disabled") == 0) { 277430f4b05bSDavid Gibson spapr->resize_hpt = SPAPR_RESIZE_HPT_DISABLED; 277530f4b05bSDavid Gibson } else if (strcmp(value, "enabled") == 0) { 277630f4b05bSDavid Gibson spapr->resize_hpt = SPAPR_RESIZE_HPT_ENABLED; 277730f4b05bSDavid Gibson } else if (strcmp(value, "required") == 0) { 277830f4b05bSDavid Gibson spapr->resize_hpt = SPAPR_RESIZE_HPT_REQUIRED; 277930f4b05bSDavid Gibson } else { 278030f4b05bSDavid Gibson error_setg(errp, "Bad value for \"resize-hpt\" property"); 278130f4b05bSDavid Gibson } 278230f4b05bSDavid Gibson } 278330f4b05bSDavid Gibson 2784fa98fbfcSSam Bobroff static void spapr_get_vsmt(Object *obj, Visitor *v, const char *name, 2785fa98fbfcSSam Bobroff void *opaque, Error **errp) 2786fa98fbfcSSam Bobroff { 2787fa98fbfcSSam Bobroff visit_type_uint32(v, name, (uint32_t *)opaque, errp); 2788fa98fbfcSSam Bobroff } 2789fa98fbfcSSam Bobroff 2790fa98fbfcSSam Bobroff static void spapr_set_vsmt(Object *obj, Visitor *v, const char *name, 2791fa98fbfcSSam Bobroff void *opaque, Error **errp) 2792fa98fbfcSSam Bobroff { 2793fa98fbfcSSam Bobroff visit_type_uint32(v, name, (uint32_t *)opaque, errp); 2794fa98fbfcSSam Bobroff } 2795fa98fbfcSSam Bobroff 279623825581SEduardo Habkost static void spapr_machine_initfn(Object *obj) 279723825581SEduardo Habkost { 2798715c5407SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 2799715c5407SDavid Gibson 2800715c5407SDavid Gibson spapr->htab_fd = -1; 2801f6229214SMichael Roth spapr->use_hotplug_event_source = true; 280223825581SEduardo Habkost object_property_add_str(obj, "kvm-type", 280323825581SEduardo Habkost spapr_get_kvm_type, spapr_set_kvm_type, NULL); 280449d2e648SMarcel Apfelbaum object_property_set_description(obj, "kvm-type", 280549d2e648SMarcel Apfelbaum "Specifies the KVM virtualization mode (HV, PR)", 280649d2e648SMarcel Apfelbaum NULL); 2807f6229214SMichael Roth object_property_add_bool(obj, "modern-hotplug-events", 2808f6229214SMichael Roth spapr_get_modern_hotplug_events, 2809f6229214SMichael Roth spapr_set_modern_hotplug_events, 2810f6229214SMichael Roth NULL); 2811f6229214SMichael Roth object_property_set_description(obj, "modern-hotplug-events", 2812f6229214SMichael Roth "Use dedicated hotplug event mechanism in" 2813f6229214SMichael Roth " place of standard EPOW events when possible" 2814f6229214SMichael Roth " (required for memory hot-unplug support)", 2815f6229214SMichael Roth NULL); 28167843c0d6SDavid Gibson 28177843c0d6SDavid Gibson ppc_compat_add_property(obj, "max-cpu-compat", &spapr->max_compat_pvr, 28187843c0d6SDavid Gibson "Maximum permitted CPU compatibility mode", 28197843c0d6SDavid Gibson &error_fatal); 282030f4b05bSDavid Gibson 282130f4b05bSDavid Gibson object_property_add_str(obj, "resize-hpt", 282230f4b05bSDavid Gibson spapr_get_resize_hpt, spapr_set_resize_hpt, NULL); 282330f4b05bSDavid Gibson object_property_set_description(obj, "resize-hpt", 282430f4b05bSDavid Gibson "Resizing of the Hash Page Table (enabled, disabled, required)", 282530f4b05bSDavid Gibson NULL); 2826fa98fbfcSSam Bobroff object_property_add(obj, "vsmt", "uint32", spapr_get_vsmt, 2827fa98fbfcSSam Bobroff spapr_set_vsmt, NULL, &spapr->vsmt, &error_abort); 2828fa98fbfcSSam Bobroff object_property_set_description(obj, "vsmt", 2829fa98fbfcSSam Bobroff "Virtual SMT: KVM behaves as if this were" 2830fa98fbfcSSam Bobroff " the host's SMT mode", &error_abort); 283123825581SEduardo Habkost } 283223825581SEduardo Habkost 283387bbdd9cSDavid Gibson static void spapr_machine_finalizefn(Object *obj) 283487bbdd9cSDavid Gibson { 283587bbdd9cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 283687bbdd9cSDavid Gibson 283787bbdd9cSDavid Gibson g_free(spapr->kvm_type); 283887bbdd9cSDavid Gibson } 283987bbdd9cSDavid Gibson 28401c7ad77eSNicholas Piggin void spapr_do_system_reset_on_cpu(CPUState *cs, run_on_cpu_data arg) 284134316482SAlexey Kardashevskiy { 284234316482SAlexey Kardashevskiy cpu_synchronize_state(cs); 284334316482SAlexey Kardashevskiy ppc_cpu_do_system_reset(cs); 284434316482SAlexey Kardashevskiy } 284534316482SAlexey Kardashevskiy 284634316482SAlexey Kardashevskiy static void spapr_nmi(NMIState *n, int cpu_index, Error **errp) 284734316482SAlexey Kardashevskiy { 284834316482SAlexey Kardashevskiy CPUState *cs; 284934316482SAlexey Kardashevskiy 285034316482SAlexey Kardashevskiy CPU_FOREACH(cs) { 28511c7ad77eSNicholas Piggin async_run_on_cpu(cs, spapr_do_system_reset_on_cpu, RUN_ON_CPU_NULL); 285234316482SAlexey Kardashevskiy } 285334316482SAlexey Kardashevskiy } 285434316482SAlexey Kardashevskiy 285579b78a6bSMichael Roth static void spapr_add_lmbs(DeviceState *dev, uint64_t addr_start, uint64_t size, 285679b78a6bSMichael Roth uint32_t node, bool dedicated_hp_event_source, 285779b78a6bSMichael Roth Error **errp) 2858c20d332aSBharata B Rao { 2859c20d332aSBharata B Rao sPAPRDRConnector *drc; 2860c20d332aSBharata B Rao uint32_t nr_lmbs = size/SPAPR_MEMORY_BLOCK_SIZE; 2861c20d332aSBharata B Rao int i, fdt_offset, fdt_size; 2862c20d332aSBharata B Rao void *fdt; 286379b78a6bSMichael Roth uint64_t addr = addr_start; 286494fd9cbaSLaurent Vivier bool hotplugged = spapr_drc_hotplugged(dev); 2865160bb678SGreg Kurz Error *local_err = NULL; 2866c20d332aSBharata B Rao 2867c20d332aSBharata B Rao for (i = 0; i < nr_lmbs; i++) { 2868fbf55397SDavid Gibson drc = spapr_drc_by_id(TYPE_SPAPR_DRC_LMB, 2869c20d332aSBharata B Rao addr / SPAPR_MEMORY_BLOCK_SIZE); 2870c20d332aSBharata B Rao g_assert(drc); 2871c20d332aSBharata B Rao 2872c20d332aSBharata B Rao fdt = create_device_tree(&fdt_size); 2873c20d332aSBharata B Rao fdt_offset = spapr_populate_memory_node(fdt, node, addr, 2874c20d332aSBharata B Rao SPAPR_MEMORY_BLOCK_SIZE); 2875c20d332aSBharata B Rao 2876160bb678SGreg Kurz spapr_drc_attach(drc, dev, fdt, fdt_offset, &local_err); 2877160bb678SGreg Kurz if (local_err) { 2878160bb678SGreg Kurz while (addr > addr_start) { 2879160bb678SGreg Kurz addr -= SPAPR_MEMORY_BLOCK_SIZE; 2880160bb678SGreg Kurz drc = spapr_drc_by_id(TYPE_SPAPR_DRC_LMB, 2881160bb678SGreg Kurz addr / SPAPR_MEMORY_BLOCK_SIZE); 2882a8dc47fdSDavid Gibson spapr_drc_detach(drc); 2883160bb678SGreg Kurz } 2884160bb678SGreg Kurz g_free(fdt); 2885160bb678SGreg Kurz error_propagate(errp, local_err); 2886160bb678SGreg Kurz return; 2887160bb678SGreg Kurz } 288894fd9cbaSLaurent Vivier if (!hotplugged) { 288994fd9cbaSLaurent Vivier spapr_drc_reset(drc); 289094fd9cbaSLaurent Vivier } 2891c20d332aSBharata B Rao addr += SPAPR_MEMORY_BLOCK_SIZE; 2892c20d332aSBharata B Rao } 28935dd5238cSJianjun Duan /* send hotplug notification to the 28945dd5238cSJianjun Duan * guest only in case of hotplugged memory 28955dd5238cSJianjun Duan */ 289694fd9cbaSLaurent Vivier if (hotplugged) { 289779b78a6bSMichael Roth if (dedicated_hp_event_source) { 2898fbf55397SDavid Gibson drc = spapr_drc_by_id(TYPE_SPAPR_DRC_LMB, 289979b78a6bSMichael Roth addr_start / SPAPR_MEMORY_BLOCK_SIZE); 290079b78a6bSMichael Roth spapr_hotplug_req_add_by_count_indexed(SPAPR_DR_CONNECTOR_TYPE_LMB, 290179b78a6bSMichael Roth nr_lmbs, 29020b55aa91SDavid Gibson spapr_drc_index(drc)); 290379b78a6bSMichael Roth } else { 290479b78a6bSMichael Roth spapr_hotplug_req_add_by_count(SPAPR_DR_CONNECTOR_TYPE_LMB, 290579b78a6bSMichael Roth nr_lmbs); 290679b78a6bSMichael Roth } 2907c20d332aSBharata B Rao } 29085dd5238cSJianjun Duan } 2909c20d332aSBharata B Rao 2910c20d332aSBharata B Rao static void spapr_memory_plug(HotplugHandler *hotplug_dev, DeviceState *dev, 2911c20d332aSBharata B Rao uint32_t node, Error **errp) 2912c20d332aSBharata B Rao { 2913c20d332aSBharata B Rao Error *local_err = NULL; 2914c20d332aSBharata B Rao sPAPRMachineState *ms = SPAPR_MACHINE(hotplug_dev); 2915c20d332aSBharata B Rao PCDIMMDevice *dimm = PC_DIMM(dev); 2916c20d332aSBharata B Rao PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); 291704790978SThomas Huth MemoryRegion *mr; 291804790978SThomas Huth uint64_t align, size, addr; 291904790978SThomas Huth 292004790978SThomas Huth mr = ddc->get_memory_region(dimm, &local_err); 292104790978SThomas Huth if (local_err) { 292204790978SThomas Huth goto out; 292304790978SThomas Huth } 292404790978SThomas Huth align = memory_region_get_alignment(mr); 292504790978SThomas Huth size = memory_region_size(mr); 2926df587133SThomas Huth 2927d6a9b0b8SMichael S. Tsirkin pc_dimm_memory_plug(dev, &ms->hotplug_memory, mr, align, &local_err); 2928c20d332aSBharata B Rao if (local_err) { 2929c20d332aSBharata B Rao goto out; 2930c20d332aSBharata B Rao } 2931c20d332aSBharata B Rao 29329ed442b8SMarc-André Lureau addr = object_property_get_uint(OBJECT(dimm), 29339ed442b8SMarc-André Lureau PC_DIMM_ADDR_PROP, &local_err); 2934c20d332aSBharata B Rao if (local_err) { 2935160bb678SGreg Kurz goto out_unplug; 2936c20d332aSBharata B Rao } 2937c20d332aSBharata B Rao 293879b78a6bSMichael Roth spapr_add_lmbs(dev, addr, size, node, 293979b78a6bSMichael Roth spapr_ovec_test(ms->ov5_cas, OV5_HP_EVT), 2940160bb678SGreg Kurz &local_err); 2941160bb678SGreg Kurz if (local_err) { 2942160bb678SGreg Kurz goto out_unplug; 2943160bb678SGreg Kurz } 2944c20d332aSBharata B Rao 2945160bb678SGreg Kurz return; 2946160bb678SGreg Kurz 2947160bb678SGreg Kurz out_unplug: 2948160bb678SGreg Kurz pc_dimm_memory_unplug(dev, &ms->hotplug_memory, mr); 2949c20d332aSBharata B Rao out: 2950c20d332aSBharata B Rao error_propagate(errp, local_err); 2951c20d332aSBharata B Rao } 2952c20d332aSBharata B Rao 2953c871bc70SLaurent Vivier static void spapr_memory_pre_plug(HotplugHandler *hotplug_dev, DeviceState *dev, 2954c871bc70SLaurent Vivier Error **errp) 2955c871bc70SLaurent Vivier { 2956c871bc70SLaurent Vivier PCDIMMDevice *dimm = PC_DIMM(dev); 2957c871bc70SLaurent Vivier PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); 295804790978SThomas Huth MemoryRegion *mr; 295904790978SThomas Huth uint64_t size; 2960c871bc70SLaurent Vivier char *mem_dev; 2961c871bc70SLaurent Vivier 296204790978SThomas Huth mr = ddc->get_memory_region(dimm, errp); 296304790978SThomas Huth if (!mr) { 296404790978SThomas Huth return; 296504790978SThomas Huth } 296604790978SThomas Huth size = memory_region_size(mr); 296704790978SThomas Huth 2968c871bc70SLaurent Vivier if (size % SPAPR_MEMORY_BLOCK_SIZE) { 2969c871bc70SLaurent Vivier error_setg(errp, "Hotplugged memory size must be a multiple of " 2970c871bc70SLaurent Vivier "%lld MB", SPAPR_MEMORY_BLOCK_SIZE / M_BYTE); 2971c871bc70SLaurent Vivier return; 2972c871bc70SLaurent Vivier } 2973c871bc70SLaurent Vivier 2974c871bc70SLaurent Vivier mem_dev = object_property_get_str(OBJECT(dimm), PC_DIMM_MEMDEV_PROP, NULL); 2975c871bc70SLaurent Vivier if (mem_dev && !kvmppc_is_mem_backend_page_size_ok(mem_dev)) { 2976c871bc70SLaurent Vivier error_setg(errp, "Memory backend has bad page size. " 2977c871bc70SLaurent Vivier "Use 'memory-backend-file' with correct mem-path."); 29788a9e0e7bSGreg Kurz goto out; 2979c871bc70SLaurent Vivier } 29808a9e0e7bSGreg Kurz 29818a9e0e7bSGreg Kurz out: 29828a9e0e7bSGreg Kurz g_free(mem_dev); 2983c871bc70SLaurent Vivier } 2984c871bc70SLaurent Vivier 29850cffce56SDavid Gibson struct sPAPRDIMMState { 29860cffce56SDavid Gibson PCDIMMDevice *dimm; 2987cf632463SBharata B Rao uint32_t nr_lmbs; 29880cffce56SDavid Gibson QTAILQ_ENTRY(sPAPRDIMMState) next; 29890cffce56SDavid Gibson }; 29900cffce56SDavid Gibson 29910cffce56SDavid Gibson static sPAPRDIMMState *spapr_pending_dimm_unplugs_find(sPAPRMachineState *s, 29920cffce56SDavid Gibson PCDIMMDevice *dimm) 29930cffce56SDavid Gibson { 29940cffce56SDavid Gibson sPAPRDIMMState *dimm_state = NULL; 29950cffce56SDavid Gibson 29960cffce56SDavid Gibson QTAILQ_FOREACH(dimm_state, &s->pending_dimm_unplugs, next) { 29970cffce56SDavid Gibson if (dimm_state->dimm == dimm) { 29980cffce56SDavid Gibson break; 29990cffce56SDavid Gibson } 30000cffce56SDavid Gibson } 30010cffce56SDavid Gibson return dimm_state; 30020cffce56SDavid Gibson } 30030cffce56SDavid Gibson 30048d5981c4SBharata B Rao static sPAPRDIMMState *spapr_pending_dimm_unplugs_add(sPAPRMachineState *spapr, 30058d5981c4SBharata B Rao uint32_t nr_lmbs, 30068d5981c4SBharata B Rao PCDIMMDevice *dimm) 30070cffce56SDavid Gibson { 30088d5981c4SBharata B Rao sPAPRDIMMState *ds = NULL; 30098d5981c4SBharata B Rao 30108d5981c4SBharata B Rao /* 30118d5981c4SBharata B Rao * If this request is for a DIMM whose removal had failed earlier 30128d5981c4SBharata B Rao * (due to guest's refusal to remove the LMBs), we would have this 30138d5981c4SBharata B Rao * dimm already in the pending_dimm_unplugs list. In that 30148d5981c4SBharata B Rao * case don't add again. 30158d5981c4SBharata B Rao */ 30168d5981c4SBharata B Rao ds = spapr_pending_dimm_unplugs_find(spapr, dimm); 30178d5981c4SBharata B Rao if (!ds) { 30188d5981c4SBharata B Rao ds = g_malloc0(sizeof(sPAPRDIMMState)); 30198d5981c4SBharata B Rao ds->nr_lmbs = nr_lmbs; 30208d5981c4SBharata B Rao ds->dimm = dimm; 30218d5981c4SBharata B Rao QTAILQ_INSERT_HEAD(&spapr->pending_dimm_unplugs, ds, next); 30228d5981c4SBharata B Rao } 30238d5981c4SBharata B Rao return ds; 30240cffce56SDavid Gibson } 30250cffce56SDavid Gibson 30260cffce56SDavid Gibson static void spapr_pending_dimm_unplugs_remove(sPAPRMachineState *spapr, 30270cffce56SDavid Gibson sPAPRDIMMState *dimm_state) 30280cffce56SDavid Gibson { 30290cffce56SDavid Gibson QTAILQ_REMOVE(&spapr->pending_dimm_unplugs, dimm_state, next); 30300cffce56SDavid Gibson g_free(dimm_state); 30310cffce56SDavid Gibson } 3032cf632463SBharata B Rao 303316ee9980SDaniel Henrique Barboza static sPAPRDIMMState *spapr_recover_pending_dimm_state(sPAPRMachineState *ms, 303416ee9980SDaniel Henrique Barboza PCDIMMDevice *dimm) 303516ee9980SDaniel Henrique Barboza { 303616ee9980SDaniel Henrique Barboza sPAPRDRConnector *drc; 303716ee9980SDaniel Henrique Barboza PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); 303804790978SThomas Huth MemoryRegion *mr = ddc->get_memory_region(dimm, &error_abort); 303916ee9980SDaniel Henrique Barboza uint64_t size = memory_region_size(mr); 304016ee9980SDaniel Henrique Barboza uint32_t nr_lmbs = size / SPAPR_MEMORY_BLOCK_SIZE; 304116ee9980SDaniel Henrique Barboza uint32_t avail_lmbs = 0; 304216ee9980SDaniel Henrique Barboza uint64_t addr_start, addr; 304316ee9980SDaniel Henrique Barboza int i; 304416ee9980SDaniel Henrique Barboza 304516ee9980SDaniel Henrique Barboza addr_start = object_property_get_int(OBJECT(dimm), PC_DIMM_ADDR_PROP, 304616ee9980SDaniel Henrique Barboza &error_abort); 304716ee9980SDaniel Henrique Barboza 304816ee9980SDaniel Henrique Barboza addr = addr_start; 304916ee9980SDaniel Henrique Barboza for (i = 0; i < nr_lmbs; i++) { 3050fbf55397SDavid Gibson drc = spapr_drc_by_id(TYPE_SPAPR_DRC_LMB, 305116ee9980SDaniel Henrique Barboza addr / SPAPR_MEMORY_BLOCK_SIZE); 305216ee9980SDaniel Henrique Barboza g_assert(drc); 3053454b580aSDavid Gibson if (drc->dev) { 305416ee9980SDaniel Henrique Barboza avail_lmbs++; 305516ee9980SDaniel Henrique Barboza } 305616ee9980SDaniel Henrique Barboza addr += SPAPR_MEMORY_BLOCK_SIZE; 305716ee9980SDaniel Henrique Barboza } 305816ee9980SDaniel Henrique Barboza 30598d5981c4SBharata B Rao return spapr_pending_dimm_unplugs_add(ms, avail_lmbs, dimm); 306016ee9980SDaniel Henrique Barboza } 306116ee9980SDaniel Henrique Barboza 306231834723SDaniel Henrique Barboza /* Callback to be called during DRC release. */ 306331834723SDaniel Henrique Barboza void spapr_lmb_release(DeviceState *dev) 3064cf632463SBharata B Rao { 3065765d1bddSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(qdev_get_hotplug_handler(dev)); 3066765d1bddSDavid Gibson PCDIMMDevice *dimm = PC_DIMM(dev); 3067765d1bddSDavid Gibson PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); 306804790978SThomas Huth MemoryRegion *mr = ddc->get_memory_region(dimm, &error_abort); 30690cffce56SDavid Gibson sPAPRDIMMState *ds = spapr_pending_dimm_unplugs_find(spapr, PC_DIMM(dev)); 3070cf632463SBharata B Rao 307116ee9980SDaniel Henrique Barboza /* This information will get lost if a migration occurs 307216ee9980SDaniel Henrique Barboza * during the unplug process. In this case recover it. */ 307316ee9980SDaniel Henrique Barboza if (ds == NULL) { 307416ee9980SDaniel Henrique Barboza ds = spapr_recover_pending_dimm_state(spapr, PC_DIMM(dev)); 30758d5981c4SBharata B Rao g_assert(ds); 3076454b580aSDavid Gibson /* The DRC being examined by the caller at least must be counted */ 3077454b580aSDavid Gibson g_assert(ds->nr_lmbs); 307816ee9980SDaniel Henrique Barboza } 3079454b580aSDavid Gibson 3080454b580aSDavid Gibson if (--ds->nr_lmbs) { 3081cf632463SBharata B Rao return; 3082cf632463SBharata B Rao } 3083cf632463SBharata B Rao 3084cf632463SBharata B Rao /* 3085cf632463SBharata B Rao * Now that all the LMBs have been removed by the guest, call the 3086cf632463SBharata B Rao * pc-dimm unplug handler to cleanup up the pc-dimm device. 3087cf632463SBharata B Rao */ 3088765d1bddSDavid Gibson pc_dimm_memory_unplug(dev, &spapr->hotplug_memory, mr); 3089cf632463SBharata B Rao object_unparent(OBJECT(dev)); 30902a129767SDaniel Henrique Barboza spapr_pending_dimm_unplugs_remove(spapr, ds); 3091cf632463SBharata B Rao } 3092cf632463SBharata B Rao 3093cf632463SBharata B Rao static void spapr_memory_unplug_request(HotplugHandler *hotplug_dev, 3094cf632463SBharata B Rao DeviceState *dev, Error **errp) 3095cf632463SBharata B Rao { 30960cffce56SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(hotplug_dev); 3097cf632463SBharata B Rao Error *local_err = NULL; 3098cf632463SBharata B Rao PCDIMMDevice *dimm = PC_DIMM(dev); 3099cf632463SBharata B Rao PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); 310004790978SThomas Huth MemoryRegion *mr; 310104790978SThomas Huth uint32_t nr_lmbs; 310204790978SThomas Huth uint64_t size, addr_start, addr; 31030cffce56SDavid Gibson int i; 31040cffce56SDavid Gibson sPAPRDRConnector *drc; 310504790978SThomas Huth 310604790978SThomas Huth mr = ddc->get_memory_region(dimm, &local_err); 310704790978SThomas Huth if (local_err) { 310804790978SThomas Huth goto out; 310904790978SThomas Huth } 311004790978SThomas Huth size = memory_region_size(mr); 311104790978SThomas Huth nr_lmbs = size / SPAPR_MEMORY_BLOCK_SIZE; 311204790978SThomas Huth 31139ed442b8SMarc-André Lureau addr_start = object_property_get_uint(OBJECT(dimm), PC_DIMM_ADDR_PROP, 31140cffce56SDavid Gibson &local_err); 3115cf632463SBharata B Rao if (local_err) { 3116cf632463SBharata B Rao goto out; 3117cf632463SBharata B Rao } 3118cf632463SBharata B Rao 31192a129767SDaniel Henrique Barboza /* 31202a129767SDaniel Henrique Barboza * An existing pending dimm state for this DIMM means that there is an 31212a129767SDaniel Henrique Barboza * unplug operation in progress, waiting for the spapr_lmb_release 31222a129767SDaniel Henrique Barboza * callback to complete the job (BQL can't cover that far). In this case, 31232a129767SDaniel Henrique Barboza * bail out to avoid detaching DRCs that were already released. 31242a129767SDaniel Henrique Barboza */ 31252a129767SDaniel Henrique Barboza if (spapr_pending_dimm_unplugs_find(spapr, dimm)) { 31262a129767SDaniel Henrique Barboza error_setg(&local_err, 31272a129767SDaniel Henrique Barboza "Memory unplug already in progress for device %s", 31282a129767SDaniel Henrique Barboza dev->id); 31292a129767SDaniel Henrique Barboza goto out; 31302a129767SDaniel Henrique Barboza } 31312a129767SDaniel Henrique Barboza 31328d5981c4SBharata B Rao spapr_pending_dimm_unplugs_add(spapr, nr_lmbs, dimm); 31330cffce56SDavid Gibson 31340cffce56SDavid Gibson addr = addr_start; 31350cffce56SDavid Gibson for (i = 0; i < nr_lmbs; i++) { 3136fbf55397SDavid Gibson drc = spapr_drc_by_id(TYPE_SPAPR_DRC_LMB, 31370cffce56SDavid Gibson addr / SPAPR_MEMORY_BLOCK_SIZE); 31380cffce56SDavid Gibson g_assert(drc); 31390cffce56SDavid Gibson 3140a8dc47fdSDavid Gibson spapr_drc_detach(drc); 31410cffce56SDavid Gibson addr += SPAPR_MEMORY_BLOCK_SIZE; 31420cffce56SDavid Gibson } 31430cffce56SDavid Gibson 3144fbf55397SDavid Gibson drc = spapr_drc_by_id(TYPE_SPAPR_DRC_LMB, 31450cffce56SDavid Gibson addr_start / SPAPR_MEMORY_BLOCK_SIZE); 31460cffce56SDavid Gibson spapr_hotplug_req_remove_by_count_indexed(SPAPR_DR_CONNECTOR_TYPE_LMB, 31470b55aa91SDavid Gibson nr_lmbs, spapr_drc_index(drc)); 3148cf632463SBharata B Rao out: 3149cf632463SBharata B Rao error_propagate(errp, local_err); 3150cf632463SBharata B Rao } 3151cf632463SBharata B Rao 315204d0ffbdSGreg Kurz static void *spapr_populate_hotplug_cpu_dt(CPUState *cs, int *fdt_offset, 3153af81cf32SBharata B Rao sPAPRMachineState *spapr) 3154af81cf32SBharata B Rao { 3155af81cf32SBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(cs); 3156af81cf32SBharata B Rao DeviceClass *dc = DEVICE_GET_CLASS(cs); 31572e886fb3SSam Bobroff int id = spapr_vcpu_id(cpu); 3158af81cf32SBharata B Rao void *fdt; 3159af81cf32SBharata B Rao int offset, fdt_size; 3160af81cf32SBharata B Rao char *nodename; 3161af81cf32SBharata B Rao 3162af81cf32SBharata B Rao fdt = create_device_tree(&fdt_size); 3163af81cf32SBharata B Rao nodename = g_strdup_printf("%s@%x", dc->fw_name, id); 3164af81cf32SBharata B Rao offset = fdt_add_subnode(fdt, 0, nodename); 3165af81cf32SBharata B Rao 3166af81cf32SBharata B Rao spapr_populate_cpu_dt(cs, fdt, offset, spapr); 3167af81cf32SBharata B Rao g_free(nodename); 3168af81cf32SBharata B Rao 3169af81cf32SBharata B Rao *fdt_offset = offset; 3170af81cf32SBharata B Rao return fdt; 3171af81cf32SBharata B Rao } 3172af81cf32SBharata B Rao 3173765d1bddSDavid Gibson /* Callback to be called during DRC release. */ 3174765d1bddSDavid Gibson void spapr_core_release(DeviceState *dev) 3175ff9006ddSIgor Mammedov { 3176765d1bddSDavid Gibson MachineState *ms = MACHINE(qdev_get_hotplug_handler(dev)); 317746f7afa3SGreg Kurz sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(ms); 3178ff9006ddSIgor Mammedov CPUCore *cc = CPU_CORE(dev); 3179535455fdSIgor Mammedov CPUArchId *core_slot = spapr_find_cpu_slot(ms, cc->core_id, NULL); 3180ff9006ddSIgor Mammedov 318146f7afa3SGreg Kurz if (smc->pre_2_10_has_unused_icps) { 318246f7afa3SGreg Kurz sPAPRCPUCore *sc = SPAPR_CPU_CORE(OBJECT(dev)); 318346f7afa3SGreg Kurz int i; 318446f7afa3SGreg Kurz 318546f7afa3SGreg Kurz for (i = 0; i < cc->nr_threads; i++) { 318694ad93bdSGreg Kurz CPUState *cs = CPU(sc->threads[i]); 318746f7afa3SGreg Kurz 318846f7afa3SGreg Kurz pre_2_10_vmstate_register_dummy_icp(cs->cpu_index); 318946f7afa3SGreg Kurz } 319046f7afa3SGreg Kurz } 319146f7afa3SGreg Kurz 319207572c06SGreg Kurz assert(core_slot); 3193535455fdSIgor Mammedov core_slot->cpu = NULL; 3194ff9006ddSIgor Mammedov object_unparent(OBJECT(dev)); 3195ff9006ddSIgor Mammedov } 3196ff9006ddSIgor Mammedov 3197115debf2SIgor Mammedov static 3198115debf2SIgor Mammedov void spapr_core_unplug_request(HotplugHandler *hotplug_dev, DeviceState *dev, 3199ff9006ddSIgor Mammedov Error **errp) 3200ff9006ddSIgor Mammedov { 3201535455fdSIgor Mammedov int index; 3202535455fdSIgor Mammedov sPAPRDRConnector *drc; 3203535455fdSIgor Mammedov CPUCore *cc = CPU_CORE(dev); 3204535455fdSIgor Mammedov int smt = kvmppc_smt_threads(); 3205ff9006ddSIgor Mammedov 3206535455fdSIgor Mammedov if (!spapr_find_cpu_slot(MACHINE(hotplug_dev), cc->core_id, &index)) { 3207535455fdSIgor Mammedov error_setg(errp, "Unable to find CPU core with core-id: %d", 3208535455fdSIgor Mammedov cc->core_id); 3209535455fdSIgor Mammedov return; 3210535455fdSIgor Mammedov } 3211ff9006ddSIgor Mammedov if (index == 0) { 3212ff9006ddSIgor Mammedov error_setg(errp, "Boot CPU core may not be unplugged"); 3213ff9006ddSIgor Mammedov return; 3214ff9006ddSIgor Mammedov } 3215ff9006ddSIgor Mammedov 3216fbf55397SDavid Gibson drc = spapr_drc_by_id(TYPE_SPAPR_DRC_CPU, index * smt); 3217ff9006ddSIgor Mammedov g_assert(drc); 3218ff9006ddSIgor Mammedov 3219a8dc47fdSDavid Gibson spapr_drc_detach(drc); 3220ff9006ddSIgor Mammedov 3221ff9006ddSIgor Mammedov spapr_hotplug_req_remove_by_index(drc); 3222ff9006ddSIgor Mammedov } 3223ff9006ddSIgor Mammedov 3224ff9006ddSIgor Mammedov static void spapr_core_plug(HotplugHandler *hotplug_dev, DeviceState *dev, 3225ff9006ddSIgor Mammedov Error **errp) 3226ff9006ddSIgor Mammedov { 3227ff9006ddSIgor Mammedov sPAPRMachineState *spapr = SPAPR_MACHINE(OBJECT(hotplug_dev)); 3228ff9006ddSIgor Mammedov MachineClass *mc = MACHINE_GET_CLASS(spapr); 322946f7afa3SGreg Kurz sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); 3230ff9006ddSIgor Mammedov sPAPRCPUCore *core = SPAPR_CPU_CORE(OBJECT(dev)); 3231ff9006ddSIgor Mammedov CPUCore *cc = CPU_CORE(dev); 323294ad93bdSGreg Kurz CPUState *cs = CPU(core->threads[0]); 3233ff9006ddSIgor Mammedov sPAPRDRConnector *drc; 3234ff9006ddSIgor Mammedov Error *local_err = NULL; 3235ff9006ddSIgor Mammedov int smt = kvmppc_smt_threads(); 3236535455fdSIgor Mammedov CPUArchId *core_slot; 3237535455fdSIgor Mammedov int index; 323894fd9cbaSLaurent Vivier bool hotplugged = spapr_drc_hotplugged(dev); 3239ff9006ddSIgor Mammedov 3240535455fdSIgor Mammedov core_slot = spapr_find_cpu_slot(MACHINE(hotplug_dev), cc->core_id, &index); 3241535455fdSIgor Mammedov if (!core_slot) { 3242535455fdSIgor Mammedov error_setg(errp, "Unable to find CPU core with core-id: %d", 3243535455fdSIgor Mammedov cc->core_id); 3244535455fdSIgor Mammedov return; 3245535455fdSIgor Mammedov } 3246fbf55397SDavid Gibson drc = spapr_drc_by_id(TYPE_SPAPR_DRC_CPU, index * smt); 3247ff9006ddSIgor Mammedov 3248c5514d0eSIgor Mammedov g_assert(drc || !mc->has_hotpluggable_cpus); 3249ff9006ddSIgor Mammedov 3250e49c63d5SGreg Kurz if (drc) { 3251e49c63d5SGreg Kurz void *fdt; 3252e49c63d5SGreg Kurz int fdt_offset; 3253e49c63d5SGreg Kurz 3254ff9006ddSIgor Mammedov fdt = spapr_populate_hotplug_cpu_dt(cs, &fdt_offset, spapr); 3255ff9006ddSIgor Mammedov 32565c1da812SDavid Gibson spapr_drc_attach(drc, dev, fdt, fdt_offset, &local_err); 3257ff9006ddSIgor Mammedov if (local_err) { 3258ff9006ddSIgor Mammedov g_free(fdt); 3259ff9006ddSIgor Mammedov error_propagate(errp, local_err); 3260ff9006ddSIgor Mammedov return; 3261ff9006ddSIgor Mammedov } 3262ff9006ddSIgor Mammedov 326394fd9cbaSLaurent Vivier if (hotplugged) { 3264ff9006ddSIgor Mammedov /* 326594fd9cbaSLaurent Vivier * Send hotplug notification interrupt to the guest only 326694fd9cbaSLaurent Vivier * in case of hotplugged CPUs. 3267ff9006ddSIgor Mammedov */ 3268ff9006ddSIgor Mammedov spapr_hotplug_req_add_by_index(drc); 326994fd9cbaSLaurent Vivier } else { 327094fd9cbaSLaurent Vivier spapr_drc_reset(drc); 3271ff9006ddSIgor Mammedov } 327294fd9cbaSLaurent Vivier } 327394fd9cbaSLaurent Vivier 3274535455fdSIgor Mammedov core_slot->cpu = OBJECT(dev); 327546f7afa3SGreg Kurz 327646f7afa3SGreg Kurz if (smc->pre_2_10_has_unused_icps) { 327746f7afa3SGreg Kurz int i; 327846f7afa3SGreg Kurz 327946f7afa3SGreg Kurz for (i = 0; i < cc->nr_threads; i++) { 328046f7afa3SGreg Kurz sPAPRCPUCore *sc = SPAPR_CPU_CORE(dev); 328146f7afa3SGreg Kurz 328294ad93bdSGreg Kurz cs = CPU(sc->threads[i]); 328346f7afa3SGreg Kurz pre_2_10_vmstate_unregister_dummy_icp(cs->cpu_index); 328446f7afa3SGreg Kurz } 328546f7afa3SGreg Kurz } 3286ff9006ddSIgor Mammedov } 3287ff9006ddSIgor Mammedov 3288ff9006ddSIgor Mammedov static void spapr_core_pre_plug(HotplugHandler *hotplug_dev, DeviceState *dev, 3289ff9006ddSIgor Mammedov Error **errp) 3290ff9006ddSIgor Mammedov { 3291ff9006ddSIgor Mammedov MachineState *machine = MACHINE(OBJECT(hotplug_dev)); 3292ff9006ddSIgor Mammedov MachineClass *mc = MACHINE_GET_CLASS(hotplug_dev); 3293ff9006ddSIgor Mammedov Error *local_err = NULL; 3294ff9006ddSIgor Mammedov CPUCore *cc = CPU_CORE(dev); 32952e9c10ebSIgor Mammedov const char *base_core_type = spapr_get_cpu_core_type(machine->cpu_type); 3296ff9006ddSIgor Mammedov const char *type = object_get_typename(OBJECT(dev)); 3297535455fdSIgor Mammedov CPUArchId *core_slot; 3298535455fdSIgor Mammedov int index; 3299ff9006ddSIgor Mammedov 3300c5514d0eSIgor Mammedov if (dev->hotplugged && !mc->has_hotpluggable_cpus) { 3301ff9006ddSIgor Mammedov error_setg(&local_err, "CPU hotplug not supported for this machine"); 3302ff9006ddSIgor Mammedov goto out; 3303ff9006ddSIgor Mammedov } 3304ff9006ddSIgor Mammedov 3305ff9006ddSIgor Mammedov if (strcmp(base_core_type, type)) { 3306ff9006ddSIgor Mammedov error_setg(&local_err, "CPU core type should be %s", base_core_type); 3307ff9006ddSIgor Mammedov goto out; 3308ff9006ddSIgor Mammedov } 3309ff9006ddSIgor Mammedov 3310ff9006ddSIgor Mammedov if (cc->core_id % smp_threads) { 3311ff9006ddSIgor Mammedov error_setg(&local_err, "invalid core id %d", cc->core_id); 3312ff9006ddSIgor Mammedov goto out; 3313ff9006ddSIgor Mammedov } 3314ff9006ddSIgor Mammedov 3315459264efSDavid Gibson /* 3316459264efSDavid Gibson * In general we should have homogeneous threads-per-core, but old 3317459264efSDavid Gibson * (pre hotplug support) machine types allow the last core to have 3318459264efSDavid Gibson * reduced threads as a compatibility hack for when we allowed 3319459264efSDavid Gibson * total vcpus not a multiple of threads-per-core. 3320459264efSDavid Gibson */ 3321459264efSDavid Gibson if (mc->has_hotpluggable_cpus && (cc->nr_threads != smp_threads)) { 3322df8658deSGreg Kurz error_setg(&local_err, "invalid nr-threads %d, must be %d", 33238149e299SDavid Gibson cc->nr_threads, smp_threads); 3324df8658deSGreg Kurz goto out; 33258149e299SDavid Gibson } 33268149e299SDavid Gibson 3327535455fdSIgor Mammedov core_slot = spapr_find_cpu_slot(MACHINE(hotplug_dev), cc->core_id, &index); 3328535455fdSIgor Mammedov if (!core_slot) { 3329ff9006ddSIgor Mammedov error_setg(&local_err, "core id %d out of range", cc->core_id); 3330ff9006ddSIgor Mammedov goto out; 3331ff9006ddSIgor Mammedov } 3332ff9006ddSIgor Mammedov 3333535455fdSIgor Mammedov if (core_slot->cpu) { 3334ff9006ddSIgor Mammedov error_setg(&local_err, "core %d already populated", cc->core_id); 3335ff9006ddSIgor Mammedov goto out; 3336ff9006ddSIgor Mammedov } 3337ff9006ddSIgor Mammedov 3338a0ceb640SIgor Mammedov numa_cpu_pre_plug(core_slot, dev, &local_err); 33390b8497f0SIgor Mammedov 3340ff9006ddSIgor Mammedov out: 3341ff9006ddSIgor Mammedov error_propagate(errp, local_err); 3342ff9006ddSIgor Mammedov } 3343ff9006ddSIgor Mammedov 3344c20d332aSBharata B Rao static void spapr_machine_device_plug(HotplugHandler *hotplug_dev, 3345c20d332aSBharata B Rao DeviceState *dev, Error **errp) 3346c20d332aSBharata B Rao { 3347c86c1affSDaniel Henrique Barboza MachineState *ms = MACHINE(hotplug_dev); 3348c86c1affSDaniel Henrique Barboza sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(ms); 3349c20d332aSBharata B Rao 3350c20d332aSBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { 3351b556854bSBharata B Rao int node; 3352c20d332aSBharata B Rao 3353c20d332aSBharata B Rao if (!smc->dr_lmb_enabled) { 3354c20d332aSBharata B Rao error_setg(errp, "Memory hotplug not supported for this machine"); 3355c20d332aSBharata B Rao return; 3356c20d332aSBharata B Rao } 33579ed442b8SMarc-André Lureau node = object_property_get_uint(OBJECT(dev), PC_DIMM_NODE_PROP, errp); 3358c20d332aSBharata B Rao if (*errp) { 3359c20d332aSBharata B Rao return; 3360c20d332aSBharata B Rao } 33611a5512bbSGonglei if (node < 0 || node >= MAX_NODES) { 33621a5512bbSGonglei error_setg(errp, "Invaild node %d", node); 33631a5512bbSGonglei return; 33641a5512bbSGonglei } 3365c20d332aSBharata B Rao 3366b556854bSBharata B Rao /* 3367b556854bSBharata B Rao * Currently PowerPC kernel doesn't allow hot-adding memory to 3368b556854bSBharata B Rao * memory-less node, but instead will silently add the memory 3369b556854bSBharata B Rao * to the first node that has some memory. This causes two 3370b556854bSBharata B Rao * unexpected behaviours for the user. 3371b556854bSBharata B Rao * 3372b556854bSBharata B Rao * - Memory gets hotplugged to a different node than what the user 3373b556854bSBharata B Rao * specified. 3374b556854bSBharata B Rao * - Since pc-dimm subsystem in QEMU still thinks that memory belongs 3375b556854bSBharata B Rao * to memory-less node, a reboot will set things accordingly 3376b556854bSBharata B Rao * and the previously hotplugged memory now ends in the right node. 3377b556854bSBharata B Rao * This appears as if some memory moved from one node to another. 3378b556854bSBharata B Rao * 3379b556854bSBharata B Rao * So until kernel starts supporting memory hotplug to memory-less 3380b556854bSBharata B Rao * nodes, just prevent such attempts upfront in QEMU. 3381b556854bSBharata B Rao */ 3382b556854bSBharata B Rao if (nb_numa_nodes && !numa_info[node].node_mem) { 3383b556854bSBharata B Rao error_setg(errp, "Can't hotplug memory to memory-less node %d", 3384b556854bSBharata B Rao node); 3385b556854bSBharata B Rao return; 3386b556854bSBharata B Rao } 3387b556854bSBharata B Rao 3388c20d332aSBharata B Rao spapr_memory_plug(hotplug_dev, dev, node, errp); 3389af81cf32SBharata B Rao } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 3390af81cf32SBharata B Rao spapr_core_plug(hotplug_dev, dev, errp); 3391c20d332aSBharata B Rao } 3392c20d332aSBharata B Rao } 3393c20d332aSBharata B Rao 3394cf632463SBharata B Rao static void spapr_machine_device_unplug_request(HotplugHandler *hotplug_dev, 3395cf632463SBharata B Rao DeviceState *dev, Error **errp) 3396cf632463SBharata B Rao { 3397c86c1affSDaniel Henrique Barboza sPAPRMachineState *sms = SPAPR_MACHINE(OBJECT(hotplug_dev)); 3398c86c1affSDaniel Henrique Barboza MachineClass *mc = MACHINE_GET_CLASS(sms); 3399cf632463SBharata B Rao 3400cf632463SBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { 3401cf632463SBharata B Rao if (spapr_ovec_test(sms->ov5_cas, OV5_HP_EVT)) { 3402cf632463SBharata B Rao spapr_memory_unplug_request(hotplug_dev, dev, errp); 3403cf632463SBharata B Rao } else { 3404cf632463SBharata B Rao /* NOTE: this means there is a window after guest reset, prior to 3405cf632463SBharata B Rao * CAS negotiation, where unplug requests will fail due to the 3406cf632463SBharata B Rao * capability not being detected yet. This is a bit different than 3407cf632463SBharata B Rao * the case with PCI unplug, where the events will be queued and 3408cf632463SBharata B Rao * eventually handled by the guest after boot 3409cf632463SBharata B Rao */ 3410cf632463SBharata B Rao error_setg(errp, "Memory hot unplug not supported for this guest"); 3411cf632463SBharata B Rao } 34126f4b5c3eSBharata B Rao } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 3413c5514d0eSIgor Mammedov if (!mc->has_hotpluggable_cpus) { 34146f4b5c3eSBharata B Rao error_setg(errp, "CPU hot unplug not supported on this machine"); 34156f4b5c3eSBharata B Rao return; 34166f4b5c3eSBharata B Rao } 3417115debf2SIgor Mammedov spapr_core_unplug_request(hotplug_dev, dev, errp); 3418c20d332aSBharata B Rao } 3419c20d332aSBharata B Rao } 3420c20d332aSBharata B Rao 342194a94e4cSBharata B Rao static void spapr_machine_device_pre_plug(HotplugHandler *hotplug_dev, 342294a94e4cSBharata B Rao DeviceState *dev, Error **errp) 342394a94e4cSBharata B Rao { 3424c871bc70SLaurent Vivier if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { 3425c871bc70SLaurent Vivier spapr_memory_pre_plug(hotplug_dev, dev, errp); 3426c871bc70SLaurent Vivier } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 342794a94e4cSBharata B Rao spapr_core_pre_plug(hotplug_dev, dev, errp); 342894a94e4cSBharata B Rao } 342994a94e4cSBharata B Rao } 343094a94e4cSBharata B Rao 34317ebaf795SBharata B Rao static HotplugHandler *spapr_get_hotplug_handler(MachineState *machine, 3432c20d332aSBharata B Rao DeviceState *dev) 3433c20d332aSBharata B Rao { 343494a94e4cSBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM) || 343594a94e4cSBharata B Rao object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 3436c20d332aSBharata B Rao return HOTPLUG_HANDLER(machine); 3437c20d332aSBharata B Rao } 3438c20d332aSBharata B Rao return NULL; 3439c20d332aSBharata B Rao } 3440c20d332aSBharata B Rao 3441ea089eebSIgor Mammedov static CpuInstanceProperties 3442ea089eebSIgor Mammedov spapr_cpu_index_to_props(MachineState *machine, unsigned cpu_index) 344320bb648dSDavid Gibson { 3444ea089eebSIgor Mammedov CPUArchId *core_slot; 3445ea089eebSIgor Mammedov MachineClass *mc = MACHINE_GET_CLASS(machine); 3446ea089eebSIgor Mammedov 3447ea089eebSIgor Mammedov /* make sure possible_cpu are intialized */ 3448ea089eebSIgor Mammedov mc->possible_cpu_arch_ids(machine); 3449ea089eebSIgor Mammedov /* get CPU core slot containing thread that matches cpu_index */ 3450ea089eebSIgor Mammedov core_slot = spapr_find_cpu_slot(machine, cpu_index, NULL); 3451ea089eebSIgor Mammedov assert(core_slot); 3452ea089eebSIgor Mammedov return core_slot->props; 345320bb648dSDavid Gibson } 345420bb648dSDavid Gibson 345579e07936SIgor Mammedov static int64_t spapr_get_default_cpu_node_id(const MachineState *ms, int idx) 345679e07936SIgor Mammedov { 345779e07936SIgor Mammedov return idx / smp_cores % nb_numa_nodes; 345879e07936SIgor Mammedov } 345979e07936SIgor Mammedov 3460535455fdSIgor Mammedov static const CPUArchIdList *spapr_possible_cpu_arch_ids(MachineState *machine) 3461535455fdSIgor Mammedov { 3462535455fdSIgor Mammedov int i; 3463535455fdSIgor Mammedov int spapr_max_cores = max_cpus / smp_threads; 3464535455fdSIgor Mammedov MachineClass *mc = MACHINE_GET_CLASS(machine); 3465535455fdSIgor Mammedov 3466c5514d0eSIgor Mammedov if (!mc->has_hotpluggable_cpus) { 3467535455fdSIgor Mammedov spapr_max_cores = QEMU_ALIGN_UP(smp_cpus, smp_threads) / smp_threads; 3468535455fdSIgor Mammedov } 3469535455fdSIgor Mammedov if (machine->possible_cpus) { 3470535455fdSIgor Mammedov assert(machine->possible_cpus->len == spapr_max_cores); 3471535455fdSIgor Mammedov return machine->possible_cpus; 3472535455fdSIgor Mammedov } 3473535455fdSIgor Mammedov 3474535455fdSIgor Mammedov machine->possible_cpus = g_malloc0(sizeof(CPUArchIdList) + 3475535455fdSIgor Mammedov sizeof(CPUArchId) * spapr_max_cores); 3476535455fdSIgor Mammedov machine->possible_cpus->len = spapr_max_cores; 3477535455fdSIgor Mammedov for (i = 0; i < machine->possible_cpus->len; i++) { 3478535455fdSIgor Mammedov int core_id = i * smp_threads; 3479535455fdSIgor Mammedov 3480f2d672c2SIgor Mammedov machine->possible_cpus->cpus[i].vcpus_count = smp_threads; 3481535455fdSIgor Mammedov machine->possible_cpus->cpus[i].arch_id = core_id; 3482535455fdSIgor Mammedov machine->possible_cpus->cpus[i].props.has_core_id = true; 3483535455fdSIgor Mammedov machine->possible_cpus->cpus[i].props.core_id = core_id; 3484535455fdSIgor Mammedov } 3485535455fdSIgor Mammedov return machine->possible_cpus; 3486535455fdSIgor Mammedov } 3487535455fdSIgor Mammedov 34886737d9adSDavid Gibson static void spapr_phb_placement(sPAPRMachineState *spapr, uint32_t index, 3489daa23699SDavid Gibson uint64_t *buid, hwaddr *pio, 3490daa23699SDavid Gibson hwaddr *mmio32, hwaddr *mmio64, 34916737d9adSDavid Gibson unsigned n_dma, uint32_t *liobns, Error **errp) 34926737d9adSDavid Gibson { 3493357d1e3bSDavid Gibson /* 3494357d1e3bSDavid Gibson * New-style PHB window placement. 3495357d1e3bSDavid Gibson * 3496357d1e3bSDavid Gibson * Goals: Gives large (1TiB), naturally aligned 64-bit MMIO window 3497357d1e3bSDavid Gibson * for each PHB, in addition to 2GiB 32-bit MMIO and 64kiB PIO 3498357d1e3bSDavid Gibson * windows. 3499357d1e3bSDavid Gibson * 3500357d1e3bSDavid Gibson * Some guest kernels can't work with MMIO windows above 1<<46 3501357d1e3bSDavid Gibson * (64TiB), so we place up to 31 PHBs in the area 32TiB..64TiB 3502357d1e3bSDavid Gibson * 3503357d1e3bSDavid Gibson * 32TiB..(33TiB+1984kiB) contains the 64kiB PIO windows for each 3504357d1e3bSDavid Gibson * PHB stacked together. (32TiB+2GiB)..(32TiB+64GiB) contains the 3505357d1e3bSDavid Gibson * 2GiB 32-bit MMIO windows for each PHB. Then 33..64TiB has the 3506357d1e3bSDavid Gibson * 1TiB 64-bit MMIO windows for each PHB. 3507357d1e3bSDavid Gibson */ 35086737d9adSDavid Gibson const uint64_t base_buid = 0x800000020000000ULL; 350925e6a118SMichael S. Tsirkin #define SPAPR_MAX_PHBS ((SPAPR_PCI_LIMIT - SPAPR_PCI_BASE) / \ 351025e6a118SMichael S. Tsirkin SPAPR_PCI_MEM64_WIN_SIZE - 1) 35116737d9adSDavid Gibson int i; 35126737d9adSDavid Gibson 3513357d1e3bSDavid Gibson /* Sanity check natural alignments */ 3514357d1e3bSDavid Gibson QEMU_BUILD_BUG_ON((SPAPR_PCI_BASE % SPAPR_PCI_MEM64_WIN_SIZE) != 0); 3515357d1e3bSDavid Gibson QEMU_BUILD_BUG_ON((SPAPR_PCI_LIMIT % SPAPR_PCI_MEM64_WIN_SIZE) != 0); 3516357d1e3bSDavid Gibson QEMU_BUILD_BUG_ON((SPAPR_PCI_MEM64_WIN_SIZE % SPAPR_PCI_MEM32_WIN_SIZE) != 0); 3517357d1e3bSDavid Gibson QEMU_BUILD_BUG_ON((SPAPR_PCI_MEM32_WIN_SIZE % SPAPR_PCI_IO_WIN_SIZE) != 0); 3518357d1e3bSDavid Gibson /* Sanity check bounds */ 351925e6a118SMichael S. Tsirkin QEMU_BUILD_BUG_ON((SPAPR_MAX_PHBS * SPAPR_PCI_IO_WIN_SIZE) > 352025e6a118SMichael S. Tsirkin SPAPR_PCI_MEM32_WIN_SIZE); 352125e6a118SMichael S. Tsirkin QEMU_BUILD_BUG_ON((SPAPR_MAX_PHBS * SPAPR_PCI_MEM32_WIN_SIZE) > 352225e6a118SMichael S. Tsirkin SPAPR_PCI_MEM64_WIN_SIZE); 35232efff1c0SDavid Gibson 352425e6a118SMichael S. Tsirkin if (index >= SPAPR_MAX_PHBS) { 352525e6a118SMichael S. Tsirkin error_setg(errp, "\"index\" for PAPR PHB is too large (max %llu)", 352625e6a118SMichael S. Tsirkin SPAPR_MAX_PHBS - 1); 35276737d9adSDavid Gibson return; 35286737d9adSDavid Gibson } 35296737d9adSDavid Gibson 35306737d9adSDavid Gibson *buid = base_buid + index; 35316737d9adSDavid Gibson for (i = 0; i < n_dma; ++i) { 35326737d9adSDavid Gibson liobns[i] = SPAPR_PCI_LIOBN(index, i); 35336737d9adSDavid Gibson } 35346737d9adSDavid Gibson 3535357d1e3bSDavid Gibson *pio = SPAPR_PCI_BASE + index * SPAPR_PCI_IO_WIN_SIZE; 3536357d1e3bSDavid Gibson *mmio32 = SPAPR_PCI_BASE + (index + 1) * SPAPR_PCI_MEM32_WIN_SIZE; 3537357d1e3bSDavid Gibson *mmio64 = SPAPR_PCI_BASE + (index + 1) * SPAPR_PCI_MEM64_WIN_SIZE; 35386737d9adSDavid Gibson } 35396737d9adSDavid Gibson 35407844e12bSCédric Le Goater static ICSState *spapr_ics_get(XICSFabric *dev, int irq) 35417844e12bSCédric Le Goater { 35427844e12bSCédric Le Goater sPAPRMachineState *spapr = SPAPR_MACHINE(dev); 35437844e12bSCédric Le Goater 35447844e12bSCédric Le Goater return ics_valid_irq(spapr->ics, irq) ? spapr->ics : NULL; 35457844e12bSCédric Le Goater } 35467844e12bSCédric Le Goater 35477844e12bSCédric Le Goater static void spapr_ics_resend(XICSFabric *dev) 35487844e12bSCédric Le Goater { 35497844e12bSCédric Le Goater sPAPRMachineState *spapr = SPAPR_MACHINE(dev); 35507844e12bSCédric Le Goater 35517844e12bSCédric Le Goater ics_resend(spapr->ics); 35527844e12bSCédric Le Goater } 35537844e12bSCédric Le Goater 355481210c20SSam Bobroff static ICPState *spapr_icp_get(XICSFabric *xi, int vcpu_id) 3555b2fc59aaSCédric Le Goater { 35562e886fb3SSam Bobroff PowerPCCPU *cpu = spapr_find_cpu(vcpu_id); 3557b2fc59aaSCédric Le Goater 35585bc8d26dSCédric Le Goater return cpu ? ICP(cpu->intc) : NULL; 3559b2fc59aaSCédric Le Goater } 3560b2fc59aaSCédric Le Goater 356160c6823bSCédric Le Goater #define ICS_IRQ_FREE(ics, srcno) \ 356260c6823bSCédric Le Goater (!((ics)->irqs[(srcno)].flags & (XICS_FLAGS_IRQ_MASK))) 356360c6823bSCédric Le Goater 356460c6823bSCédric Le Goater static int ics_find_free_block(ICSState *ics, int num, int alignnum) 356560c6823bSCédric Le Goater { 356660c6823bSCédric Le Goater int first, i; 356760c6823bSCédric Le Goater 356860c6823bSCédric Le Goater for (first = 0; first < ics->nr_irqs; first += alignnum) { 356960c6823bSCédric Le Goater if (num > (ics->nr_irqs - first)) { 357060c6823bSCédric Le Goater return -1; 357160c6823bSCédric Le Goater } 357260c6823bSCédric Le Goater for (i = first; i < first + num; ++i) { 357360c6823bSCédric Le Goater if (!ICS_IRQ_FREE(ics, i)) { 357460c6823bSCédric Le Goater break; 357560c6823bSCédric Le Goater } 357660c6823bSCédric Le Goater } 357760c6823bSCédric Le Goater if (i == (first + num)) { 357860c6823bSCédric Le Goater return first; 357960c6823bSCédric Le Goater } 358060c6823bSCédric Le Goater } 358160c6823bSCédric Le Goater 358260c6823bSCédric Le Goater return -1; 358360c6823bSCédric Le Goater } 358460c6823bSCédric Le Goater 35859e7dc5fcSCédric Le Goater /* 35869e7dc5fcSCédric Le Goater * Allocate the IRQ number and set the IRQ type, LSI or MSI 35879e7dc5fcSCédric Le Goater */ 35889e7dc5fcSCédric Le Goater static void spapr_irq_set_lsi(sPAPRMachineState *spapr, int irq, bool lsi) 35899e7dc5fcSCédric Le Goater { 35909e7dc5fcSCédric Le Goater ics_set_irq_type(spapr->ics, irq - spapr->ics->offset, lsi); 35919e7dc5fcSCédric Le Goater } 35929e7dc5fcSCédric Le Goater 359360c6823bSCédric Le Goater int spapr_irq_alloc(sPAPRMachineState *spapr, int irq_hint, bool lsi, 359460c6823bSCédric Le Goater Error **errp) 359560c6823bSCédric Le Goater { 359660c6823bSCédric Le Goater ICSState *ics = spapr->ics; 359760c6823bSCédric Le Goater int irq; 359860c6823bSCédric Le Goater 359960c6823bSCédric Le Goater if (!ics) { 360060c6823bSCédric Le Goater return -1; 360160c6823bSCédric Le Goater } 360260c6823bSCédric Le Goater if (irq_hint) { 360360c6823bSCédric Le Goater if (!ICS_IRQ_FREE(ics, irq_hint - ics->offset)) { 360460c6823bSCédric Le Goater error_setg(errp, "can't allocate IRQ %d: already in use", irq_hint); 360560c6823bSCédric Le Goater return -1; 360660c6823bSCédric Le Goater } 360760c6823bSCédric Le Goater irq = irq_hint; 360860c6823bSCédric Le Goater } else { 360960c6823bSCédric Le Goater irq = ics_find_free_block(ics, 1, 1); 361060c6823bSCédric Le Goater if (irq < 0) { 361160c6823bSCédric Le Goater error_setg(errp, "can't allocate IRQ: no IRQ left"); 361260c6823bSCédric Le Goater return -1; 361360c6823bSCédric Le Goater } 361460c6823bSCédric Le Goater irq += ics->offset; 361560c6823bSCédric Le Goater } 361660c6823bSCédric Le Goater 36179e7dc5fcSCédric Le Goater spapr_irq_set_lsi(spapr, irq, lsi); 361860c6823bSCédric Le Goater trace_spapr_irq_alloc(irq); 361960c6823bSCédric Le Goater 362060c6823bSCédric Le Goater return irq; 362160c6823bSCédric Le Goater } 362260c6823bSCédric Le Goater 362360c6823bSCédric Le Goater /* 362460c6823bSCédric Le Goater * Allocate block of consecutive IRQs, and return the number of the first IRQ in 362560c6823bSCédric Le Goater * the block. If align==true, aligns the first IRQ number to num. 362660c6823bSCédric Le Goater */ 362760c6823bSCédric Le Goater int spapr_irq_alloc_block(sPAPRMachineState *spapr, int num, bool lsi, 362860c6823bSCédric Le Goater bool align, Error **errp) 362960c6823bSCédric Le Goater { 363060c6823bSCédric Le Goater ICSState *ics = spapr->ics; 363160c6823bSCédric Le Goater int i, first = -1; 363260c6823bSCédric Le Goater 363360c6823bSCédric Le Goater if (!ics) { 363460c6823bSCédric Le Goater return -1; 363560c6823bSCédric Le Goater } 363660c6823bSCédric Le Goater 363760c6823bSCédric Le Goater /* 363860c6823bSCédric Le Goater * MSIMesage::data is used for storing VIRQ so 363960c6823bSCédric Le Goater * it has to be aligned to num to support multiple 364060c6823bSCédric Le Goater * MSI vectors. MSI-X is not affected by this. 364160c6823bSCédric Le Goater * The hint is used for the first IRQ, the rest should 364260c6823bSCédric Le Goater * be allocated continuously. 364360c6823bSCédric Le Goater */ 364460c6823bSCédric Le Goater if (align) { 364560c6823bSCédric Le Goater assert((num == 1) || (num == 2) || (num == 4) || 364660c6823bSCédric Le Goater (num == 8) || (num == 16) || (num == 32)); 364760c6823bSCédric Le Goater first = ics_find_free_block(ics, num, num); 364860c6823bSCédric Le Goater } else { 364960c6823bSCédric Le Goater first = ics_find_free_block(ics, num, 1); 365060c6823bSCédric Le Goater } 365160c6823bSCédric Le Goater if (first < 0) { 365260c6823bSCédric Le Goater error_setg(errp, "can't find a free %d-IRQ block", num); 365360c6823bSCédric Le Goater return -1; 365460c6823bSCédric Le Goater } 365560c6823bSCédric Le Goater 365660c6823bSCédric Le Goater first += ics->offset; 36579e7dc5fcSCédric Le Goater for (i = first; i < first + num; ++i) { 36589e7dc5fcSCédric Le Goater spapr_irq_set_lsi(spapr, i, lsi); 36599e7dc5fcSCédric Le Goater } 366060c6823bSCédric Le Goater 366160c6823bSCédric Le Goater trace_spapr_irq_alloc_block(first, num, lsi, align); 366260c6823bSCédric Le Goater 366360c6823bSCédric Le Goater return first; 366460c6823bSCédric Le Goater } 366560c6823bSCédric Le Goater 366660c6823bSCédric Le Goater void spapr_irq_free(sPAPRMachineState *spapr, int irq, int num) 366760c6823bSCédric Le Goater { 366860c6823bSCédric Le Goater ICSState *ics = spapr->ics; 366960c6823bSCédric Le Goater int srcno = irq - ics->offset; 367060c6823bSCédric Le Goater int i; 367160c6823bSCédric Le Goater 367260c6823bSCédric Le Goater if (ics_valid_irq(ics, irq)) { 367360c6823bSCédric Le Goater trace_spapr_irq_free(0, irq, num); 367460c6823bSCédric Le Goater for (i = srcno; i < srcno + num; ++i) { 367560c6823bSCédric Le Goater if (ICS_IRQ_FREE(ics, i)) { 367660c6823bSCédric Le Goater trace_spapr_irq_free_warn(0, i + ics->offset); 367760c6823bSCédric Le Goater } 367860c6823bSCédric Le Goater memset(&ics->irqs[i], 0, sizeof(ICSIRQState)); 367960c6823bSCédric Le Goater } 368060c6823bSCédric Le Goater } 368160c6823bSCédric Le Goater } 368260c6823bSCédric Le Goater 3683*77183755SCédric Le Goater qemu_irq spapr_qirq(sPAPRMachineState *spapr, int irq) 3684*77183755SCédric Le Goater { 3685*77183755SCédric Le Goater ICSState *ics = spapr->ics; 3686*77183755SCédric Le Goater 3687*77183755SCédric Le Goater if (ics_valid_irq(ics, irq)) { 3688*77183755SCédric Le Goater return ics->qirqs[irq - ics->offset]; 3689*77183755SCédric Le Goater } 3690*77183755SCédric Le Goater 3691*77183755SCédric Le Goater return NULL; 3692*77183755SCédric Le Goater } 3693*77183755SCédric Le Goater 36946449da45SCédric Le Goater static void spapr_pic_print_info(InterruptStatsProvider *obj, 36956449da45SCédric Le Goater Monitor *mon) 36966449da45SCédric Le Goater { 36976449da45SCédric Le Goater sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 36985bc8d26dSCédric Le Goater CPUState *cs; 36996449da45SCédric Le Goater 37005bc8d26dSCédric Le Goater CPU_FOREACH(cs) { 37015bc8d26dSCédric Le Goater PowerPCCPU *cpu = POWERPC_CPU(cs); 37025bc8d26dSCédric Le Goater 37035bc8d26dSCédric Le Goater icp_pic_print_info(ICP(cpu->intc), mon); 37046449da45SCédric Le Goater } 37056449da45SCédric Le Goater 37066449da45SCédric Le Goater ics_pic_print_info(spapr->ics, mon); 37076449da45SCédric Le Goater } 37086449da45SCédric Le Goater 37092e886fb3SSam Bobroff int spapr_vcpu_id(PowerPCCPU *cpu) 37102e886fb3SSam Bobroff { 37112e886fb3SSam Bobroff CPUState *cs = CPU(cpu); 37122e886fb3SSam Bobroff 37132e886fb3SSam Bobroff if (kvm_enabled()) { 37142e886fb3SSam Bobroff return kvm_arch_vcpu_id(cs); 37152e886fb3SSam Bobroff } else { 37162e886fb3SSam Bobroff return cs->cpu_index; 37172e886fb3SSam Bobroff } 37182e886fb3SSam Bobroff } 37192e886fb3SSam Bobroff 37202e886fb3SSam Bobroff PowerPCCPU *spapr_find_cpu(int vcpu_id) 37212e886fb3SSam Bobroff { 37222e886fb3SSam Bobroff CPUState *cs; 37232e886fb3SSam Bobroff 37242e886fb3SSam Bobroff CPU_FOREACH(cs) { 37252e886fb3SSam Bobroff PowerPCCPU *cpu = POWERPC_CPU(cs); 37262e886fb3SSam Bobroff 37272e886fb3SSam Bobroff if (spapr_vcpu_id(cpu) == vcpu_id) { 37282e886fb3SSam Bobroff return cpu; 37292e886fb3SSam Bobroff } 37302e886fb3SSam Bobroff } 37312e886fb3SSam Bobroff 37322e886fb3SSam Bobroff return NULL; 37332e886fb3SSam Bobroff } 37342e886fb3SSam Bobroff 373529ee3247SAlexey Kardashevskiy static void spapr_machine_class_init(ObjectClass *oc, void *data) 373653018216SPaolo Bonzini { 373729ee3247SAlexey Kardashevskiy MachineClass *mc = MACHINE_CLASS(oc); 3738224245bfSDavid Gibson sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(oc); 373971461b0fSAlexey Kardashevskiy FWPathProviderClass *fwc = FW_PATH_PROVIDER_CLASS(oc); 374034316482SAlexey Kardashevskiy NMIClass *nc = NMI_CLASS(oc); 3741c20d332aSBharata B Rao HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(oc); 37421d1be34dSDavid Gibson PPCVirtualHypervisorClass *vhc = PPC_VIRTUAL_HYPERVISOR_CLASS(oc); 37437844e12bSCédric Le Goater XICSFabricClass *xic = XICS_FABRIC_CLASS(oc); 37446449da45SCédric Le Goater InterruptStatsProviderClass *ispc = INTERRUPT_STATS_PROVIDER_CLASS(oc); 374529ee3247SAlexey Kardashevskiy 37460eb9054cSDavid Gibson mc->desc = "pSeries Logical Partition (PAPR compliant)"; 3747fc9f38c3SDavid Gibson 3748fc9f38c3SDavid Gibson /* 3749fc9f38c3SDavid Gibson * We set up the default / latest behaviour here. The class_init 3750fc9f38c3SDavid Gibson * functions for the specific versioned machine types can override 3751fc9f38c3SDavid Gibson * these details for backwards compatibility 3752fc9f38c3SDavid Gibson */ 3753958db90cSMarcel Apfelbaum mc->init = ppc_spapr_init; 3754958db90cSMarcel Apfelbaum mc->reset = ppc_spapr_reset; 3755958db90cSMarcel Apfelbaum mc->block_default_type = IF_SCSI; 37566244bb7eSGreg Kurz mc->max_cpus = 1024; 3757958db90cSMarcel Apfelbaum mc->no_parallel = 1; 37585b2128d2SAlexander Graf mc->default_boot_order = ""; 3759a34944feSNikunj A Dadhania mc->default_ram_size = 512 * M_BYTE; 3760958db90cSMarcel Apfelbaum mc->kvm_type = spapr_kvm_type; 37619e3f9733SAlexander Graf mc->has_dynamic_sysbus = true; 3762e4024630SLaurent Vivier mc->pci_allow_0_address = true; 37637ebaf795SBharata B Rao mc->get_hotplug_handler = spapr_get_hotplug_handler; 376494a94e4cSBharata B Rao hc->pre_plug = spapr_machine_device_pre_plug; 3765c20d332aSBharata B Rao hc->plug = spapr_machine_device_plug; 3766ea089eebSIgor Mammedov mc->cpu_index_to_instance_props = spapr_cpu_index_to_props; 376779e07936SIgor Mammedov mc->get_default_cpu_node_id = spapr_get_default_cpu_node_id; 3768535455fdSIgor Mammedov mc->possible_cpu_arch_ids = spapr_possible_cpu_arch_ids; 3769cf632463SBharata B Rao hc->unplug_request = spapr_machine_device_unplug_request; 377000b4fbe2SMarcel Apfelbaum 3771fc9f38c3SDavid Gibson smc->dr_lmb_enabled = true; 37722e9c10ebSIgor Mammedov mc->default_cpu_type = POWERPC_CPU_TYPE_NAME("power8_v2.0"); 3773c5514d0eSIgor Mammedov mc->has_hotpluggable_cpus = true; 377452b81ab5SDavid Gibson smc->resize_hpt_default = SPAPR_RESIZE_HPT_ENABLED; 377571461b0fSAlexey Kardashevskiy fwc->get_dev_path = spapr_get_fw_dev_path; 377634316482SAlexey Kardashevskiy nc->nmi_monitor_handler = spapr_nmi; 37776737d9adSDavid Gibson smc->phb_placement = spapr_phb_placement; 37781d1be34dSDavid Gibson vhc->hypercall = emulate_spapr_hypercall; 3779e57ca75cSDavid Gibson vhc->hpt_mask = spapr_hpt_mask; 3780e57ca75cSDavid Gibson vhc->map_hptes = spapr_map_hptes; 3781e57ca75cSDavid Gibson vhc->unmap_hptes = spapr_unmap_hptes; 3782e57ca75cSDavid Gibson vhc->store_hpte = spapr_store_hpte; 37839861bb3eSSuraj Jitindar Singh vhc->get_patbe = spapr_get_patbe; 37841ec26c75SGreg Kurz vhc->encode_hpt_for_kvm_pr = spapr_encode_hpt_for_kvm_pr; 37857844e12bSCédric Le Goater xic->ics_get = spapr_ics_get; 37867844e12bSCédric Le Goater xic->ics_resend = spapr_ics_resend; 3787b2fc59aaSCédric Le Goater xic->icp_get = spapr_icp_get; 37886449da45SCédric Le Goater ispc->print_info = spapr_pic_print_info; 378955641213SLaurent Vivier /* Force NUMA node memory size to be a multiple of 379055641213SLaurent Vivier * SPAPR_MEMORY_BLOCK_SIZE (256M) since that's the granularity 379155641213SLaurent Vivier * in which LMBs are represented and hot-added 379255641213SLaurent Vivier */ 379355641213SLaurent Vivier mc->numa_mem_align_shift = 28; 379453018216SPaolo Bonzini } 379553018216SPaolo Bonzini 379629ee3247SAlexey Kardashevskiy static const TypeInfo spapr_machine_info = { 379729ee3247SAlexey Kardashevskiy .name = TYPE_SPAPR_MACHINE, 379829ee3247SAlexey Kardashevskiy .parent = TYPE_MACHINE, 37994aee7362SDavid Gibson .abstract = true, 38006ca1502eSAlexey Kardashevskiy .instance_size = sizeof(sPAPRMachineState), 380123825581SEduardo Habkost .instance_init = spapr_machine_initfn, 380287bbdd9cSDavid Gibson .instance_finalize = spapr_machine_finalizefn, 3803183930c0SDavid Gibson .class_size = sizeof(sPAPRMachineClass), 380429ee3247SAlexey Kardashevskiy .class_init = spapr_machine_class_init, 380571461b0fSAlexey Kardashevskiy .interfaces = (InterfaceInfo[]) { 380671461b0fSAlexey Kardashevskiy { TYPE_FW_PATH_PROVIDER }, 380734316482SAlexey Kardashevskiy { TYPE_NMI }, 3808c20d332aSBharata B Rao { TYPE_HOTPLUG_HANDLER }, 38091d1be34dSDavid Gibson { TYPE_PPC_VIRTUAL_HYPERVISOR }, 38107844e12bSCédric Le Goater { TYPE_XICS_FABRIC }, 38116449da45SCédric Le Goater { TYPE_INTERRUPT_STATS_PROVIDER }, 381271461b0fSAlexey Kardashevskiy { } 381371461b0fSAlexey Kardashevskiy }, 381429ee3247SAlexey Kardashevskiy }; 381529ee3247SAlexey Kardashevskiy 3816fccbc785SDavid Gibson #define DEFINE_SPAPR_MACHINE(suffix, verstr, latest) \ 38175013c547SDavid Gibson static void spapr_machine_##suffix##_class_init(ObjectClass *oc, \ 38185013c547SDavid Gibson void *data) \ 38195013c547SDavid Gibson { \ 38205013c547SDavid Gibson MachineClass *mc = MACHINE_CLASS(oc); \ 38215013c547SDavid Gibson spapr_machine_##suffix##_class_options(mc); \ 3822fccbc785SDavid Gibson if (latest) { \ 3823fccbc785SDavid Gibson mc->alias = "pseries"; \ 3824fccbc785SDavid Gibson mc->is_default = 1; \ 3825fccbc785SDavid Gibson } \ 38265013c547SDavid Gibson } \ 38275013c547SDavid Gibson static void spapr_machine_##suffix##_instance_init(Object *obj) \ 38285013c547SDavid Gibson { \ 38295013c547SDavid Gibson MachineState *machine = MACHINE(obj); \ 38305013c547SDavid Gibson spapr_machine_##suffix##_instance_options(machine); \ 38315013c547SDavid Gibson } \ 38325013c547SDavid Gibson static const TypeInfo spapr_machine_##suffix##_info = { \ 38335013c547SDavid Gibson .name = MACHINE_TYPE_NAME("pseries-" verstr), \ 38345013c547SDavid Gibson .parent = TYPE_SPAPR_MACHINE, \ 38355013c547SDavid Gibson .class_init = spapr_machine_##suffix##_class_init, \ 38365013c547SDavid Gibson .instance_init = spapr_machine_##suffix##_instance_init, \ 38375013c547SDavid Gibson }; \ 38385013c547SDavid Gibson static void spapr_machine_register_##suffix(void) \ 38395013c547SDavid Gibson { \ 38405013c547SDavid Gibson type_register(&spapr_machine_##suffix##_info); \ 38415013c547SDavid Gibson } \ 38420e6aac87SEduardo Habkost type_init(spapr_machine_register_##suffix) 38435013c547SDavid Gibson 38441c5f29bbSDavid Gibson /* 38452b615412SDavid Gibson * pseries-2.12 3846e2676b16SGreg Kurz */ 38472b615412SDavid Gibson static void spapr_machine_2_12_instance_options(MachineState *machine) 3848e2676b16SGreg Kurz { 3849e2676b16SGreg Kurz } 3850e2676b16SGreg Kurz 38512b615412SDavid Gibson static void spapr_machine_2_12_class_options(MachineClass *mc) 3852e2676b16SGreg Kurz { 3853e2676b16SGreg Kurz /* Defaults for the latest behaviour inherited from the base class */ 3854e2676b16SGreg Kurz } 3855e2676b16SGreg Kurz 38562b615412SDavid Gibson DEFINE_SPAPR_MACHINE(2_12, "2.12", true); 38572b615412SDavid Gibson 38582b615412SDavid Gibson /* 38592b615412SDavid Gibson * pseries-2.11 38602b615412SDavid Gibson */ 38612b615412SDavid Gibson #define SPAPR_COMPAT_2_11 \ 38622b615412SDavid Gibson HW_COMPAT_2_11 38632b615412SDavid Gibson 38642b615412SDavid Gibson static void spapr_machine_2_11_instance_options(MachineState *machine) 38652b615412SDavid Gibson { 38662b615412SDavid Gibson spapr_machine_2_12_instance_options(machine); 38672b615412SDavid Gibson } 38682b615412SDavid Gibson 38692b615412SDavid Gibson static void spapr_machine_2_11_class_options(MachineClass *mc) 38702b615412SDavid Gibson { 38712b615412SDavid Gibson spapr_machine_2_12_class_options(mc); 38722b615412SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_11); 38732b615412SDavid Gibson } 38742b615412SDavid Gibson 38752b615412SDavid Gibson DEFINE_SPAPR_MACHINE(2_11, "2.11", false); 3876e2676b16SGreg Kurz 3877e2676b16SGreg Kurz /* 38783fa14fbeSDavid Gibson * pseries-2.10 3879db800b21SDavid Gibson */ 3880e2676b16SGreg Kurz #define SPAPR_COMPAT_2_10 \ 38812b615412SDavid Gibson HW_COMPAT_2_10 3882e2676b16SGreg Kurz 38833fa14fbeSDavid Gibson static void spapr_machine_2_10_instance_options(MachineState *machine) 3884db800b21SDavid Gibson { 38852b615412SDavid Gibson spapr_machine_2_11_instance_options(machine); 3886db800b21SDavid Gibson } 3887db800b21SDavid Gibson 38883fa14fbeSDavid Gibson static void spapr_machine_2_10_class_options(MachineClass *mc) 3889db800b21SDavid Gibson { 3890e2676b16SGreg Kurz spapr_machine_2_11_class_options(mc); 3891e2676b16SGreg Kurz SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_10); 3892db800b21SDavid Gibson } 3893db800b21SDavid Gibson 3894e2676b16SGreg Kurz DEFINE_SPAPR_MACHINE(2_10, "2.10", false); 38953fa14fbeSDavid Gibson 38963fa14fbeSDavid Gibson /* 38973fa14fbeSDavid Gibson * pseries-2.9 38983fa14fbeSDavid Gibson */ 38993fa14fbeSDavid Gibson #define SPAPR_COMPAT_2_9 \ 3900d5fc133eSDavid Gibson HW_COMPAT_2_9 \ 3901d5fc133eSDavid Gibson { \ 3902d5fc133eSDavid Gibson .driver = TYPE_POWERPC_CPU, \ 3903d5fc133eSDavid Gibson .property = "pre-2.10-migration", \ 3904d5fc133eSDavid Gibson .value = "on", \ 3905d5fc133eSDavid Gibson }, \ 39063fa14fbeSDavid Gibson 39073fa14fbeSDavid Gibson static void spapr_machine_2_9_instance_options(MachineState *machine) 39083fa14fbeSDavid Gibson { 39093fa14fbeSDavid Gibson spapr_machine_2_10_instance_options(machine); 39103fa14fbeSDavid Gibson } 39113fa14fbeSDavid Gibson 39123fa14fbeSDavid Gibson static void spapr_machine_2_9_class_options(MachineClass *mc) 39133fa14fbeSDavid Gibson { 391446f7afa3SGreg Kurz sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); 391546f7afa3SGreg Kurz 39163fa14fbeSDavid Gibson spapr_machine_2_10_class_options(mc); 39173fa14fbeSDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_9); 39183bfe5716SLaurent Vivier mc->numa_auto_assign_ram = numa_legacy_auto_assign_ram; 391946f7afa3SGreg Kurz smc->pre_2_10_has_unused_icps = true; 392052b81ab5SDavid Gibson smc->resize_hpt_default = SPAPR_RESIZE_HPT_DISABLED; 39213fa14fbeSDavid Gibson } 39223fa14fbeSDavid Gibson 39233fa14fbeSDavid Gibson DEFINE_SPAPR_MACHINE(2_9, "2.9", false); 3924fa325e6cSDavid Gibson 3925fa325e6cSDavid Gibson /* 3926fa325e6cSDavid Gibson * pseries-2.8 3927fa325e6cSDavid Gibson */ 3928fa325e6cSDavid Gibson #define SPAPR_COMPAT_2_8 \ 392982516263SDavid Gibson HW_COMPAT_2_8 \ 393082516263SDavid Gibson { \ 393182516263SDavid Gibson .driver = TYPE_SPAPR_PCI_HOST_BRIDGE, \ 393282516263SDavid Gibson .property = "pcie-extended-configuration-space", \ 393382516263SDavid Gibson .value = "off", \ 393482516263SDavid Gibson }, 3935fa325e6cSDavid Gibson 3936fa325e6cSDavid Gibson static void spapr_machine_2_8_instance_options(MachineState *machine) 3937fa325e6cSDavid Gibson { 3938fa325e6cSDavid Gibson spapr_machine_2_9_instance_options(machine); 3939fa325e6cSDavid Gibson } 3940fa325e6cSDavid Gibson 3941fa325e6cSDavid Gibson static void spapr_machine_2_8_class_options(MachineClass *mc) 3942fa325e6cSDavid Gibson { 3943fa325e6cSDavid Gibson spapr_machine_2_9_class_options(mc); 3944fa325e6cSDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_8); 394555641213SLaurent Vivier mc->numa_mem_align_shift = 23; 3946fa325e6cSDavid Gibson } 3947fa325e6cSDavid Gibson 3948fa325e6cSDavid Gibson DEFINE_SPAPR_MACHINE(2_8, "2.8", false); 3949db800b21SDavid Gibson 3950db800b21SDavid Gibson /* 39511ea1eefcSBharata B Rao * pseries-2.7 39521ea1eefcSBharata B Rao */ 3953db800b21SDavid Gibson #define SPAPR_COMPAT_2_7 \ 3954db800b21SDavid Gibson HW_COMPAT_2_7 \ 3955357d1e3bSDavid Gibson { \ 3956357d1e3bSDavid Gibson .driver = TYPE_SPAPR_PCI_HOST_BRIDGE, \ 3957357d1e3bSDavid Gibson .property = "mem_win_size", \ 3958357d1e3bSDavid Gibson .value = stringify(SPAPR_PCI_2_7_MMIO_WIN_SIZE),\ 3959357d1e3bSDavid Gibson }, \ 3960357d1e3bSDavid Gibson { \ 3961357d1e3bSDavid Gibson .driver = TYPE_SPAPR_PCI_HOST_BRIDGE, \ 3962357d1e3bSDavid Gibson .property = "mem64_win_size", \ 3963357d1e3bSDavid Gibson .value = "0", \ 3964146c11f1SDavid Gibson }, \ 3965146c11f1SDavid Gibson { \ 3966146c11f1SDavid Gibson .driver = TYPE_POWERPC_CPU, \ 3967146c11f1SDavid Gibson .property = "pre-2.8-migration", \ 3968146c11f1SDavid Gibson .value = "on", \ 39695c4537bdSDavid Gibson }, \ 39705c4537bdSDavid Gibson { \ 39715c4537bdSDavid Gibson .driver = TYPE_SPAPR_PCI_HOST_BRIDGE, \ 39725c4537bdSDavid Gibson .property = "pre-2.8-migration", \ 39735c4537bdSDavid Gibson .value = "on", \ 3974357d1e3bSDavid Gibson }, 3975357d1e3bSDavid Gibson 3976357d1e3bSDavid Gibson static void phb_placement_2_7(sPAPRMachineState *spapr, uint32_t index, 3977357d1e3bSDavid Gibson uint64_t *buid, hwaddr *pio, 3978357d1e3bSDavid Gibson hwaddr *mmio32, hwaddr *mmio64, 3979357d1e3bSDavid Gibson unsigned n_dma, uint32_t *liobns, Error **errp) 3980357d1e3bSDavid Gibson { 3981357d1e3bSDavid Gibson /* Legacy PHB placement for pseries-2.7 and earlier machine types */ 3982357d1e3bSDavid Gibson const uint64_t base_buid = 0x800000020000000ULL; 3983357d1e3bSDavid Gibson const hwaddr phb_spacing = 0x1000000000ULL; /* 64 GiB */ 3984357d1e3bSDavid Gibson const hwaddr mmio_offset = 0xa0000000; /* 2 GiB + 512 MiB */ 3985357d1e3bSDavid Gibson const hwaddr pio_offset = 0x80000000; /* 2 GiB */ 3986357d1e3bSDavid Gibson const uint32_t max_index = 255; 3987357d1e3bSDavid Gibson const hwaddr phb0_alignment = 0x10000000000ULL; /* 1 TiB */ 3988357d1e3bSDavid Gibson 3989357d1e3bSDavid Gibson uint64_t ram_top = MACHINE(spapr)->ram_size; 3990357d1e3bSDavid Gibson hwaddr phb0_base, phb_base; 3991357d1e3bSDavid Gibson int i; 3992357d1e3bSDavid Gibson 3993357d1e3bSDavid Gibson /* Do we have hotpluggable memory? */ 3994357d1e3bSDavid Gibson if (MACHINE(spapr)->maxram_size > ram_top) { 3995357d1e3bSDavid Gibson /* Can't just use maxram_size, because there may be an 3996357d1e3bSDavid Gibson * alignment gap between normal and hotpluggable memory 3997357d1e3bSDavid Gibson * regions */ 3998357d1e3bSDavid Gibson ram_top = spapr->hotplug_memory.base + 3999357d1e3bSDavid Gibson memory_region_size(&spapr->hotplug_memory.mr); 4000357d1e3bSDavid Gibson } 4001357d1e3bSDavid Gibson 4002357d1e3bSDavid Gibson phb0_base = QEMU_ALIGN_UP(ram_top, phb0_alignment); 4003357d1e3bSDavid Gibson 4004357d1e3bSDavid Gibson if (index > max_index) { 4005357d1e3bSDavid Gibson error_setg(errp, "\"index\" for PAPR PHB is too large (max %u)", 4006357d1e3bSDavid Gibson max_index); 4007357d1e3bSDavid Gibson return; 4008357d1e3bSDavid Gibson } 4009357d1e3bSDavid Gibson 4010357d1e3bSDavid Gibson *buid = base_buid + index; 4011357d1e3bSDavid Gibson for (i = 0; i < n_dma; ++i) { 4012357d1e3bSDavid Gibson liobns[i] = SPAPR_PCI_LIOBN(index, i); 4013357d1e3bSDavid Gibson } 4014357d1e3bSDavid Gibson 4015357d1e3bSDavid Gibson phb_base = phb0_base + index * phb_spacing; 4016357d1e3bSDavid Gibson *pio = phb_base + pio_offset; 4017357d1e3bSDavid Gibson *mmio32 = phb_base + mmio_offset; 4018357d1e3bSDavid Gibson /* 4019357d1e3bSDavid Gibson * We don't set the 64-bit MMIO window, relying on the PHB's 4020357d1e3bSDavid Gibson * fallback behaviour of automatically splitting a large "32-bit" 4021357d1e3bSDavid Gibson * window into contiguous 32-bit and 64-bit windows 4022357d1e3bSDavid Gibson */ 4023357d1e3bSDavid Gibson } 4024db800b21SDavid Gibson 40251ea1eefcSBharata B Rao static void spapr_machine_2_7_instance_options(MachineState *machine) 40261ea1eefcSBharata B Rao { 4027f6229214SMichael Roth sPAPRMachineState *spapr = SPAPR_MACHINE(machine); 4028f6229214SMichael Roth 4029672de881SMichael Roth spapr_machine_2_8_instance_options(machine); 4030f6229214SMichael Roth spapr->use_hotplug_event_source = false; 40311ea1eefcSBharata B Rao } 40321ea1eefcSBharata B Rao 40331ea1eefcSBharata B Rao static void spapr_machine_2_7_class_options(MachineClass *mc) 40341ea1eefcSBharata B Rao { 40353daa4a9fSThomas Huth sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); 40363daa4a9fSThomas Huth 4037db800b21SDavid Gibson spapr_machine_2_8_class_options(mc); 40382e9c10ebSIgor Mammedov mc->default_cpu_type = POWERPC_CPU_TYPE_NAME("power7_v2.3"); 4039db800b21SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_7); 4040357d1e3bSDavid Gibson smc->phb_placement = phb_placement_2_7; 40411ea1eefcSBharata B Rao } 40421ea1eefcSBharata B Rao 4043db800b21SDavid Gibson DEFINE_SPAPR_MACHINE(2_7, "2.7", false); 40441ea1eefcSBharata B Rao 40451ea1eefcSBharata B Rao /* 40464b23699cSDavid Gibson * pseries-2.6 40474b23699cSDavid Gibson */ 40481ea1eefcSBharata B Rao #define SPAPR_COMPAT_2_6 \ 4049ae4de14cSAlexey Kardashevskiy HW_COMPAT_2_6 \ 4050ae4de14cSAlexey Kardashevskiy { \ 4051ae4de14cSAlexey Kardashevskiy .driver = TYPE_SPAPR_PCI_HOST_BRIDGE,\ 4052ae4de14cSAlexey Kardashevskiy .property = "ddw",\ 4053ae4de14cSAlexey Kardashevskiy .value = stringify(off),\ 4054ae4de14cSAlexey Kardashevskiy }, 40551ea1eefcSBharata B Rao 40564b23699cSDavid Gibson static void spapr_machine_2_6_instance_options(MachineState *machine) 40574b23699cSDavid Gibson { 4058672de881SMichael Roth spapr_machine_2_7_instance_options(machine); 40594b23699cSDavid Gibson } 40604b23699cSDavid Gibson 40614b23699cSDavid Gibson static void spapr_machine_2_6_class_options(MachineClass *mc) 40624b23699cSDavid Gibson { 40631ea1eefcSBharata B Rao spapr_machine_2_7_class_options(mc); 4064c5514d0eSIgor Mammedov mc->has_hotpluggable_cpus = false; 40651ea1eefcSBharata B Rao SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_6); 40664b23699cSDavid Gibson } 40674b23699cSDavid Gibson 40681ea1eefcSBharata B Rao DEFINE_SPAPR_MACHINE(2_6, "2.6", false); 40694b23699cSDavid Gibson 40704b23699cSDavid Gibson /* 40711c5f29bbSDavid Gibson * pseries-2.5 40721c5f29bbSDavid Gibson */ 40734b23699cSDavid Gibson #define SPAPR_COMPAT_2_5 \ 407457c522f4SThomas Huth HW_COMPAT_2_5 \ 407557c522f4SThomas Huth { \ 407657c522f4SThomas Huth .driver = "spapr-vlan", \ 407757c522f4SThomas Huth .property = "use-rx-buffer-pools", \ 407857c522f4SThomas Huth .value = "off", \ 407957c522f4SThomas Huth }, 40804b23699cSDavid Gibson 40815013c547SDavid Gibson static void spapr_machine_2_5_instance_options(MachineState *machine) 40821c5f29bbSDavid Gibson { 4083672de881SMichael Roth spapr_machine_2_6_instance_options(machine); 40845013c547SDavid Gibson } 40855013c547SDavid Gibson 40865013c547SDavid Gibson static void spapr_machine_2_5_class_options(MachineClass *mc) 40875013c547SDavid Gibson { 408857040d45SThomas Huth sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); 408957040d45SThomas Huth 40904b23699cSDavid Gibson spapr_machine_2_6_class_options(mc); 409157040d45SThomas Huth smc->use_ohci_by_default = true; 40924b23699cSDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_5); 40931c5f29bbSDavid Gibson } 40941c5f29bbSDavid Gibson 40954b23699cSDavid Gibson DEFINE_SPAPR_MACHINE(2_5, "2.5", false); 40961c5f29bbSDavid Gibson 40971c5f29bbSDavid Gibson /* 40981c5f29bbSDavid Gibson * pseries-2.4 40991c5f29bbSDavid Gibson */ 410080fd50f9SCornelia Huck #define SPAPR_COMPAT_2_4 \ 410180fd50f9SCornelia Huck HW_COMPAT_2_4 410280fd50f9SCornelia Huck 41035013c547SDavid Gibson static void spapr_machine_2_4_instance_options(MachineState *machine) 41041c5f29bbSDavid Gibson { 41055013c547SDavid Gibson spapr_machine_2_5_instance_options(machine); 41065013c547SDavid Gibson } 41071c5f29bbSDavid Gibson 41085013c547SDavid Gibson static void spapr_machine_2_4_class_options(MachineClass *mc) 41095013c547SDavid Gibson { 4110fc9f38c3SDavid Gibson sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); 4111fc9f38c3SDavid Gibson 4112fc9f38c3SDavid Gibson spapr_machine_2_5_class_options(mc); 4113fc9f38c3SDavid Gibson smc->dr_lmb_enabled = false; 4114f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_4); 41151c5f29bbSDavid Gibson } 41161c5f29bbSDavid Gibson 4117fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_4, "2.4", false); 41181c5f29bbSDavid Gibson 41191c5f29bbSDavid Gibson /* 41201c5f29bbSDavid Gibson * pseries-2.3 41211c5f29bbSDavid Gibson */ 412238ff32c6SEduardo Habkost #define SPAPR_COMPAT_2_3 \ 41237619c7b0SMichael Roth HW_COMPAT_2_3 \ 41247619c7b0SMichael Roth {\ 41257619c7b0SMichael Roth .driver = "spapr-pci-host-bridge",\ 41267619c7b0SMichael Roth .property = "dynamic-reconfiguration",\ 41277619c7b0SMichael Roth .value = "off",\ 41287619c7b0SMichael Roth }, 412938ff32c6SEduardo Habkost 41305013c547SDavid Gibson static void spapr_machine_2_3_instance_options(MachineState *machine) 41311c5f29bbSDavid Gibson { 41325013c547SDavid Gibson spapr_machine_2_4_instance_options(machine); 41331c5f29bbSDavid Gibson } 41341c5f29bbSDavid Gibson 41355013c547SDavid Gibson static void spapr_machine_2_3_class_options(MachineClass *mc) 41361c5f29bbSDavid Gibson { 4137fc9f38c3SDavid Gibson spapr_machine_2_4_class_options(mc); 4138f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_3); 41391c5f29bbSDavid Gibson } 4140fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_3, "2.3", false); 41411c5f29bbSDavid Gibson 41421c5f29bbSDavid Gibson /* 41431c5f29bbSDavid Gibson * pseries-2.2 41441c5f29bbSDavid Gibson */ 41451c5f29bbSDavid Gibson 4146b194df47SAlexey Kardashevskiy #define SPAPR_COMPAT_2_2 \ 41474dfd8eaaSEduardo Habkost HW_COMPAT_2_2 \ 4148b194df47SAlexey Kardashevskiy {\ 4149b194df47SAlexey Kardashevskiy .driver = TYPE_SPAPR_PCI_HOST_BRIDGE,\ 4150b194df47SAlexey Kardashevskiy .property = "mem_win_size",\ 4151b194df47SAlexey Kardashevskiy .value = "0x20000000",\ 4152dd754bafSEduardo Habkost }, 4153b194df47SAlexey Kardashevskiy 41545013c547SDavid Gibson static void spapr_machine_2_2_instance_options(MachineState *machine) 4155b0e966d0SJason Wang { 41565013c547SDavid Gibson spapr_machine_2_3_instance_options(machine); 4157cba0e779SGreg Kurz machine->suppress_vmdesc = true; 4158b0e966d0SJason Wang } 4159b0e966d0SJason Wang 41605013c547SDavid Gibson static void spapr_machine_2_2_class_options(MachineClass *mc) 4161b0e966d0SJason Wang { 4162fc9f38c3SDavid Gibson spapr_machine_2_3_class_options(mc); 4163f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_2); 41641c5f29bbSDavid Gibson } 4165fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_2, "2.2", false); 41661c5f29bbSDavid Gibson 41671c5f29bbSDavid Gibson /* 41681c5f29bbSDavid Gibson * pseries-2.1 41691c5f29bbSDavid Gibson */ 41701c5f29bbSDavid Gibson #define SPAPR_COMPAT_2_1 \ 41711c5f29bbSDavid Gibson HW_COMPAT_2_1 41721c5f29bbSDavid Gibson 41735013c547SDavid Gibson static void spapr_machine_2_1_instance_options(MachineState *machine) 41741c5f29bbSDavid Gibson { 41755013c547SDavid Gibson spapr_machine_2_2_instance_options(machine); 41761c5f29bbSDavid Gibson } 41771c5f29bbSDavid Gibson 41785013c547SDavid Gibson static void spapr_machine_2_1_class_options(MachineClass *mc) 4179b0e966d0SJason Wang { 4180fc9f38c3SDavid Gibson spapr_machine_2_2_class_options(mc); 4181f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_1); 41826026db45SAlexey Kardashevskiy } 4183fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_1, "2.1", false); 41846026db45SAlexey Kardashevskiy 418529ee3247SAlexey Kardashevskiy static void spapr_machine_register_types(void) 418629ee3247SAlexey Kardashevskiy { 418729ee3247SAlexey Kardashevskiy type_register_static(&spapr_machine_info); 418829ee3247SAlexey Kardashevskiy } 418929ee3247SAlexey Kardashevskiy 419029ee3247SAlexey Kardashevskiy type_init(spapr_machine_register_types) 4191