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" 7768a27b20SMichael S. Tsirkin 7853018216SPaolo Bonzini #include <libfdt.h> 7953018216SPaolo Bonzini 8053018216SPaolo Bonzini /* SLOF memory layout: 8153018216SPaolo Bonzini * 8253018216SPaolo Bonzini * SLOF raw image loaded at 0, copies its romfs right below the flat 8353018216SPaolo Bonzini * device-tree, then position SLOF itself 31M below that 8453018216SPaolo Bonzini * 8553018216SPaolo Bonzini * So we set FW_OVERHEAD to 40MB which should account for all of that 8653018216SPaolo Bonzini * and more 8753018216SPaolo Bonzini * 8853018216SPaolo Bonzini * We load our kernel at 4M, leaving space for SLOF initial image 8953018216SPaolo Bonzini */ 9038b02bd8SAlexey Kardashevskiy #define FDT_MAX_SIZE 0x100000 9153018216SPaolo Bonzini #define RTAS_MAX_SIZE 0x10000 92b7d1f77aSBenjamin Herrenschmidt #define RTAS_MAX_ADDR 0x80000000 /* RTAS must stay below that */ 9353018216SPaolo Bonzini #define FW_MAX_SIZE 0x400000 9453018216SPaolo Bonzini #define FW_FILE_NAME "slof.bin" 9553018216SPaolo Bonzini #define FW_OVERHEAD 0x2800000 9653018216SPaolo Bonzini #define KERNEL_LOAD_ADDR FW_MAX_SIZE 9753018216SPaolo Bonzini 9853018216SPaolo Bonzini #define MIN_RMA_SLOF 128UL 9953018216SPaolo Bonzini 10053018216SPaolo Bonzini #define PHANDLE_XICP 0x00001111 10153018216SPaolo Bonzini 10271cd4dacSCédric Le Goater static ICSState *spapr_ics_create(sPAPRMachineState *spapr, 10371cd4dacSCédric Le Goater const char *type_ics, 104817bb6a4SCédric Le Goater int nr_irqs, Error **errp) 105c04d6cfaSAnthony Liguori { 106175d2aa0SGreg Kurz Error *local_err = NULL; 10771cd4dacSCédric Le Goater Object *obj; 108c04d6cfaSAnthony Liguori 10971cd4dacSCédric Le Goater obj = object_new(type_ics); 110175d2aa0SGreg Kurz object_property_add_child(OBJECT(spapr), "ics", obj, &error_abort); 111ad265631SGreg Kurz object_property_add_const_link(obj, ICS_PROP_XICS, OBJECT(spapr), 112ad265631SGreg Kurz &error_abort); 113175d2aa0SGreg Kurz object_property_set_int(obj, nr_irqs, "nr-irqs", &local_err); 114175d2aa0SGreg Kurz if (local_err) { 115175d2aa0SGreg Kurz goto error; 116175d2aa0SGreg Kurz } 11771cd4dacSCédric Le Goater object_property_set_bool(obj, true, "realized", &local_err); 118175d2aa0SGreg Kurz if (local_err) { 119175d2aa0SGreg Kurz goto error; 120c04d6cfaSAnthony Liguori } 121c04d6cfaSAnthony Liguori 12271cd4dacSCédric Le Goater return ICS_SIMPLE(obj); 123175d2aa0SGreg Kurz 124175d2aa0SGreg Kurz error: 125175d2aa0SGreg Kurz error_propagate(errp, local_err); 126175d2aa0SGreg Kurz return NULL; 1275bc8d26dSCédric Le Goater } 1285bc8d26dSCédric Le Goater 12946f7afa3SGreg Kurz static bool pre_2_10_vmstate_dummy_icp_needed(void *opaque) 13046f7afa3SGreg Kurz { 13146f7afa3SGreg Kurz /* Dummy entries correspond to unused ICPState objects in older QEMUs, 13246f7afa3SGreg Kurz * and newer QEMUs don't even have them. In both cases, we don't want 13346f7afa3SGreg Kurz * to send anything on the wire. 13446f7afa3SGreg Kurz */ 13546f7afa3SGreg Kurz return false; 13646f7afa3SGreg Kurz } 13746f7afa3SGreg Kurz 13846f7afa3SGreg Kurz static const VMStateDescription pre_2_10_vmstate_dummy_icp = { 13946f7afa3SGreg Kurz .name = "icp/server", 14046f7afa3SGreg Kurz .version_id = 1, 14146f7afa3SGreg Kurz .minimum_version_id = 1, 14246f7afa3SGreg Kurz .needed = pre_2_10_vmstate_dummy_icp_needed, 14346f7afa3SGreg Kurz .fields = (VMStateField[]) { 14446f7afa3SGreg Kurz VMSTATE_UNUSED(4), /* uint32_t xirr */ 14546f7afa3SGreg Kurz VMSTATE_UNUSED(1), /* uint8_t pending_priority */ 14646f7afa3SGreg Kurz VMSTATE_UNUSED(1), /* uint8_t mfrr */ 14746f7afa3SGreg Kurz VMSTATE_END_OF_LIST() 14846f7afa3SGreg Kurz }, 14946f7afa3SGreg Kurz }; 15046f7afa3SGreg Kurz 15146f7afa3SGreg Kurz static void pre_2_10_vmstate_register_dummy_icp(int i) 15246f7afa3SGreg Kurz { 15346f7afa3SGreg Kurz vmstate_register(NULL, i, &pre_2_10_vmstate_dummy_icp, 15446f7afa3SGreg Kurz (void *)(uintptr_t) i); 15546f7afa3SGreg Kurz } 15646f7afa3SGreg Kurz 15746f7afa3SGreg Kurz static void pre_2_10_vmstate_unregister_dummy_icp(int i) 15846f7afa3SGreg Kurz { 15946f7afa3SGreg Kurz vmstate_unregister(NULL, &pre_2_10_vmstate_dummy_icp, 16046f7afa3SGreg Kurz (void *)(uintptr_t) i); 16146f7afa3SGreg Kurz } 16246f7afa3SGreg Kurz 163*72194664SGreg Kurz static int xics_max_server_number(sPAPRMachineState *spapr) 16446f7afa3SGreg Kurz { 165*72194664SGreg Kurz return DIV_ROUND_UP(max_cpus * spapr->vsmt, smp_threads); 16646f7afa3SGreg Kurz } 16746f7afa3SGreg Kurz 16871cd4dacSCédric Le Goater static void xics_system_init(MachineState *machine, int nr_irqs, Error **errp) 169c04d6cfaSAnthony Liguori { 17071cd4dacSCédric Le Goater sPAPRMachineState *spapr = SPAPR_MACHINE(machine); 17146f7afa3SGreg Kurz sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(machine); 172c04d6cfaSAnthony Liguori 17311ad93f6SDavid Gibson if (kvm_enabled()) { 1742192a930SCédric Le Goater if (machine_kernel_irqchip_allowed(machine) && 17571cd4dacSCédric Le Goater !xics_kvm_init(spapr, errp)) { 17671cd4dacSCédric Le Goater spapr->icp_type = TYPE_KVM_ICP; 1773d85885aSGreg Kurz spapr->ics = spapr_ics_create(spapr, TYPE_ICS_KVM, nr_irqs, errp); 17811ad93f6SDavid Gibson } 17971cd4dacSCédric Le Goater if (machine_kernel_irqchip_required(machine) && !spapr->ics) { 1803d85885aSGreg Kurz error_prepend(errp, "kernel_irqchip requested but unavailable: "); 1813d85885aSGreg Kurz return; 18211ad93f6SDavid Gibson } 183b83baa60SMarkus Armbruster } 18411ad93f6SDavid Gibson 18571cd4dacSCédric Le Goater if (!spapr->ics) { 186f63ebfe0SGreg Kurz xics_spapr_init(spapr); 18771cd4dacSCédric Le Goater spapr->icp_type = TYPE_ICP; 18871cd4dacSCédric Le Goater spapr->ics = spapr_ics_create(spapr, TYPE_ICS_SIMPLE, nr_irqs, errp); 1893d85885aSGreg Kurz if (!spapr->ics) { 1903d85885aSGreg Kurz return; 1913d85885aSGreg Kurz } 192c04d6cfaSAnthony Liguori } 19346f7afa3SGreg Kurz 19446f7afa3SGreg Kurz if (smc->pre_2_10_has_unused_icps) { 19546f7afa3SGreg Kurz int i; 19646f7afa3SGreg Kurz 197*72194664SGreg Kurz for (i = 0; i < xics_max_server_number(spapr); i++) { 19846f7afa3SGreg Kurz /* Dummy entries get deregistered when real ICPState objects 19946f7afa3SGreg Kurz * are registered during CPU core hotplug. 20046f7afa3SGreg Kurz */ 20146f7afa3SGreg Kurz pre_2_10_vmstate_register_dummy_icp(i); 20246f7afa3SGreg Kurz } 20346f7afa3SGreg Kurz } 204c04d6cfaSAnthony Liguori } 205c04d6cfaSAnthony Liguori 206833d4668SAlexey Kardashevskiy static int spapr_fixup_cpu_smt_dt(void *fdt, int offset, PowerPCCPU *cpu, 207833d4668SAlexey Kardashevskiy int smt_threads) 208833d4668SAlexey Kardashevskiy { 209833d4668SAlexey Kardashevskiy int i, ret = 0; 210833d4668SAlexey Kardashevskiy uint32_t servers_prop[smt_threads]; 211833d4668SAlexey Kardashevskiy uint32_t gservers_prop[smt_threads * 2]; 2122e886fb3SSam Bobroff int index = spapr_vcpu_id(cpu); 213833d4668SAlexey Kardashevskiy 214d6e166c0SDavid Gibson if (cpu->compat_pvr) { 215d6e166c0SDavid Gibson ret = fdt_setprop_cell(fdt, offset, "cpu-version", cpu->compat_pvr); 2166d9412eaSAlexey Kardashevskiy if (ret < 0) { 2176d9412eaSAlexey Kardashevskiy return ret; 2186d9412eaSAlexey Kardashevskiy } 2196d9412eaSAlexey Kardashevskiy } 2206d9412eaSAlexey Kardashevskiy 221833d4668SAlexey Kardashevskiy /* Build interrupt servers and gservers properties */ 222833d4668SAlexey Kardashevskiy for (i = 0; i < smt_threads; i++) { 223833d4668SAlexey Kardashevskiy servers_prop[i] = cpu_to_be32(index + i); 224833d4668SAlexey Kardashevskiy /* Hack, direct the group queues back to cpu 0 */ 225833d4668SAlexey Kardashevskiy gservers_prop[i*2] = cpu_to_be32(index + i); 226833d4668SAlexey Kardashevskiy gservers_prop[i*2 + 1] = 0; 227833d4668SAlexey Kardashevskiy } 228833d4668SAlexey Kardashevskiy ret = fdt_setprop(fdt, offset, "ibm,ppc-interrupt-server#s", 229833d4668SAlexey Kardashevskiy servers_prop, sizeof(servers_prop)); 230833d4668SAlexey Kardashevskiy if (ret < 0) { 231833d4668SAlexey Kardashevskiy return ret; 232833d4668SAlexey Kardashevskiy } 233833d4668SAlexey Kardashevskiy ret = fdt_setprop(fdt, offset, "ibm,ppc-interrupt-gserver#s", 234833d4668SAlexey Kardashevskiy gservers_prop, sizeof(gservers_prop)); 235833d4668SAlexey Kardashevskiy 236833d4668SAlexey Kardashevskiy return ret; 237833d4668SAlexey Kardashevskiy } 238833d4668SAlexey Kardashevskiy 23999861ecbSIgor Mammedov static int spapr_fixup_cpu_numa_dt(void *fdt, int offset, PowerPCCPU *cpu) 2400da6f3feSBharata B Rao { 2412e886fb3SSam Bobroff int index = spapr_vcpu_id(cpu); 2420da6f3feSBharata B Rao uint32_t associativity[] = {cpu_to_be32(0x5), 2430da6f3feSBharata B Rao cpu_to_be32(0x0), 2440da6f3feSBharata B Rao cpu_to_be32(0x0), 2450da6f3feSBharata B Rao cpu_to_be32(0x0), 24615f8b142SIgor Mammedov cpu_to_be32(cpu->node_id), 2470da6f3feSBharata B Rao cpu_to_be32(index)}; 2480da6f3feSBharata B Rao 2490da6f3feSBharata B Rao /* Advertise NUMA via ibm,associativity */ 25099861ecbSIgor Mammedov return fdt_setprop(fdt, offset, "ibm,associativity", associativity, 2510da6f3feSBharata B Rao sizeof(associativity)); 2520da6f3feSBharata B Rao } 2530da6f3feSBharata B Rao 25486d5771aSSam Bobroff /* Populate the "ibm,pa-features" property */ 255ee76a09fSDavid Gibson static void spapr_populate_pa_features(sPAPRMachineState *spapr, 256ee76a09fSDavid Gibson PowerPCCPU *cpu, 257ee76a09fSDavid Gibson void *fdt, int offset, 258e957f6a9SSam Bobroff bool legacy_guest) 25986d5771aSSam Bobroff { 2607abd43baSSuraj Jitindar Singh CPUPPCState *env = &cpu->env; 26186d5771aSSam Bobroff uint8_t pa_features_206[] = { 6, 0, 26286d5771aSSam Bobroff 0xf6, 0x1f, 0xc7, 0x00, 0x80, 0xc0 }; 26386d5771aSSam Bobroff uint8_t pa_features_207[] = { 24, 0, 26486d5771aSSam Bobroff 0xf6, 0x1f, 0xc7, 0xc0, 0x80, 0xf0, 26586d5771aSSam Bobroff 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 26686d5771aSSam Bobroff 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 26786d5771aSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x00, 0x00 }; 2689fb4541fSSam Bobroff uint8_t pa_features_300[] = { 66, 0, 2699fb4541fSSam Bobroff /* 0: MMU|FPU|SLB|RUN|DABR|NX, 1: fri[nzpm]|DABRX|SPRG3|SLB0|PP110 */ 2709fb4541fSSam Bobroff /* 2: VPM|DS205|PPR|DS202|DS206, 3: LSD|URG, SSO, 5: LE|CFAR|EB|LSQ */ 27186d5771aSSam Bobroff 0xf6, 0x1f, 0xc7, 0xc0, 0x80, 0xf0, /* 0 - 5 */ 2729fb4541fSSam Bobroff /* 6: DS207 */ 27386d5771aSSam Bobroff 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, /* 6 - 11 */ 2749fb4541fSSam Bobroff /* 16: Vector */ 27586d5771aSSam Bobroff 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, /* 12 - 17 */ 2769fb4541fSSam Bobroff /* 18: Vec. Scalar, 20: Vec. XOR, 22: HTM */ 2779bf502feSDavid Gibson 0x80, 0x00, 0x80, 0x00, 0x00, 0x00, /* 18 - 23 */ 2789fb4541fSSam Bobroff /* 24: Ext. Dec, 26: 64 bit ftrs, 28: PM ftrs */ 2799fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, /* 24 - 29 */ 2809fb4541fSSam Bobroff /* 30: MMR, 32: LE atomic, 34: EBB + ext EBB */ 2819fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0xC0, 0x00, /* 30 - 35 */ 2829fb4541fSSam Bobroff /* 36: SPR SO, 38: Copy/Paste, 40: Radix MMU */ 2839fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, /* 36 - 41 */ 2849fb4541fSSam Bobroff /* 42: PM, 44: PC RA, 46: SC vec'd */ 2859fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, /* 42 - 47 */ 2869fb4541fSSam Bobroff /* 48: SIMD, 50: QP BFP, 52: String */ 2879fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, /* 48 - 53 */ 2889fb4541fSSam Bobroff /* 54: DecFP, 56: DecI, 58: SHA */ 2899fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, /* 54 - 59 */ 2909fb4541fSSam Bobroff /* 60: NM atomic, 62: RNG */ 2919fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x00, 0x00, /* 60 - 65 */ 2929fb4541fSSam Bobroff }; 2937abd43baSSuraj Jitindar Singh uint8_t *pa_features = NULL; 29486d5771aSSam Bobroff size_t pa_size; 29586d5771aSSam Bobroff 2967abd43baSSuraj Jitindar Singh if (ppc_check_compat(cpu, CPU_POWERPC_LOGICAL_2_06, 0, cpu->compat_pvr)) { 29786d5771aSSam Bobroff pa_features = pa_features_206; 29886d5771aSSam Bobroff pa_size = sizeof(pa_features_206); 2997abd43baSSuraj Jitindar Singh } 3007abd43baSSuraj Jitindar Singh if (ppc_check_compat(cpu, CPU_POWERPC_LOGICAL_2_07, 0, cpu->compat_pvr)) { 30186d5771aSSam Bobroff pa_features = pa_features_207; 30286d5771aSSam Bobroff pa_size = sizeof(pa_features_207); 3037abd43baSSuraj Jitindar Singh } 3047abd43baSSuraj Jitindar Singh if (ppc_check_compat(cpu, CPU_POWERPC_LOGICAL_3_00, 0, cpu->compat_pvr)) { 30586d5771aSSam Bobroff pa_features = pa_features_300; 30686d5771aSSam Bobroff pa_size = sizeof(pa_features_300); 3077abd43baSSuraj Jitindar Singh } 3087abd43baSSuraj Jitindar Singh if (!pa_features) { 30986d5771aSSam Bobroff return; 31086d5771aSSam Bobroff } 31186d5771aSSam Bobroff 31286d5771aSSam Bobroff if (env->ci_large_pages) { 31386d5771aSSam Bobroff /* 31486d5771aSSam Bobroff * Note: we keep CI large pages off by default because a 64K capable 31586d5771aSSam Bobroff * guest provisioned with large pages might otherwise try to map a qemu 31686d5771aSSam Bobroff * framebuffer (or other kind of memory mapped PCI BAR) using 64K pages 31786d5771aSSam Bobroff * even if that qemu runs on a 4k host. 31886d5771aSSam Bobroff * We dd this bit back here if we are confident this is not an issue 31986d5771aSSam Bobroff */ 32086d5771aSSam Bobroff pa_features[3] |= 0x20; 32186d5771aSSam Bobroff } 3224e5fe368SSuraj Jitindar Singh if ((spapr_get_cap(spapr, SPAPR_CAP_HTM) != 0) && pa_size > 24) { 32386d5771aSSam Bobroff pa_features[24] |= 0x80; /* Transactional memory support */ 32486d5771aSSam Bobroff } 325e957f6a9SSam Bobroff if (legacy_guest && pa_size > 40) { 326e957f6a9SSam Bobroff /* Workaround for broken kernels that attempt (guest) radix 327e957f6a9SSam Bobroff * mode when they can't handle it, if they see the radix bit set 328e957f6a9SSam Bobroff * in pa-features. So hide it from them. */ 329e957f6a9SSam Bobroff pa_features[40 + 2] &= ~0x80; /* Radix MMU */ 330e957f6a9SSam Bobroff } 33186d5771aSSam Bobroff 33286d5771aSSam Bobroff _FDT((fdt_setprop(fdt, offset, "ibm,pa-features", pa_features, pa_size))); 33386d5771aSSam Bobroff } 33486d5771aSSam Bobroff 33528e02042SDavid Gibson static int spapr_fixup_cpu_dt(void *fdt, sPAPRMachineState *spapr) 33653018216SPaolo Bonzini { 33782677ed2SAlexey Kardashevskiy int ret = 0, offset, cpus_offset; 33882677ed2SAlexey Kardashevskiy CPUState *cs; 33953018216SPaolo Bonzini char cpu_model[32]; 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); 346abbc1247SDavid Gibson int compat_smt = MIN(smp_threads, ppc_compat_max_vthreads(cpu)); 34753018216SPaolo Bonzini 348*72194664SGreg Kurz if (index % spapr->vsmt != 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 387ee76a09fSDavid Gibson spapr_populate_pa_features(spapr, 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) { 466b472b1a7SDaniel Henrique Barboza /* spapr_machine_init() checks for rma_size <= node0_size 467b472b1a7SDaniel Henrique Barboza * already */ 468e8f986fcSBharata B Rao spapr_populate_memory_node(fdt, i, 0, spapr->rma_size); 4697db8a127SAlexey Kardashevskiy mem_start += spapr->rma_size; 4707db8a127SAlexey Kardashevskiy node_size -= spapr->rma_size; 4717db8a127SAlexey Kardashevskiy } 4726010818cSAlexey Kardashevskiy for ( ; node_size; ) { 4736010818cSAlexey Kardashevskiy hwaddr sizetmp = pow2floor(node_size); 4746010818cSAlexey Kardashevskiy 4756010818cSAlexey Kardashevskiy /* mem_start != 0 here */ 4766010818cSAlexey Kardashevskiy if (ctzl(mem_start) < ctzl(sizetmp)) { 4776010818cSAlexey Kardashevskiy sizetmp = 1ULL << ctzl(mem_start); 4786010818cSAlexey Kardashevskiy } 4796010818cSAlexey Kardashevskiy 4806010818cSAlexey Kardashevskiy spapr_populate_memory_node(fdt, i, mem_start, sizetmp); 4816010818cSAlexey Kardashevskiy node_size -= sizetmp; 4826010818cSAlexey Kardashevskiy mem_start += sizetmp; 4836010818cSAlexey Kardashevskiy } 48453018216SPaolo Bonzini } 48553018216SPaolo Bonzini 48653018216SPaolo Bonzini return 0; 48753018216SPaolo Bonzini } 48853018216SPaolo Bonzini 4890da6f3feSBharata B Rao static void spapr_populate_cpu_dt(CPUState *cs, void *fdt, int offset, 4900da6f3feSBharata B Rao sPAPRMachineState *spapr) 4910da6f3feSBharata B Rao { 4920da6f3feSBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(cs); 4930da6f3feSBharata B Rao CPUPPCState *env = &cpu->env; 4940da6f3feSBharata B Rao PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(cs); 4952e886fb3SSam Bobroff int index = spapr_vcpu_id(cpu); 4960da6f3feSBharata B Rao uint32_t segs[] = {cpu_to_be32(28), cpu_to_be32(40), 4970da6f3feSBharata B Rao 0xffffffff, 0xffffffff}; 498afd10a0fSBharata B Rao uint32_t tbfreq = kvm_enabled() ? kvmppc_get_tbfreq() 499afd10a0fSBharata B Rao : SPAPR_TIMEBASE_FREQ; 5000da6f3feSBharata B Rao uint32_t cpufreq = kvm_enabled() ? kvmppc_get_clockfreq() : 1000000000; 5010da6f3feSBharata B Rao uint32_t page_sizes_prop[64]; 5020da6f3feSBharata B Rao size_t page_sizes_prop_size; 50322419c2aSDavid Gibson uint32_t vcpus_per_socket = smp_threads * smp_cores; 5040da6f3feSBharata B Rao uint32_t pft_size_prop[] = {0, cpu_to_be32(spapr->htab_shift)}; 505abbc1247SDavid Gibson int compat_smt = MIN(smp_threads, ppc_compat_max_vthreads(cpu)); 506af81cf32SBharata B Rao sPAPRDRConnector *drc; 507af81cf32SBharata B Rao int drc_index; 508c64abd1fSSam Bobroff uint32_t radix_AP_encodings[PPC_PAGE_SIZES_MAX_SZ]; 509c64abd1fSSam Bobroff int i; 510af81cf32SBharata B Rao 511fbf55397SDavid Gibson drc = spapr_drc_by_id(TYPE_SPAPR_DRC_CPU, index); 512af81cf32SBharata B Rao if (drc) { 5130b55aa91SDavid Gibson drc_index = spapr_drc_index(drc); 514af81cf32SBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,my-drc-index", drc_index))); 515af81cf32SBharata B Rao } 5160da6f3feSBharata B Rao 5170da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "reg", index))); 5180da6f3feSBharata B Rao _FDT((fdt_setprop_string(fdt, offset, "device_type", "cpu"))); 5190da6f3feSBharata B Rao 5200da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "cpu-version", env->spr[SPR_PVR]))); 5210da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "d-cache-block-size", 5220da6f3feSBharata B Rao env->dcache_line_size))); 5230da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "d-cache-line-size", 5240da6f3feSBharata B Rao env->dcache_line_size))); 5250da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "i-cache-block-size", 5260da6f3feSBharata B Rao env->icache_line_size))); 5270da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "i-cache-line-size", 5280da6f3feSBharata B Rao env->icache_line_size))); 5290da6f3feSBharata B Rao 5300da6f3feSBharata B Rao if (pcc->l1_dcache_size) { 5310da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "d-cache-size", 5320da6f3feSBharata B Rao pcc->l1_dcache_size))); 5330da6f3feSBharata B Rao } else { 5343dc6f869SAlistair Francis warn_report("Unknown L1 dcache size for cpu"); 5350da6f3feSBharata B Rao } 5360da6f3feSBharata B Rao if (pcc->l1_icache_size) { 5370da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "i-cache-size", 5380da6f3feSBharata B Rao pcc->l1_icache_size))); 5390da6f3feSBharata B Rao } else { 5403dc6f869SAlistair Francis warn_report("Unknown L1 icache size for cpu"); 5410da6f3feSBharata B Rao } 5420da6f3feSBharata B Rao 5430da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "timebase-frequency", tbfreq))); 5440da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "clock-frequency", cpufreq))); 545fd5da5c4SThomas Huth _FDT((fdt_setprop_cell(fdt, offset, "slb-size", env->slb_nr))); 5460da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,slb-size", env->slb_nr))); 5470da6f3feSBharata B Rao _FDT((fdt_setprop_string(fdt, offset, "status", "okay"))); 5480da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "64-bit", NULL, 0))); 5490da6f3feSBharata B Rao 5500da6f3feSBharata B Rao if (env->spr_cb[SPR_PURR].oea_read) { 5510da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,purr", NULL, 0))); 5520da6f3feSBharata B Rao } 5530da6f3feSBharata B Rao 5540da6f3feSBharata B Rao if (env->mmu_model & POWERPC_MMU_1TSEG) { 5550da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,processor-segment-sizes", 5560da6f3feSBharata B Rao segs, sizeof(segs)))); 5570da6f3feSBharata B Rao } 5580da6f3feSBharata B Rao 55929386642SDavid Gibson /* Advertise VSX (vector extensions) if available 5600da6f3feSBharata B Rao * 1 == VMX / Altivec available 56129386642SDavid Gibson * 2 == VSX available 56229386642SDavid Gibson * 56329386642SDavid Gibson * Only CPUs for which we create core types in spapr_cpu_core.c 56429386642SDavid Gibson * are possible, and all of those have VMX */ 5654e5fe368SSuraj Jitindar Singh if (spapr_get_cap(spapr, SPAPR_CAP_VSX) != 0) { 56629386642SDavid Gibson _FDT((fdt_setprop_cell(fdt, offset, "ibm,vmx", 2))); 56729386642SDavid Gibson } else { 56829386642SDavid Gibson _FDT((fdt_setprop_cell(fdt, offset, "ibm,vmx", 1))); 5690da6f3feSBharata B Rao } 5700da6f3feSBharata B Rao 5710da6f3feSBharata B Rao /* Advertise DFP (Decimal Floating Point) if available 5720da6f3feSBharata B Rao * 0 / no property == no DFP 5730da6f3feSBharata B Rao * 1 == DFP available */ 5744e5fe368SSuraj Jitindar Singh if (spapr_get_cap(spapr, SPAPR_CAP_DFP) != 0) { 5750da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,dfp", 1))); 5760da6f3feSBharata B Rao } 5770da6f3feSBharata B Rao 5783654fa95SCédric Le Goater page_sizes_prop_size = ppc_create_page_sizes_prop(env, page_sizes_prop, 5790da6f3feSBharata B Rao sizeof(page_sizes_prop)); 5800da6f3feSBharata B Rao if (page_sizes_prop_size) { 5810da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,segment-page-sizes", 5820da6f3feSBharata B Rao page_sizes_prop, page_sizes_prop_size))); 5830da6f3feSBharata B Rao } 5840da6f3feSBharata B Rao 585ee76a09fSDavid Gibson spapr_populate_pa_features(spapr, cpu, fdt, offset, false); 58690da0d5aSBenjamin Herrenschmidt 5870da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,chip-id", 58822419c2aSDavid Gibson cs->cpu_index / vcpus_per_socket))); 5890da6f3feSBharata B Rao 5900da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,pft-size", 5910da6f3feSBharata B Rao pft_size_prop, sizeof(pft_size_prop)))); 5920da6f3feSBharata B Rao 59399861ecbSIgor Mammedov if (nb_numa_nodes > 1) { 59499861ecbSIgor Mammedov _FDT(spapr_fixup_cpu_numa_dt(fdt, offset, cpu)); 59599861ecbSIgor Mammedov } 5960da6f3feSBharata B Rao 59712dbeb16SDavid Gibson _FDT(spapr_fixup_cpu_smt_dt(fdt, offset, cpu, compat_smt)); 598c64abd1fSSam Bobroff 599c64abd1fSSam Bobroff if (pcc->radix_page_info) { 600c64abd1fSSam Bobroff for (i = 0; i < pcc->radix_page_info->count; i++) { 601c64abd1fSSam Bobroff radix_AP_encodings[i] = 602c64abd1fSSam Bobroff cpu_to_be32(pcc->radix_page_info->entries[i]); 603c64abd1fSSam Bobroff } 604c64abd1fSSam Bobroff _FDT((fdt_setprop(fdt, offset, "ibm,processor-radix-AP-encodings", 605c64abd1fSSam Bobroff radix_AP_encodings, 606c64abd1fSSam Bobroff pcc->radix_page_info->count * 607c64abd1fSSam Bobroff sizeof(radix_AP_encodings[0])))); 608c64abd1fSSam Bobroff } 6090da6f3feSBharata B Rao } 6100da6f3feSBharata B Rao 6110da6f3feSBharata B Rao static void spapr_populate_cpus_dt_node(void *fdt, sPAPRMachineState *spapr) 6120da6f3feSBharata B Rao { 6130da6f3feSBharata B Rao CPUState *cs; 6140da6f3feSBharata B Rao int cpus_offset; 6150da6f3feSBharata B Rao char *nodename; 6160da6f3feSBharata B Rao 6170da6f3feSBharata B Rao cpus_offset = fdt_add_subnode(fdt, 0, "cpus"); 6180da6f3feSBharata B Rao _FDT(cpus_offset); 6190da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, cpus_offset, "#address-cells", 0x1))); 6200da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, cpus_offset, "#size-cells", 0x0))); 6210da6f3feSBharata B Rao 6220da6f3feSBharata B Rao /* 6230da6f3feSBharata B Rao * We walk the CPUs in reverse order to ensure that CPU DT nodes 6240da6f3feSBharata B Rao * created by fdt_add_subnode() end up in the right order in FDT 6250da6f3feSBharata B Rao * for the guest kernel the enumerate the CPUs correctly. 6260da6f3feSBharata B Rao */ 6270da6f3feSBharata B Rao CPU_FOREACH_REVERSE(cs) { 6280da6f3feSBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(cs); 6292e886fb3SSam Bobroff int index = spapr_vcpu_id(cpu); 6300da6f3feSBharata B Rao DeviceClass *dc = DEVICE_GET_CLASS(cs); 6310da6f3feSBharata B Rao int offset; 6320da6f3feSBharata B Rao 633*72194664SGreg Kurz if (index % spapr->vsmt != 0) { 6340da6f3feSBharata B Rao continue; 6350da6f3feSBharata B Rao } 6360da6f3feSBharata B Rao 6370da6f3feSBharata B Rao nodename = g_strdup_printf("%s@%x", dc->fw_name, index); 6380da6f3feSBharata B Rao offset = fdt_add_subnode(fdt, cpus_offset, nodename); 6390da6f3feSBharata B Rao g_free(nodename); 6400da6f3feSBharata B Rao _FDT(offset); 6410da6f3feSBharata B Rao spapr_populate_cpu_dt(cs, fdt, offset, spapr); 6420da6f3feSBharata B Rao } 6430da6f3feSBharata B Rao 6440da6f3feSBharata B Rao } 6450da6f3feSBharata B Rao 646f47bd1c8SIgor Mammedov static uint32_t spapr_pc_dimm_node(MemoryDeviceInfoList *list, ram_addr_t addr) 647f47bd1c8SIgor Mammedov { 648f47bd1c8SIgor Mammedov MemoryDeviceInfoList *info; 649f47bd1c8SIgor Mammedov 650f47bd1c8SIgor Mammedov for (info = list; info; info = info->next) { 651f47bd1c8SIgor Mammedov MemoryDeviceInfo *value = info->value; 652f47bd1c8SIgor Mammedov 653f47bd1c8SIgor Mammedov if (value && value->type == MEMORY_DEVICE_INFO_KIND_DIMM) { 654f47bd1c8SIgor Mammedov PCDIMMDeviceInfo *pcdimm_info = value->u.dimm.data; 655f47bd1c8SIgor Mammedov 656f47bd1c8SIgor Mammedov if (pcdimm_info->addr >= addr && 657f47bd1c8SIgor Mammedov addr < (pcdimm_info->addr + pcdimm_info->size)) { 658f47bd1c8SIgor Mammedov return pcdimm_info->node; 659f47bd1c8SIgor Mammedov } 660f47bd1c8SIgor Mammedov } 661f47bd1c8SIgor Mammedov } 662f47bd1c8SIgor Mammedov 663f47bd1c8SIgor Mammedov return -1; 664f47bd1c8SIgor Mammedov } 665f47bd1c8SIgor Mammedov 66603d196b7SBharata B Rao /* 66703d196b7SBharata B Rao * Adds ibm,dynamic-reconfiguration-memory node. 66803d196b7SBharata B Rao * Refer to docs/specs/ppc-spapr-hotplug.txt for the documentation 66903d196b7SBharata B Rao * of this device tree node. 67003d196b7SBharata B Rao */ 67103d196b7SBharata B Rao static int spapr_populate_drconf_memory(sPAPRMachineState *spapr, void *fdt) 67203d196b7SBharata B Rao { 67303d196b7SBharata B Rao MachineState *machine = MACHINE(spapr); 67403d196b7SBharata B Rao int ret, i, offset; 67503d196b7SBharata B Rao uint64_t lmb_size = SPAPR_MEMORY_BLOCK_SIZE; 67603d196b7SBharata B Rao uint32_t prop_lmb_size[] = {0, cpu_to_be32(lmb_size)}; 677d0e5a8f2SBharata B Rao uint32_t hotplug_lmb_start = spapr->hotplug_memory.base / lmb_size; 678d0e5a8f2SBharata B Rao uint32_t nr_lmbs = (spapr->hotplug_memory.base + 679d0e5a8f2SBharata B Rao memory_region_size(&spapr->hotplug_memory.mr)) / 680d0e5a8f2SBharata B Rao lmb_size; 68103d196b7SBharata B Rao uint32_t *int_buf, *cur_index, buf_len; 6826663864eSBharata B Rao int nr_nodes = nb_numa_nodes ? nb_numa_nodes : 1; 683f47bd1c8SIgor Mammedov MemoryDeviceInfoList *dimms = NULL; 68403d196b7SBharata B Rao 685ef001f06SThomas Huth /* 686d0e5a8f2SBharata B Rao * Don't create the node if there is no hotpluggable memory 68716c25aefSBharata B Rao */ 688d0e5a8f2SBharata B Rao if (machine->ram_size == machine->maxram_size) { 68916c25aefSBharata B Rao return 0; 69016c25aefSBharata B Rao } 69116c25aefSBharata B Rao 69216c25aefSBharata B Rao /* 693ef001f06SThomas Huth * Allocate enough buffer size to fit in ibm,dynamic-memory 694ef001f06SThomas Huth * or ibm,associativity-lookup-arrays 695ef001f06SThomas Huth */ 696ef001f06SThomas Huth buf_len = MAX(nr_lmbs * SPAPR_DR_LMB_LIST_ENTRY_SIZE + 1, nr_nodes * 4 + 2) 697ef001f06SThomas Huth * sizeof(uint32_t); 69803d196b7SBharata B Rao cur_index = int_buf = g_malloc0(buf_len); 69903d196b7SBharata B Rao 70003d196b7SBharata B Rao offset = fdt_add_subnode(fdt, 0, "ibm,dynamic-reconfiguration-memory"); 70103d196b7SBharata B Rao 70203d196b7SBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,lmb-size", prop_lmb_size, 70303d196b7SBharata B Rao sizeof(prop_lmb_size)); 70403d196b7SBharata B Rao if (ret < 0) { 70503d196b7SBharata B Rao goto out; 70603d196b7SBharata B Rao } 70703d196b7SBharata B Rao 70803d196b7SBharata B Rao ret = fdt_setprop_cell(fdt, offset, "ibm,memory-flags-mask", 0xff); 70903d196b7SBharata B Rao if (ret < 0) { 71003d196b7SBharata B Rao goto out; 71103d196b7SBharata B Rao } 71203d196b7SBharata B Rao 71303d196b7SBharata B Rao ret = fdt_setprop_cell(fdt, offset, "ibm,memory-preservation-time", 0x0); 71403d196b7SBharata B Rao if (ret < 0) { 71503d196b7SBharata B Rao goto out; 71603d196b7SBharata B Rao } 71703d196b7SBharata B Rao 718f47bd1c8SIgor Mammedov if (hotplug_lmb_start) { 719f47bd1c8SIgor Mammedov MemoryDeviceInfoList **prev = &dimms; 720f47bd1c8SIgor Mammedov qmp_pc_dimm_device_list(qdev_get_machine(), &prev); 721f47bd1c8SIgor Mammedov } 722f47bd1c8SIgor Mammedov 72303d196b7SBharata B Rao /* ibm,dynamic-memory */ 72403d196b7SBharata B Rao int_buf[0] = cpu_to_be32(nr_lmbs); 72503d196b7SBharata B Rao cur_index++; 72603d196b7SBharata B Rao for (i = 0; i < nr_lmbs; i++) { 727d0e5a8f2SBharata B Rao uint64_t addr = i * lmb_size; 72803d196b7SBharata B Rao uint32_t *dynamic_memory = cur_index; 72903d196b7SBharata B Rao 730d0e5a8f2SBharata B Rao if (i >= hotplug_lmb_start) { 731d0e5a8f2SBharata B Rao sPAPRDRConnector *drc; 732d0e5a8f2SBharata B Rao 733fbf55397SDavid Gibson drc = spapr_drc_by_id(TYPE_SPAPR_DRC_LMB, i); 73403d196b7SBharata B Rao g_assert(drc); 73503d196b7SBharata B Rao 73603d196b7SBharata B Rao dynamic_memory[0] = cpu_to_be32(addr >> 32); 73703d196b7SBharata B Rao dynamic_memory[1] = cpu_to_be32(addr & 0xffffffff); 7380b55aa91SDavid Gibson dynamic_memory[2] = cpu_to_be32(spapr_drc_index(drc)); 73903d196b7SBharata B Rao dynamic_memory[3] = cpu_to_be32(0); /* reserved */ 740f47bd1c8SIgor Mammedov dynamic_memory[4] = cpu_to_be32(spapr_pc_dimm_node(dimms, addr)); 741d0e5a8f2SBharata B Rao if (memory_region_present(get_system_memory(), addr)) { 74203d196b7SBharata B Rao dynamic_memory[5] = cpu_to_be32(SPAPR_LMB_FLAGS_ASSIGNED); 74303d196b7SBharata B Rao } else { 74403d196b7SBharata B Rao dynamic_memory[5] = cpu_to_be32(0); 74503d196b7SBharata B Rao } 746d0e5a8f2SBharata B Rao } else { 747d0e5a8f2SBharata B Rao /* 748d0e5a8f2SBharata B Rao * LMB information for RMA, boot time RAM and gap b/n RAM and 749d0e5a8f2SBharata B Rao * hotplug memory region -- all these are marked as reserved 750d0e5a8f2SBharata B Rao * and as having no valid DRC. 751d0e5a8f2SBharata B Rao */ 752d0e5a8f2SBharata B Rao dynamic_memory[0] = cpu_to_be32(addr >> 32); 753d0e5a8f2SBharata B Rao dynamic_memory[1] = cpu_to_be32(addr & 0xffffffff); 754d0e5a8f2SBharata B Rao dynamic_memory[2] = cpu_to_be32(0); 755d0e5a8f2SBharata B Rao dynamic_memory[3] = cpu_to_be32(0); /* reserved */ 756d0e5a8f2SBharata B Rao dynamic_memory[4] = cpu_to_be32(-1); 757d0e5a8f2SBharata B Rao dynamic_memory[5] = cpu_to_be32(SPAPR_LMB_FLAGS_RESERVED | 758d0e5a8f2SBharata B Rao SPAPR_LMB_FLAGS_DRC_INVALID); 759d0e5a8f2SBharata B Rao } 76003d196b7SBharata B Rao 76103d196b7SBharata B Rao cur_index += SPAPR_DR_LMB_LIST_ENTRY_SIZE; 76203d196b7SBharata B Rao } 763f47bd1c8SIgor Mammedov qapi_free_MemoryDeviceInfoList(dimms); 76403d196b7SBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,dynamic-memory", int_buf, buf_len); 76503d196b7SBharata B Rao if (ret < 0) { 76603d196b7SBharata B Rao goto out; 76703d196b7SBharata B Rao } 76803d196b7SBharata B Rao 76903d196b7SBharata B Rao /* ibm,associativity-lookup-arrays */ 77003d196b7SBharata B Rao cur_index = int_buf; 7716663864eSBharata B Rao int_buf[0] = cpu_to_be32(nr_nodes); 77203d196b7SBharata B Rao int_buf[1] = cpu_to_be32(4); /* Number of entries per associativity list */ 77303d196b7SBharata B Rao cur_index += 2; 7746663864eSBharata B Rao for (i = 0; i < nr_nodes; i++) { 77503d196b7SBharata B Rao uint32_t associativity[] = { 77603d196b7SBharata B Rao cpu_to_be32(0x0), 77703d196b7SBharata B Rao cpu_to_be32(0x0), 77803d196b7SBharata B Rao cpu_to_be32(0x0), 77903d196b7SBharata B Rao cpu_to_be32(i) 78003d196b7SBharata B Rao }; 78103d196b7SBharata B Rao memcpy(cur_index, associativity, sizeof(associativity)); 78203d196b7SBharata B Rao cur_index += 4; 78303d196b7SBharata B Rao } 78403d196b7SBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,associativity-lookup-arrays", int_buf, 78503d196b7SBharata B Rao (cur_index - int_buf) * sizeof(uint32_t)); 78603d196b7SBharata B Rao out: 78703d196b7SBharata B Rao g_free(int_buf); 78803d196b7SBharata B Rao return ret; 78903d196b7SBharata B Rao } 79003d196b7SBharata B Rao 7916787d27bSMichael Roth static int spapr_dt_cas_updates(sPAPRMachineState *spapr, void *fdt, 7926787d27bSMichael Roth sPAPROptionVector *ov5_updates) 7936787d27bSMichael Roth { 7946787d27bSMichael Roth sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(spapr); 795417ece33SMichael Roth int ret = 0, offset; 7966787d27bSMichael Roth 7976787d27bSMichael Roth /* Generate ibm,dynamic-reconfiguration-memory node if required */ 7986787d27bSMichael Roth if (spapr_ovec_test(ov5_updates, OV5_DRCONF_MEMORY)) { 7996787d27bSMichael Roth g_assert(smc->dr_lmb_enabled); 8006787d27bSMichael Roth ret = spapr_populate_drconf_memory(spapr, fdt); 801417ece33SMichael Roth if (ret) { 802417ece33SMichael Roth goto out; 803417ece33SMichael Roth } 8046787d27bSMichael Roth } 8056787d27bSMichael Roth 806417ece33SMichael Roth offset = fdt_path_offset(fdt, "/chosen"); 807417ece33SMichael Roth if (offset < 0) { 808417ece33SMichael Roth offset = fdt_add_subnode(fdt, 0, "chosen"); 809417ece33SMichael Roth if (offset < 0) { 810417ece33SMichael Roth return offset; 811417ece33SMichael Roth } 812417ece33SMichael Roth } 813417ece33SMichael Roth ret = spapr_ovec_populate_dt(fdt, offset, spapr->ov5_cas, 814417ece33SMichael Roth "ibm,architecture-vec-5"); 815417ece33SMichael Roth 816417ece33SMichael Roth out: 8176787d27bSMichael Roth return ret; 8186787d27bSMichael Roth } 8196787d27bSMichael Roth 82010f12e64SDaniel Henrique Barboza static bool spapr_hotplugged_dev_before_cas(void) 82110f12e64SDaniel Henrique Barboza { 82210f12e64SDaniel Henrique Barboza Object *drc_container, *obj; 82310f12e64SDaniel Henrique Barboza ObjectProperty *prop; 82410f12e64SDaniel Henrique Barboza ObjectPropertyIterator iter; 82510f12e64SDaniel Henrique Barboza 82610f12e64SDaniel Henrique Barboza drc_container = container_get(object_get_root(), "/dr-connector"); 82710f12e64SDaniel Henrique Barboza object_property_iter_init(&iter, drc_container); 82810f12e64SDaniel Henrique Barboza while ((prop = object_property_iter_next(&iter))) { 82910f12e64SDaniel Henrique Barboza if (!strstart(prop->type, "link<", NULL)) { 83010f12e64SDaniel Henrique Barboza continue; 83110f12e64SDaniel Henrique Barboza } 83210f12e64SDaniel Henrique Barboza obj = object_property_get_link(drc_container, prop->name, NULL); 83310f12e64SDaniel Henrique Barboza if (spapr_drc_needed(obj)) { 83410f12e64SDaniel Henrique Barboza return true; 83510f12e64SDaniel Henrique Barboza } 83610f12e64SDaniel Henrique Barboza } 83710f12e64SDaniel Henrique Barboza return false; 83810f12e64SDaniel Henrique Barboza } 83910f12e64SDaniel Henrique Barboza 84003d196b7SBharata B Rao int spapr_h_cas_compose_response(sPAPRMachineState *spapr, 84103d196b7SBharata B Rao target_ulong addr, target_ulong size, 8426787d27bSMichael Roth sPAPROptionVector *ov5_updates) 84303d196b7SBharata B Rao { 84403d196b7SBharata B Rao void *fdt, *fdt_skel; 84503d196b7SBharata B Rao sPAPRDeviceTreeUpdateHeader hdr = { .version_id = 1 }; 84603d196b7SBharata B Rao 84710f12e64SDaniel Henrique Barboza if (spapr_hotplugged_dev_before_cas()) { 84810f12e64SDaniel Henrique Barboza return 1; 84910f12e64SDaniel Henrique Barboza } 85010f12e64SDaniel Henrique Barboza 851827b17c4SGreg Kurz if (size < sizeof(hdr) || size > FW_MAX_SIZE) { 852827b17c4SGreg Kurz error_report("SLOF provided an unexpected CAS buffer size " 853827b17c4SGreg Kurz TARGET_FMT_lu " (min: %zu, max: %u)", 854827b17c4SGreg Kurz size, sizeof(hdr), FW_MAX_SIZE); 855827b17c4SGreg Kurz exit(EXIT_FAILURE); 856827b17c4SGreg Kurz } 857827b17c4SGreg Kurz 85803d196b7SBharata B Rao size -= sizeof(hdr); 85903d196b7SBharata B Rao 86010f12e64SDaniel Henrique Barboza /* Create skeleton */ 86103d196b7SBharata B Rao fdt_skel = g_malloc0(size); 86203d196b7SBharata B Rao _FDT((fdt_create(fdt_skel, size))); 86303d196b7SBharata B Rao _FDT((fdt_begin_node(fdt_skel, ""))); 86403d196b7SBharata B Rao _FDT((fdt_end_node(fdt_skel))); 86503d196b7SBharata B Rao _FDT((fdt_finish(fdt_skel))); 86603d196b7SBharata B Rao fdt = g_malloc0(size); 86703d196b7SBharata B Rao _FDT((fdt_open_into(fdt_skel, fdt, size))); 86803d196b7SBharata B Rao g_free(fdt_skel); 86903d196b7SBharata B Rao 87003d196b7SBharata B Rao /* Fixup cpu nodes */ 87103d196b7SBharata B Rao _FDT((spapr_fixup_cpu_dt(fdt, spapr))); 87203d196b7SBharata B Rao 8736787d27bSMichael Roth if (spapr_dt_cas_updates(spapr, fdt, ov5_updates)) { 8746787d27bSMichael Roth return -1; 87503d196b7SBharata B Rao } 87603d196b7SBharata B Rao 87703d196b7SBharata B Rao /* Pack resulting tree */ 87803d196b7SBharata B Rao _FDT((fdt_pack(fdt))); 87903d196b7SBharata B Rao 88003d196b7SBharata B Rao if (fdt_totalsize(fdt) + sizeof(hdr) > size) { 88103d196b7SBharata B Rao trace_spapr_cas_failed(size); 88203d196b7SBharata B Rao return -1; 88303d196b7SBharata B Rao } 88403d196b7SBharata B Rao 88503d196b7SBharata B Rao cpu_physical_memory_write(addr, &hdr, sizeof(hdr)); 88603d196b7SBharata B Rao cpu_physical_memory_write(addr + sizeof(hdr), fdt, fdt_totalsize(fdt)); 88703d196b7SBharata B Rao trace_spapr_cas_continue(fdt_totalsize(fdt) + sizeof(hdr)); 88803d196b7SBharata B Rao g_free(fdt); 88903d196b7SBharata B Rao 89003d196b7SBharata B Rao return 0; 89103d196b7SBharata B Rao } 89203d196b7SBharata B Rao 8933f5dabceSDavid Gibson static void spapr_dt_rtas(sPAPRMachineState *spapr, void *fdt) 8943f5dabceSDavid Gibson { 8953f5dabceSDavid Gibson int rtas; 8963f5dabceSDavid Gibson GString *hypertas = g_string_sized_new(256); 8973f5dabceSDavid Gibson GString *qemu_hypertas = g_string_sized_new(256); 8983f5dabceSDavid Gibson uint32_t refpoints[] = { cpu_to_be32(0x4), cpu_to_be32(0x4) }; 8993f5dabceSDavid Gibson uint64_t max_hotplug_addr = spapr->hotplug_memory.base + 9003f5dabceSDavid Gibson memory_region_size(&spapr->hotplug_memory.mr); 9013f5dabceSDavid Gibson uint32_t lrdr_capacity[] = { 9023f5dabceSDavid Gibson cpu_to_be32(max_hotplug_addr >> 32), 9033f5dabceSDavid Gibson cpu_to_be32(max_hotplug_addr & 0xffffffff), 9043f5dabceSDavid Gibson 0, cpu_to_be32(SPAPR_MEMORY_BLOCK_SIZE), 9053f5dabceSDavid Gibson cpu_to_be32(max_cpus / smp_threads), 9063f5dabceSDavid Gibson }; 9073f5dabceSDavid Gibson 9083f5dabceSDavid Gibson _FDT(rtas = fdt_add_subnode(fdt, 0, "rtas")); 9093f5dabceSDavid Gibson 9103f5dabceSDavid Gibson /* hypertas */ 9113f5dabceSDavid Gibson add_str(hypertas, "hcall-pft"); 9123f5dabceSDavid Gibson add_str(hypertas, "hcall-term"); 9133f5dabceSDavid Gibson add_str(hypertas, "hcall-dabr"); 9143f5dabceSDavid Gibson add_str(hypertas, "hcall-interrupt"); 9153f5dabceSDavid Gibson add_str(hypertas, "hcall-tce"); 9163f5dabceSDavid Gibson add_str(hypertas, "hcall-vio"); 9173f5dabceSDavid Gibson add_str(hypertas, "hcall-splpar"); 9183f5dabceSDavid Gibson add_str(hypertas, "hcall-bulk"); 9193f5dabceSDavid Gibson add_str(hypertas, "hcall-set-mode"); 9203f5dabceSDavid Gibson add_str(hypertas, "hcall-sprg0"); 9213f5dabceSDavid Gibson add_str(hypertas, "hcall-copy"); 9223f5dabceSDavid Gibson add_str(hypertas, "hcall-debug"); 9233f5dabceSDavid Gibson add_str(qemu_hypertas, "hcall-memop1"); 9243f5dabceSDavid Gibson 9253f5dabceSDavid Gibson if (!kvm_enabled() || kvmppc_spapr_use_multitce()) { 9263f5dabceSDavid Gibson add_str(hypertas, "hcall-multi-tce"); 9273f5dabceSDavid Gibson } 92830f4b05bSDavid Gibson 92930f4b05bSDavid Gibson if (spapr->resize_hpt != SPAPR_RESIZE_HPT_DISABLED) { 93030f4b05bSDavid Gibson add_str(hypertas, "hcall-hpt-resize"); 93130f4b05bSDavid Gibson } 93230f4b05bSDavid Gibson 9333f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,hypertas-functions", 9343f5dabceSDavid Gibson hypertas->str, hypertas->len)); 9353f5dabceSDavid Gibson g_string_free(hypertas, TRUE); 9363f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "qemu,hypertas-functions", 9373f5dabceSDavid Gibson qemu_hypertas->str, qemu_hypertas->len)); 9383f5dabceSDavid Gibson g_string_free(qemu_hypertas, TRUE); 9393f5dabceSDavid Gibson 9403f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,associativity-reference-points", 9413f5dabceSDavid Gibson refpoints, sizeof(refpoints))); 9423f5dabceSDavid Gibson 9433f5dabceSDavid Gibson _FDT(fdt_setprop_cell(fdt, rtas, "rtas-error-log-max", 9443f5dabceSDavid Gibson RTAS_ERROR_LOG_MAX)); 9453f5dabceSDavid Gibson _FDT(fdt_setprop_cell(fdt, rtas, "rtas-event-scan-rate", 9463f5dabceSDavid Gibson RTAS_EVENT_SCAN_RATE)); 9473f5dabceSDavid Gibson 9484f441474SDavid Gibson g_assert(msi_nonbroken); 9493f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,change-msix-capable", NULL, 0)); 9503f5dabceSDavid Gibson 9513f5dabceSDavid Gibson /* 9523f5dabceSDavid Gibson * According to PAPR, rtas ibm,os-term does not guarantee a return 9533f5dabceSDavid Gibson * back to the guest cpu. 9543f5dabceSDavid Gibson * 9553f5dabceSDavid Gibson * While an additional ibm,extended-os-term property indicates 9563f5dabceSDavid Gibson * that rtas call return will always occur. Set this property. 9573f5dabceSDavid Gibson */ 9583f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,extended-os-term", NULL, 0)); 9593f5dabceSDavid Gibson 9603f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,lrdr-capacity", 9613f5dabceSDavid Gibson lrdr_capacity, sizeof(lrdr_capacity))); 9623f5dabceSDavid Gibson 9633f5dabceSDavid Gibson spapr_dt_rtas_tokens(fdt, rtas); 9643f5dabceSDavid Gibson } 9653f5dabceSDavid Gibson 9669fb4541fSSam Bobroff /* Prepare ibm,arch-vec-5-platform-support, which indicates the MMU features 9679fb4541fSSam Bobroff * that the guest may request and thus the valid values for bytes 24..26 of 9689fb4541fSSam Bobroff * option vector 5: */ 9699fb4541fSSam Bobroff static void spapr_dt_ov5_platform_support(void *fdt, int chosen) 9709fb4541fSSam Bobroff { 971545d6e2bSSuraj Jitindar Singh PowerPCCPU *first_ppc_cpu = POWERPC_CPU(first_cpu); 972545d6e2bSSuraj Jitindar Singh 973f2b14e3aSCédric Le Goater char val[2 * 4] = { 97421f3f8dbSCédric Le Goater 23, 0x00, /* Xive mode, filled in below. */ 9759fb4541fSSam Bobroff 24, 0x00, /* Hash/Radix, filled in below. */ 9769fb4541fSSam Bobroff 25, 0x00, /* Hash options: Segment Tables == no, GTSE == no. */ 9779fb4541fSSam Bobroff 26, 0x40, /* Radix options: GTSE == yes. */ 9789fb4541fSSam Bobroff }; 9799fb4541fSSam Bobroff 9807abd43baSSuraj Jitindar Singh if (!ppc_check_compat(first_ppc_cpu, CPU_POWERPC_LOGICAL_3_00, 0, 9817abd43baSSuraj Jitindar Singh first_ppc_cpu->compat_pvr)) { 9827abd43baSSuraj Jitindar Singh /* If we're in a pre POWER9 compat mode then the guest should do hash */ 9837abd43baSSuraj Jitindar Singh val[3] = 0x00; /* Hash */ 9847abd43baSSuraj Jitindar Singh } else if (kvm_enabled()) { 9859fb4541fSSam Bobroff if (kvmppc_has_cap_mmu_radix() && kvmppc_has_cap_mmu_hash_v3()) { 986f2b14e3aSCédric Le Goater val[3] = 0x80; /* OV5_MMU_BOTH */ 9879fb4541fSSam Bobroff } else if (kvmppc_has_cap_mmu_radix()) { 988f2b14e3aSCédric Le Goater val[3] = 0x40; /* OV5_MMU_RADIX_300 */ 9899fb4541fSSam Bobroff } else { 990f2b14e3aSCédric Le Goater val[3] = 0x00; /* Hash */ 9919fb4541fSSam Bobroff } 9929fb4541fSSam Bobroff } else { 9937abd43baSSuraj Jitindar Singh /* V3 MMU supports both hash and radix in tcg (with dynamic switching) */ 994f2b14e3aSCédric Le Goater val[3] = 0xC0; 995545d6e2bSSuraj Jitindar Singh } 9969fb4541fSSam Bobroff _FDT(fdt_setprop(fdt, chosen, "ibm,arch-vec-5-platform-support", 9979fb4541fSSam Bobroff val, sizeof(val))); 9989fb4541fSSam Bobroff } 9999fb4541fSSam Bobroff 10007c866c6aSDavid Gibson static void spapr_dt_chosen(sPAPRMachineState *spapr, void *fdt) 10017c866c6aSDavid Gibson { 10027c866c6aSDavid Gibson MachineState *machine = MACHINE(spapr); 10037c866c6aSDavid Gibson int chosen; 10047c866c6aSDavid Gibson const char *boot_device = machine->boot_order; 10057c866c6aSDavid Gibson char *stdout_path = spapr_vio_stdout_path(spapr->vio_bus); 10067c866c6aSDavid Gibson size_t cb = 0; 10077c866c6aSDavid Gibson char *bootlist = get_boot_devices_list(&cb, true); 10087c866c6aSDavid Gibson 10097c866c6aSDavid Gibson _FDT(chosen = fdt_add_subnode(fdt, 0, "chosen")); 10107c866c6aSDavid Gibson 10117c866c6aSDavid Gibson _FDT(fdt_setprop_string(fdt, chosen, "bootargs", machine->kernel_cmdline)); 10127c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "linux,initrd-start", 10137c866c6aSDavid Gibson spapr->initrd_base)); 10147c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "linux,initrd-end", 10157c866c6aSDavid Gibson spapr->initrd_base + spapr->initrd_size)); 10167c866c6aSDavid Gibson 10177c866c6aSDavid Gibson if (spapr->kernel_size) { 10187c866c6aSDavid Gibson uint64_t kprop[2] = { cpu_to_be64(KERNEL_LOAD_ADDR), 10197c866c6aSDavid Gibson cpu_to_be64(spapr->kernel_size) }; 10207c866c6aSDavid Gibson 10217c866c6aSDavid Gibson _FDT(fdt_setprop(fdt, chosen, "qemu,boot-kernel", 10227c866c6aSDavid Gibson &kprop, sizeof(kprop))); 10237c866c6aSDavid Gibson if (spapr->kernel_le) { 10247c866c6aSDavid Gibson _FDT(fdt_setprop(fdt, chosen, "qemu,boot-kernel-le", NULL, 0)); 10257c866c6aSDavid Gibson } 10267c866c6aSDavid Gibson } 10277c866c6aSDavid Gibson if (boot_menu) { 10287c866c6aSDavid Gibson _FDT((fdt_setprop_cell(fdt, chosen, "qemu,boot-menu", boot_menu))); 10297c866c6aSDavid Gibson } 10307c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "qemu,graphic-width", graphic_width)); 10317c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "qemu,graphic-height", graphic_height)); 10327c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "qemu,graphic-depth", graphic_depth)); 10337c866c6aSDavid Gibson 10347c866c6aSDavid Gibson if (cb && bootlist) { 10357c866c6aSDavid Gibson int i; 10367c866c6aSDavid Gibson 10377c866c6aSDavid Gibson for (i = 0; i < cb; i++) { 10387c866c6aSDavid Gibson if (bootlist[i] == '\n') { 10397c866c6aSDavid Gibson bootlist[i] = ' '; 10407c866c6aSDavid Gibson } 10417c866c6aSDavid Gibson } 10427c866c6aSDavid Gibson _FDT(fdt_setprop_string(fdt, chosen, "qemu,boot-list", bootlist)); 10437c866c6aSDavid Gibson } 10447c866c6aSDavid Gibson 10457c866c6aSDavid Gibson if (boot_device && strlen(boot_device)) { 10467c866c6aSDavid Gibson _FDT(fdt_setprop_string(fdt, chosen, "qemu,boot-device", boot_device)); 10477c866c6aSDavid Gibson } 10487c866c6aSDavid Gibson 10497c866c6aSDavid Gibson if (!spapr->has_graphics && stdout_path) { 10507c866c6aSDavid Gibson _FDT(fdt_setprop_string(fdt, chosen, "linux,stdout-path", stdout_path)); 10517c866c6aSDavid Gibson } 10527c866c6aSDavid Gibson 10539fb4541fSSam Bobroff spapr_dt_ov5_platform_support(fdt, chosen); 10549fb4541fSSam Bobroff 10557c866c6aSDavid Gibson g_free(stdout_path); 10567c866c6aSDavid Gibson g_free(bootlist); 10577c866c6aSDavid Gibson } 10587c866c6aSDavid Gibson 1059fca5f2dcSDavid Gibson static void spapr_dt_hypervisor(sPAPRMachineState *spapr, void *fdt) 1060fca5f2dcSDavid Gibson { 1061fca5f2dcSDavid Gibson /* The /hypervisor node isn't in PAPR - this is a hack to allow PR 1062fca5f2dcSDavid Gibson * KVM to work under pHyp with some guest co-operation */ 1063fca5f2dcSDavid Gibson int hypervisor; 1064fca5f2dcSDavid Gibson uint8_t hypercall[16]; 1065fca5f2dcSDavid Gibson 1066fca5f2dcSDavid Gibson _FDT(hypervisor = fdt_add_subnode(fdt, 0, "hypervisor")); 1067fca5f2dcSDavid Gibson /* indicate KVM hypercall interface */ 1068fca5f2dcSDavid Gibson _FDT(fdt_setprop_string(fdt, hypervisor, "compatible", "linux,kvm")); 1069fca5f2dcSDavid Gibson if (kvmppc_has_cap_fixup_hcalls()) { 1070fca5f2dcSDavid Gibson /* 1071fca5f2dcSDavid Gibson * Older KVM versions with older guest kernels were broken 1072fca5f2dcSDavid Gibson * with the magic page, don't allow the guest to map it. 1073fca5f2dcSDavid Gibson */ 1074fca5f2dcSDavid Gibson if (!kvmppc_get_hypercall(first_cpu->env_ptr, hypercall, 1075fca5f2dcSDavid Gibson sizeof(hypercall))) { 1076fca5f2dcSDavid Gibson _FDT(fdt_setprop(fdt, hypervisor, "hcall-instructions", 1077fca5f2dcSDavid Gibson hypercall, sizeof(hypercall))); 1078fca5f2dcSDavid Gibson } 1079fca5f2dcSDavid Gibson } 1080fca5f2dcSDavid Gibson } 1081fca5f2dcSDavid Gibson 1082997b6cfcSDavid Gibson static void *spapr_build_fdt(sPAPRMachineState *spapr, 108353018216SPaolo Bonzini hwaddr rtas_addr, 108453018216SPaolo Bonzini hwaddr rtas_size) 108553018216SPaolo Bonzini { 1086c86c1affSDaniel Henrique Barboza MachineState *machine = MACHINE(spapr); 10873c0c47e3SDavid Gibson MachineClass *mc = MACHINE_GET_CLASS(machine); 1088c20d332aSBharata B Rao sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(machine); 10897c866c6aSDavid Gibson int ret; 109053018216SPaolo Bonzini void *fdt; 109153018216SPaolo Bonzini sPAPRPHBState *phb; 1092398a0bd5SDavid Gibson char *buf; 109353018216SPaolo Bonzini 1094398a0bd5SDavid Gibson fdt = g_malloc0(FDT_MAX_SIZE); 1095398a0bd5SDavid Gibson _FDT((fdt_create_empty_tree(fdt, FDT_MAX_SIZE))); 109653018216SPaolo Bonzini 1097398a0bd5SDavid Gibson /* Root node */ 1098398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "device_type", "chrp")); 1099398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "model", "IBM pSeries (emulated by qemu)")); 1100398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "compatible", "qemu,pseries")); 1101398a0bd5SDavid Gibson 1102398a0bd5SDavid Gibson /* 1103398a0bd5SDavid Gibson * Add info to guest to indentify which host is it being run on 1104398a0bd5SDavid Gibson * and what is the uuid of the guest 1105398a0bd5SDavid Gibson */ 1106398a0bd5SDavid Gibson if (kvmppc_get_host_model(&buf)) { 1107398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "host-model", buf)); 1108398a0bd5SDavid Gibson g_free(buf); 1109398a0bd5SDavid Gibson } 1110398a0bd5SDavid Gibson if (kvmppc_get_host_serial(&buf)) { 1111398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "host-serial", buf)); 1112398a0bd5SDavid Gibson g_free(buf); 1113398a0bd5SDavid Gibson } 1114398a0bd5SDavid Gibson 1115398a0bd5SDavid Gibson buf = qemu_uuid_unparse_strdup(&qemu_uuid); 1116398a0bd5SDavid Gibson 1117398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "vm,uuid", buf)); 1118398a0bd5SDavid Gibson if (qemu_uuid_set) { 1119398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "system-id", buf)); 1120398a0bd5SDavid Gibson } 1121398a0bd5SDavid Gibson g_free(buf); 1122398a0bd5SDavid Gibson 1123398a0bd5SDavid Gibson if (qemu_get_vm_name()) { 1124398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "ibm,partition-name", 1125398a0bd5SDavid Gibson qemu_get_vm_name())); 1126398a0bd5SDavid Gibson } 1127398a0bd5SDavid Gibson 1128398a0bd5SDavid Gibson _FDT(fdt_setprop_cell(fdt, 0, "#address-cells", 2)); 1129398a0bd5SDavid Gibson _FDT(fdt_setprop_cell(fdt, 0, "#size-cells", 2)); 113053018216SPaolo Bonzini 1131fc7e0765SDavid Gibson /* /interrupt controller */ 1132*72194664SGreg Kurz spapr_dt_xics(xics_max_server_number(spapr), fdt, PHANDLE_XICP); 1133fc7e0765SDavid Gibson 1134e8f986fcSBharata B Rao ret = spapr_populate_memory(spapr, fdt); 1135e8f986fcSBharata B Rao if (ret < 0) { 1136ce9863b7SCédric Le Goater error_report("couldn't setup memory nodes in fdt"); 1137e8f986fcSBharata B Rao exit(1); 113853018216SPaolo Bonzini } 113953018216SPaolo Bonzini 1140bf5a6696SDavid Gibson /* /vdevice */ 1141bf5a6696SDavid Gibson spapr_dt_vdevice(spapr->vio_bus, fdt); 114253018216SPaolo Bonzini 11434d9392beSThomas Huth if (object_resolve_path_type("", TYPE_SPAPR_RNG, NULL)) { 11444d9392beSThomas Huth ret = spapr_rng_populate_dt(fdt); 11454d9392beSThomas Huth if (ret < 0) { 1146ce9863b7SCédric Le Goater error_report("could not set up rng device in the fdt"); 11474d9392beSThomas Huth exit(1); 11484d9392beSThomas Huth } 11494d9392beSThomas Huth } 11504d9392beSThomas Huth 115153018216SPaolo Bonzini QLIST_FOREACH(phb, &spapr->phbs, list) { 115253018216SPaolo Bonzini ret = spapr_populate_pci_dt(phb, PHANDLE_XICP, fdt); 115353018216SPaolo Bonzini if (ret < 0) { 1154da34fed7SThomas Huth error_report("couldn't setup PCI devices in fdt"); 115553018216SPaolo Bonzini exit(1); 115653018216SPaolo Bonzini } 1157da34fed7SThomas Huth } 115853018216SPaolo Bonzini 11590da6f3feSBharata B Rao /* cpus */ 11600da6f3feSBharata B Rao spapr_populate_cpus_dt_node(fdt, spapr); 116153018216SPaolo Bonzini 1162c20d332aSBharata B Rao if (smc->dr_lmb_enabled) { 1163c20d332aSBharata B Rao _FDT(spapr_drc_populate_dt(fdt, 0, NULL, SPAPR_DR_CONNECTOR_TYPE_LMB)); 1164c20d332aSBharata B Rao } 1165c20d332aSBharata B Rao 1166c5514d0eSIgor Mammedov if (mc->has_hotpluggable_cpus) { 1167af81cf32SBharata B Rao int offset = fdt_path_offset(fdt, "/cpus"); 1168af81cf32SBharata B Rao ret = spapr_drc_populate_dt(fdt, offset, NULL, 1169af81cf32SBharata B Rao SPAPR_DR_CONNECTOR_TYPE_CPU); 1170af81cf32SBharata B Rao if (ret < 0) { 1171af81cf32SBharata B Rao error_report("Couldn't set up CPU DR device tree properties"); 1172af81cf32SBharata B Rao exit(1); 1173af81cf32SBharata B Rao } 1174af81cf32SBharata B Rao } 1175af81cf32SBharata B Rao 1176ffb1e275SDavid Gibson /* /event-sources */ 1177ffbb1705SMichael Roth spapr_dt_events(spapr, fdt); 1178ffb1e275SDavid Gibson 11793f5dabceSDavid Gibson /* /rtas */ 11803f5dabceSDavid Gibson spapr_dt_rtas(spapr, fdt); 11813f5dabceSDavid Gibson 11827c866c6aSDavid Gibson /* /chosen */ 11837c866c6aSDavid Gibson spapr_dt_chosen(spapr, fdt); 1184cf6e5223SDavid Gibson 1185fca5f2dcSDavid Gibson /* /hypervisor */ 1186fca5f2dcSDavid Gibson if (kvm_enabled()) { 1187fca5f2dcSDavid Gibson spapr_dt_hypervisor(spapr, fdt); 1188fca5f2dcSDavid Gibson } 1189fca5f2dcSDavid Gibson 1190cf6e5223SDavid Gibson /* Build memory reserve map */ 1191cf6e5223SDavid Gibson if (spapr->kernel_size) { 1192cf6e5223SDavid Gibson _FDT((fdt_add_mem_rsv(fdt, KERNEL_LOAD_ADDR, spapr->kernel_size))); 1193cf6e5223SDavid Gibson } 1194cf6e5223SDavid Gibson if (spapr->initrd_size) { 1195cf6e5223SDavid Gibson _FDT((fdt_add_mem_rsv(fdt, spapr->initrd_base, spapr->initrd_size))); 1196cf6e5223SDavid Gibson } 1197cf6e5223SDavid Gibson 11986787d27bSMichael Roth /* ibm,client-architecture-support updates */ 11996787d27bSMichael Roth ret = spapr_dt_cas_updates(spapr, fdt, spapr->ov5_cas); 12006787d27bSMichael Roth if (ret < 0) { 12016787d27bSMichael Roth error_report("couldn't setup CAS properties fdt"); 12026787d27bSMichael Roth exit(1); 12036787d27bSMichael Roth } 12046787d27bSMichael Roth 1205997b6cfcSDavid Gibson return fdt; 120653018216SPaolo Bonzini } 120753018216SPaolo Bonzini 120853018216SPaolo Bonzini static uint64_t translate_kernel_address(void *opaque, uint64_t addr) 120953018216SPaolo Bonzini { 121053018216SPaolo Bonzini return (addr & 0x0fffffff) + KERNEL_LOAD_ADDR; 121153018216SPaolo Bonzini } 121253018216SPaolo Bonzini 12131d1be34dSDavid Gibson static void emulate_spapr_hypercall(PPCVirtualHypervisor *vhyp, 12141d1be34dSDavid Gibson PowerPCCPU *cpu) 121553018216SPaolo Bonzini { 121653018216SPaolo Bonzini CPUPPCState *env = &cpu->env; 121753018216SPaolo Bonzini 12188d04fb55SJan Kiszka /* The TCG path should also be holding the BQL at this point */ 12198d04fb55SJan Kiszka g_assert(qemu_mutex_iothread_locked()); 12208d04fb55SJan Kiszka 122153018216SPaolo Bonzini if (msr_pr) { 122253018216SPaolo Bonzini hcall_dprintf("Hypercall made with MSR[PR]=1\n"); 122353018216SPaolo Bonzini env->gpr[3] = H_PRIVILEGE; 122453018216SPaolo Bonzini } else { 122553018216SPaolo Bonzini env->gpr[3] = spapr_hypercall(cpu, env->gpr[3], &env->gpr[4]); 122653018216SPaolo Bonzini } 122753018216SPaolo Bonzini } 122853018216SPaolo Bonzini 12299861bb3eSSuraj Jitindar Singh static uint64_t spapr_get_patbe(PPCVirtualHypervisor *vhyp) 12309861bb3eSSuraj Jitindar Singh { 12319861bb3eSSuraj Jitindar Singh sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 12329861bb3eSSuraj Jitindar Singh 12339861bb3eSSuraj Jitindar Singh return spapr->patb_entry; 12349861bb3eSSuraj Jitindar Singh } 12359861bb3eSSuraj Jitindar Singh 1236e6b8fd24SSamuel Mendoza-Jonas #define HPTE(_table, _i) (void *)(((uint64_t *)(_table)) + ((_i) * 2)) 1237e6b8fd24SSamuel Mendoza-Jonas #define HPTE_VALID(_hpte) (tswap64(*((uint64_t *)(_hpte))) & HPTE64_V_VALID) 1238e6b8fd24SSamuel Mendoza-Jonas #define HPTE_DIRTY(_hpte) (tswap64(*((uint64_t *)(_hpte))) & HPTE64_V_HPTE_DIRTY) 1239e6b8fd24SSamuel Mendoza-Jonas #define CLEAN_HPTE(_hpte) ((*(uint64_t *)(_hpte)) &= tswap64(~HPTE64_V_HPTE_DIRTY)) 1240e6b8fd24SSamuel Mendoza-Jonas #define DIRTY_HPTE(_hpte) ((*(uint64_t *)(_hpte)) |= tswap64(HPTE64_V_HPTE_DIRTY)) 1241e6b8fd24SSamuel Mendoza-Jonas 1242715c5407SDavid Gibson /* 1243715c5407SDavid Gibson * Get the fd to access the kernel htab, re-opening it if necessary 1244715c5407SDavid Gibson */ 1245715c5407SDavid Gibson static int get_htab_fd(sPAPRMachineState *spapr) 1246715c5407SDavid Gibson { 124714b0d748SGreg Kurz Error *local_err = NULL; 124814b0d748SGreg Kurz 1249715c5407SDavid Gibson if (spapr->htab_fd >= 0) { 1250715c5407SDavid Gibson return spapr->htab_fd; 1251715c5407SDavid Gibson } 1252715c5407SDavid Gibson 125314b0d748SGreg Kurz spapr->htab_fd = kvmppc_get_htab_fd(false, 0, &local_err); 1254715c5407SDavid Gibson if (spapr->htab_fd < 0) { 125514b0d748SGreg Kurz error_report_err(local_err); 1256715c5407SDavid Gibson } 1257715c5407SDavid Gibson 1258715c5407SDavid Gibson return spapr->htab_fd; 1259715c5407SDavid Gibson } 1260715c5407SDavid Gibson 1261b4db5413SSuraj Jitindar Singh void close_htab_fd(sPAPRMachineState *spapr) 1262715c5407SDavid Gibson { 1263715c5407SDavid Gibson if (spapr->htab_fd >= 0) { 1264715c5407SDavid Gibson close(spapr->htab_fd); 1265715c5407SDavid Gibson } 1266715c5407SDavid Gibson spapr->htab_fd = -1; 1267715c5407SDavid Gibson } 1268715c5407SDavid Gibson 1269e57ca75cSDavid Gibson static hwaddr spapr_hpt_mask(PPCVirtualHypervisor *vhyp) 1270e57ca75cSDavid Gibson { 1271e57ca75cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 1272e57ca75cSDavid Gibson 1273e57ca75cSDavid Gibson return HTAB_SIZE(spapr) / HASH_PTEG_SIZE_64 - 1; 1274e57ca75cSDavid Gibson } 1275e57ca75cSDavid Gibson 12761ec26c75SGreg Kurz static target_ulong spapr_encode_hpt_for_kvm_pr(PPCVirtualHypervisor *vhyp) 12771ec26c75SGreg Kurz { 12781ec26c75SGreg Kurz sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 12791ec26c75SGreg Kurz 12801ec26c75SGreg Kurz assert(kvm_enabled()); 12811ec26c75SGreg Kurz 12821ec26c75SGreg Kurz if (!spapr->htab) { 12831ec26c75SGreg Kurz return 0; 12841ec26c75SGreg Kurz } 12851ec26c75SGreg Kurz 12861ec26c75SGreg Kurz return (target_ulong)(uintptr_t)spapr->htab | (spapr->htab_shift - 18); 12871ec26c75SGreg Kurz } 12881ec26c75SGreg Kurz 1289e57ca75cSDavid Gibson static const ppc_hash_pte64_t *spapr_map_hptes(PPCVirtualHypervisor *vhyp, 1290e57ca75cSDavid Gibson hwaddr ptex, int n) 1291e57ca75cSDavid Gibson { 1292e57ca75cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 1293e57ca75cSDavid Gibson hwaddr pte_offset = ptex * HASH_PTE_SIZE_64; 1294e57ca75cSDavid Gibson 1295e57ca75cSDavid Gibson if (!spapr->htab) { 1296e57ca75cSDavid Gibson /* 1297e57ca75cSDavid Gibson * HTAB is controlled by KVM. Fetch into temporary buffer 1298e57ca75cSDavid Gibson */ 1299e57ca75cSDavid Gibson ppc_hash_pte64_t *hptes = g_malloc(n * HASH_PTE_SIZE_64); 1300e57ca75cSDavid Gibson kvmppc_read_hptes(hptes, ptex, n); 1301e57ca75cSDavid Gibson return hptes; 1302e57ca75cSDavid Gibson } 1303e57ca75cSDavid Gibson 1304e57ca75cSDavid Gibson /* 1305e57ca75cSDavid Gibson * HTAB is controlled by QEMU. Just point to the internally 1306e57ca75cSDavid Gibson * accessible PTEG. 1307e57ca75cSDavid Gibson */ 1308e57ca75cSDavid Gibson return (const ppc_hash_pte64_t *)(spapr->htab + pte_offset); 1309e57ca75cSDavid Gibson } 1310e57ca75cSDavid Gibson 1311e57ca75cSDavid Gibson static void spapr_unmap_hptes(PPCVirtualHypervisor *vhyp, 1312e57ca75cSDavid Gibson const ppc_hash_pte64_t *hptes, 1313e57ca75cSDavid Gibson hwaddr ptex, int n) 1314e57ca75cSDavid Gibson { 1315e57ca75cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 1316e57ca75cSDavid Gibson 1317e57ca75cSDavid Gibson if (!spapr->htab) { 1318e57ca75cSDavid Gibson g_free((void *)hptes); 1319e57ca75cSDavid Gibson } 1320e57ca75cSDavid Gibson 1321e57ca75cSDavid Gibson /* Nothing to do for qemu managed HPT */ 1322e57ca75cSDavid Gibson } 1323e57ca75cSDavid Gibson 1324e57ca75cSDavid Gibson static void spapr_store_hpte(PPCVirtualHypervisor *vhyp, hwaddr ptex, 1325e57ca75cSDavid Gibson uint64_t pte0, uint64_t pte1) 1326e57ca75cSDavid Gibson { 1327e57ca75cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 1328e57ca75cSDavid Gibson hwaddr offset = ptex * HASH_PTE_SIZE_64; 1329e57ca75cSDavid Gibson 1330e57ca75cSDavid Gibson if (!spapr->htab) { 1331e57ca75cSDavid Gibson kvmppc_write_hpte(ptex, pte0, pte1); 1332e57ca75cSDavid Gibson } else { 1333e57ca75cSDavid Gibson stq_p(spapr->htab + offset, pte0); 1334e57ca75cSDavid Gibson stq_p(spapr->htab + offset + HASH_PTE_SIZE_64 / 2, pte1); 1335e57ca75cSDavid Gibson } 1336e57ca75cSDavid Gibson } 1337e57ca75cSDavid Gibson 13380b0b8310SDavid Gibson int spapr_hpt_shift_for_ramsize(uint64_t ramsize) 13398dfe8e7fSDavid Gibson { 13408dfe8e7fSDavid Gibson int shift; 13418dfe8e7fSDavid Gibson 13428dfe8e7fSDavid Gibson /* We aim for a hash table of size 1/128 the size of RAM (rounded 13438dfe8e7fSDavid Gibson * up). The PAPR recommendation is actually 1/64 of RAM size, but 13448dfe8e7fSDavid Gibson * that's much more than is needed for Linux guests */ 13458dfe8e7fSDavid Gibson shift = ctz64(pow2ceil(ramsize)) - 7; 13468dfe8e7fSDavid Gibson shift = MAX(shift, 18); /* Minimum architected size */ 13478dfe8e7fSDavid Gibson shift = MIN(shift, 46); /* Maximum architected size */ 13488dfe8e7fSDavid Gibson return shift; 13498dfe8e7fSDavid Gibson } 13508dfe8e7fSDavid Gibson 135106ec79e8SBharata B Rao void spapr_free_hpt(sPAPRMachineState *spapr) 135206ec79e8SBharata B Rao { 135306ec79e8SBharata B Rao g_free(spapr->htab); 135406ec79e8SBharata B Rao spapr->htab = NULL; 135506ec79e8SBharata B Rao spapr->htab_shift = 0; 135606ec79e8SBharata B Rao close_htab_fd(spapr); 135706ec79e8SBharata B Rao } 135806ec79e8SBharata B Rao 13592772cf6bSDavid Gibson void spapr_reallocate_hpt(sPAPRMachineState *spapr, int shift, 1360c5f54f3eSDavid Gibson Error **errp) 136153018216SPaolo Bonzini { 1362c5f54f3eSDavid Gibson long rc; 136353018216SPaolo Bonzini 1364c5f54f3eSDavid Gibson /* Clean up any HPT info from a previous boot */ 136506ec79e8SBharata B Rao spapr_free_hpt(spapr); 136653018216SPaolo Bonzini 1367c5f54f3eSDavid Gibson rc = kvmppc_reset_htab(shift); 1368c5f54f3eSDavid Gibson if (rc < 0) { 1369c5f54f3eSDavid Gibson /* kernel-side HPT needed, but couldn't allocate one */ 1370c5f54f3eSDavid Gibson error_setg_errno(errp, errno, 1371c5f54f3eSDavid Gibson "Failed to allocate KVM HPT of order %d (try smaller maxmem?)", 1372c5f54f3eSDavid Gibson shift); 1373c5f54f3eSDavid Gibson /* This is almost certainly fatal, but if the caller really 1374c5f54f3eSDavid Gibson * wants to carry on with shift == 0, it's welcome to try */ 1375c5f54f3eSDavid Gibson } else if (rc > 0) { 1376c5f54f3eSDavid Gibson /* kernel-side HPT allocated */ 1377c5f54f3eSDavid Gibson if (rc != shift) { 1378c5f54f3eSDavid Gibson error_setg(errp, 1379c5f54f3eSDavid Gibson "Requested order %d HPT, but kernel allocated order %ld (try smaller maxmem?)", 1380c5f54f3eSDavid Gibson shift, rc); 13817735fedaSBharata B Rao } 13827735fedaSBharata B Rao 138353018216SPaolo Bonzini spapr->htab_shift = shift; 1384c18ad9a5SDavid Gibson spapr->htab = NULL; 1385b817772aSBharata B Rao } else { 1386c5f54f3eSDavid Gibson /* kernel-side HPT not needed, allocate in userspace instead */ 1387c5f54f3eSDavid Gibson size_t size = 1ULL << shift; 1388c5f54f3eSDavid Gibson int i; 138901a57972SSamuel Mendoza-Jonas 1390c5f54f3eSDavid Gibson spapr->htab = qemu_memalign(size, size); 1391c5f54f3eSDavid Gibson if (!spapr->htab) { 1392c5f54f3eSDavid Gibson error_setg_errno(errp, errno, 1393c5f54f3eSDavid Gibson "Could not allocate HPT of order %d", shift); 1394c5f54f3eSDavid Gibson return; 1395b817772aSBharata B Rao } 1396b817772aSBharata B Rao 1397c5f54f3eSDavid Gibson memset(spapr->htab, 0, size); 1398c5f54f3eSDavid Gibson spapr->htab_shift = shift; 1399b817772aSBharata B Rao 1400c5f54f3eSDavid Gibson for (i = 0; i < size / HASH_PTE_SIZE_64; i++) { 1401c5f54f3eSDavid Gibson DIRTY_HPTE(HPTE(spapr->htab, i)); 14027735fedaSBharata B Rao } 140353018216SPaolo Bonzini } 1404ee4d9eccSSuraj Jitindar Singh /* We're setting up a hash table, so that means we're not radix */ 1405ee4d9eccSSuraj Jitindar Singh spapr->patb_entry = 0; 140653018216SPaolo Bonzini } 140753018216SPaolo Bonzini 1408b4db5413SSuraj Jitindar Singh void spapr_setup_hpt_and_vrma(sPAPRMachineState *spapr) 1409b4db5413SSuraj Jitindar Singh { 14102772cf6bSDavid Gibson int hpt_shift; 14112772cf6bSDavid Gibson 14122772cf6bSDavid Gibson if ((spapr->resize_hpt == SPAPR_RESIZE_HPT_DISABLED) 14132772cf6bSDavid Gibson || (spapr->cas_reboot 14142772cf6bSDavid Gibson && !spapr_ovec_test(spapr->ov5_cas, OV5_HPT_RESIZE))) { 14152772cf6bSDavid Gibson hpt_shift = spapr_hpt_shift_for_ramsize(MACHINE(spapr)->maxram_size); 14162772cf6bSDavid Gibson } else { 1417768a20f3SDavid Gibson uint64_t current_ram_size; 1418768a20f3SDavid Gibson 1419768a20f3SDavid Gibson current_ram_size = MACHINE(spapr)->ram_size + get_plugged_memory_size(); 1420768a20f3SDavid Gibson hpt_shift = spapr_hpt_shift_for_ramsize(current_ram_size); 14212772cf6bSDavid Gibson } 14222772cf6bSDavid Gibson spapr_reallocate_hpt(spapr, hpt_shift, &error_fatal); 14232772cf6bSDavid Gibson 1424b4db5413SSuraj Jitindar Singh if (spapr->vrma_adjust) { 1425c86c1affSDaniel Henrique Barboza spapr->rma_size = kvmppc_rma_size(spapr_node0_size(MACHINE(spapr)), 1426b4db5413SSuraj Jitindar Singh spapr->htab_shift); 1427b4db5413SSuraj Jitindar Singh } 1428b4db5413SSuraj Jitindar Singh } 1429b4db5413SSuraj Jitindar Singh 14304f01a637SDavid Gibson static void find_unknown_sysbus_device(SysBusDevice *sbdev, void *opaque) 14319e3f9733SAlexander Graf { 14329e3f9733SAlexander Graf bool matched = false; 14339e3f9733SAlexander Graf 14349e3f9733SAlexander Graf if (object_dynamic_cast(OBJECT(sbdev), TYPE_SPAPR_PCI_HOST_BRIDGE)) { 14359e3f9733SAlexander Graf matched = true; 14369e3f9733SAlexander Graf } 14379e3f9733SAlexander Graf 14389e3f9733SAlexander Graf if (!matched) { 14399e3f9733SAlexander Graf error_report("Device %s is not supported by this machine yet.", 14409e3f9733SAlexander Graf qdev_fw_name(DEVICE(sbdev))); 14419e3f9733SAlexander Graf exit(1); 14429e3f9733SAlexander Graf } 14439e3f9733SAlexander Graf } 14449e3f9733SAlexander Graf 144582512483SGreg Kurz static int spapr_reset_drcs(Object *child, void *opaque) 144682512483SGreg Kurz { 144782512483SGreg Kurz sPAPRDRConnector *drc = 144882512483SGreg Kurz (sPAPRDRConnector *) object_dynamic_cast(child, 144982512483SGreg Kurz TYPE_SPAPR_DR_CONNECTOR); 145082512483SGreg Kurz 145182512483SGreg Kurz if (drc) { 145282512483SGreg Kurz spapr_drc_reset(drc); 145382512483SGreg Kurz } 145482512483SGreg Kurz 145582512483SGreg Kurz return 0; 145682512483SGreg Kurz } 145782512483SGreg Kurz 1458bcb5ce08SDavid Gibson static void spapr_machine_reset(void) 145953018216SPaolo Bonzini { 1460c5f54f3eSDavid Gibson MachineState *machine = MACHINE(qdev_get_machine()); 1461c5f54f3eSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(machine); 1462182735efSAndreas Färber PowerPCCPU *first_ppc_cpu; 1463b7d1f77aSBenjamin Herrenschmidt uint32_t rtas_limit; 1464cae172abSDavid Gibson hwaddr rtas_addr, fdt_addr; 1465997b6cfcSDavid Gibson void *fdt; 1466997b6cfcSDavid Gibson int rc; 1467259186a7SAndreas Färber 14689e3f9733SAlexander Graf /* Check for unknown sysbus devices */ 14699e3f9733SAlexander Graf foreach_dynamic_sysbus_device(find_unknown_sysbus_device, NULL); 14709e3f9733SAlexander Graf 147133face6bSDavid Gibson spapr_caps_reset(spapr); 147233face6bSDavid Gibson 14731481fe5fSLaurent Vivier first_ppc_cpu = POWERPC_CPU(first_cpu); 14741481fe5fSLaurent Vivier if (kvm_enabled() && kvmppc_has_cap_mmu_radix() && 14751481fe5fSLaurent Vivier ppc_check_compat(first_ppc_cpu, CPU_POWERPC_LOGICAL_3_00, 0, 14761481fe5fSLaurent Vivier spapr->max_compat_pvr)) { 1477b4db5413SSuraj Jitindar Singh /* If using KVM with radix mode available, VCPUs can be started 1478b4db5413SSuraj Jitindar Singh * without a HPT because KVM will start them in radix mode. 1479b4db5413SSuraj Jitindar Singh * Set the GR bit in PATB so that we know there is no HPT. */ 1480b4db5413SSuraj Jitindar Singh spapr->patb_entry = PATBE1_GR; 1481b4db5413SSuraj Jitindar Singh } else { 1482b4db5413SSuraj Jitindar Singh spapr_setup_hpt_and_vrma(spapr); 1483c5f54f3eSDavid Gibson } 148453018216SPaolo Bonzini 14859012a53fSGreg Kurz /* if this reset wasn't generated by CAS, we should reset our 14869012a53fSGreg Kurz * negotiated options and start from scratch */ 14879012a53fSGreg Kurz if (!spapr->cas_reboot) { 14889012a53fSGreg Kurz spapr_ovec_cleanup(spapr->ov5_cas); 14899012a53fSGreg Kurz spapr->ov5_cas = spapr_ovec_new(); 14909012a53fSGreg Kurz 14919012a53fSGreg Kurz ppc_set_compat(first_ppc_cpu, spapr->max_compat_pvr, &error_fatal); 14929012a53fSGreg Kurz } 14939012a53fSGreg Kurz 149453018216SPaolo Bonzini qemu_devices_reset(); 149582512483SGreg Kurz 149682512483SGreg Kurz /* DRC reset may cause a device to be unplugged. This will cause troubles 149782512483SGreg Kurz * if this device is used by another device (eg, a running vhost backend 149882512483SGreg Kurz * will crash QEMU if the DIMM holding the vring goes away). To avoid such 149982512483SGreg Kurz * situations, we reset DRCs after all devices have been reset. 150082512483SGreg Kurz */ 150182512483SGreg Kurz object_child_foreach_recursive(object_get_root(), spapr_reset_drcs, NULL); 150282512483SGreg Kurz 150356258174SDaniel Henrique Barboza spapr_clear_pending_events(spapr); 150453018216SPaolo Bonzini 1505b7d1f77aSBenjamin Herrenschmidt /* 1506b7d1f77aSBenjamin Herrenschmidt * We place the device tree and RTAS just below either the top of the RMA, 1507b7d1f77aSBenjamin Herrenschmidt * or just below 2GB, whichever is lowere, so that it can be 1508b7d1f77aSBenjamin Herrenschmidt * processed with 32-bit real mode code if necessary 1509b7d1f77aSBenjamin Herrenschmidt */ 1510b7d1f77aSBenjamin Herrenschmidt rtas_limit = MIN(spapr->rma_size, RTAS_MAX_ADDR); 1511cae172abSDavid Gibson rtas_addr = rtas_limit - RTAS_MAX_SIZE; 1512cae172abSDavid Gibson fdt_addr = rtas_addr - FDT_MAX_SIZE; 1513b7d1f77aSBenjamin Herrenschmidt 1514cae172abSDavid Gibson fdt = spapr_build_fdt(spapr, rtas_addr, spapr->rtas_size); 151553018216SPaolo Bonzini 15162cac78c1SDavid Gibson spapr_load_rtas(spapr, fdt, rtas_addr); 1517b7d1f77aSBenjamin Herrenschmidt 1518997b6cfcSDavid Gibson rc = fdt_pack(fdt); 1519997b6cfcSDavid Gibson 1520997b6cfcSDavid Gibson /* Should only fail if we've built a corrupted tree */ 1521997b6cfcSDavid Gibson assert(rc == 0); 1522997b6cfcSDavid Gibson 1523997b6cfcSDavid Gibson if (fdt_totalsize(fdt) > FDT_MAX_SIZE) { 1524997b6cfcSDavid Gibson error_report("FDT too big ! 0x%x bytes (max is 0x%x)", 1525997b6cfcSDavid Gibson fdt_totalsize(fdt), FDT_MAX_SIZE); 1526997b6cfcSDavid Gibson exit(1); 1527997b6cfcSDavid Gibson } 1528997b6cfcSDavid Gibson 1529997b6cfcSDavid Gibson /* Load the fdt */ 1530997b6cfcSDavid Gibson qemu_fdt_dumpdtb(fdt, fdt_totalsize(fdt)); 1531cae172abSDavid Gibson cpu_physical_memory_write(fdt_addr, fdt, fdt_totalsize(fdt)); 1532997b6cfcSDavid Gibson g_free(fdt); 1533997b6cfcSDavid Gibson 153453018216SPaolo Bonzini /* Set up the entry state */ 1535cae172abSDavid Gibson first_ppc_cpu->env.gpr[3] = fdt_addr; 1536182735efSAndreas Färber first_ppc_cpu->env.gpr[5] = 0; 1537182735efSAndreas Färber first_cpu->halted = 0; 15381b718907SDavid Gibson first_ppc_cpu->env.nip = SPAPR_ENTRY_POINT; 153953018216SPaolo Bonzini 15406787d27bSMichael Roth spapr->cas_reboot = false; 154153018216SPaolo Bonzini } 154253018216SPaolo Bonzini 154328e02042SDavid Gibson static void spapr_create_nvram(sPAPRMachineState *spapr) 154453018216SPaolo Bonzini { 15452ff3de68SMarkus Armbruster DeviceState *dev = qdev_create(&spapr->vio_bus->bus, "spapr-nvram"); 15463978b863SPaolo Bonzini DriveInfo *dinfo = drive_get(IF_PFLASH, 0, 0); 154753018216SPaolo Bonzini 15483978b863SPaolo Bonzini if (dinfo) { 15496231a6daSMarkus Armbruster qdev_prop_set_drive(dev, "drive", blk_by_legacy_dinfo(dinfo), 15506231a6daSMarkus Armbruster &error_fatal); 155153018216SPaolo Bonzini } 155253018216SPaolo Bonzini 155353018216SPaolo Bonzini qdev_init_nofail(dev); 155453018216SPaolo Bonzini 155553018216SPaolo Bonzini spapr->nvram = (struct sPAPRNVRAM *)dev; 155653018216SPaolo Bonzini } 155753018216SPaolo Bonzini 155828e02042SDavid Gibson static void spapr_rtc_create(sPAPRMachineState *spapr) 155928df36a1SDavid Gibson { 1560147ff807SCédric Le Goater object_initialize(&spapr->rtc, sizeof(spapr->rtc), TYPE_SPAPR_RTC); 1561147ff807SCédric Le Goater object_property_add_child(OBJECT(spapr), "rtc", OBJECT(&spapr->rtc), 1562147ff807SCédric Le Goater &error_fatal); 1563147ff807SCédric Le Goater object_property_set_bool(OBJECT(&spapr->rtc), true, "realized", 1564147ff807SCédric Le Goater &error_fatal); 1565147ff807SCédric Le Goater object_property_add_alias(OBJECT(spapr), "rtc-time", OBJECT(&spapr->rtc), 1566147ff807SCédric Le Goater "date", &error_fatal); 156728df36a1SDavid Gibson } 156828df36a1SDavid Gibson 156953018216SPaolo Bonzini /* Returns whether we want to use VGA or not */ 157014c6a894SDavid Gibson static bool spapr_vga_init(PCIBus *pci_bus, Error **errp) 157153018216SPaolo Bonzini { 157253018216SPaolo Bonzini switch (vga_interface_type) { 157353018216SPaolo Bonzini case VGA_NONE: 15747effdaa3SMark Wu return false; 15757effdaa3SMark Wu case VGA_DEVICE: 15767effdaa3SMark Wu return true; 157753018216SPaolo Bonzini case VGA_STD: 1578b798c190SBenjamin Herrenschmidt case VGA_VIRTIO: 157953018216SPaolo Bonzini return pci_vga_init(pci_bus) != NULL; 158053018216SPaolo Bonzini default: 158114c6a894SDavid Gibson error_setg(errp, 158214c6a894SDavid Gibson "Unsupported VGA mode, only -vga std or -vga virtio is supported"); 158314c6a894SDavid Gibson return false; 158453018216SPaolo Bonzini } 158553018216SPaolo Bonzini } 158653018216SPaolo Bonzini 15874e5fe368SSuraj Jitindar Singh static int spapr_pre_load(void *opaque) 15884e5fe368SSuraj Jitindar Singh { 15894e5fe368SSuraj Jitindar Singh int rc; 15904e5fe368SSuraj Jitindar Singh 15914e5fe368SSuraj Jitindar Singh rc = spapr_caps_pre_load(opaque); 15924e5fe368SSuraj Jitindar Singh if (rc) { 15934e5fe368SSuraj Jitindar Singh return rc; 15944e5fe368SSuraj Jitindar Singh } 15954e5fe368SSuraj Jitindar Singh 15964e5fe368SSuraj Jitindar Singh return 0; 15974e5fe368SSuraj Jitindar Singh } 15984e5fe368SSuraj Jitindar Singh 1599880ae7deSDavid Gibson static int spapr_post_load(void *opaque, int version_id) 1600880ae7deSDavid Gibson { 160128e02042SDavid Gibson sPAPRMachineState *spapr = (sPAPRMachineState *)opaque; 1602880ae7deSDavid Gibson int err = 0; 1603880ae7deSDavid Gibson 1604be85537dSDavid Gibson err = spapr_caps_post_migration(spapr); 1605be85537dSDavid Gibson if (err) { 1606be85537dSDavid Gibson return err; 1607be85537dSDavid Gibson } 1608be85537dSDavid Gibson 1609a7ff1212SCédric Le Goater if (!object_dynamic_cast(OBJECT(spapr->ics), TYPE_ICS_KVM)) { 16105bc8d26dSCédric Le Goater CPUState *cs; 16115bc8d26dSCédric Le Goater CPU_FOREACH(cs) { 16125bc8d26dSCédric Le Goater PowerPCCPU *cpu = POWERPC_CPU(cs); 16135bc8d26dSCédric Le Goater icp_resend(ICP(cpu->intc)); 1614a7ff1212SCédric Le Goater } 1615a7ff1212SCédric Le Goater } 1616a7ff1212SCédric Le Goater 1617631b22eaSStefan Weil /* In earlier versions, there was no separate qdev for the PAPR 1618880ae7deSDavid Gibson * RTC, so the RTC offset was stored directly in sPAPREnvironment. 1619880ae7deSDavid Gibson * So when migrating from those versions, poke the incoming offset 1620880ae7deSDavid Gibson * value into the RTC device */ 1621880ae7deSDavid Gibson if (version_id < 3) { 1622147ff807SCédric Le Goater err = spapr_rtc_import_offset(&spapr->rtc, spapr->rtc_offset); 1623880ae7deSDavid Gibson } 1624880ae7deSDavid Gibson 16250c86b2dfSLaurent Vivier if (kvm_enabled() && spapr->patb_entry) { 1626d39c90f5SBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(first_cpu); 1627d39c90f5SBharata B Rao bool radix = !!(spapr->patb_entry & PATBE1_GR); 1628d39c90f5SBharata B Rao bool gtse = !!(cpu->env.spr[SPR_LPCR] & LPCR_GTSE); 1629d39c90f5SBharata B Rao 1630d39c90f5SBharata B Rao err = kvmppc_configure_v3_mmu(cpu, radix, gtse, spapr->patb_entry); 1631d39c90f5SBharata B Rao if (err) { 1632d39c90f5SBharata B Rao error_report("Process table config unsupported by the host"); 1633d39c90f5SBharata B Rao return -EINVAL; 1634d39c90f5SBharata B Rao } 1635d39c90f5SBharata B Rao } 1636d39c90f5SBharata B Rao 1637880ae7deSDavid Gibson return err; 1638880ae7deSDavid Gibson } 1639880ae7deSDavid Gibson 16404e5fe368SSuraj Jitindar Singh static int spapr_pre_save(void *opaque) 16414e5fe368SSuraj Jitindar Singh { 16424e5fe368SSuraj Jitindar Singh int rc; 16434e5fe368SSuraj Jitindar Singh 16444e5fe368SSuraj Jitindar Singh rc = spapr_caps_pre_save(opaque); 16454e5fe368SSuraj Jitindar Singh if (rc) { 16464e5fe368SSuraj Jitindar Singh return rc; 16474e5fe368SSuraj Jitindar Singh } 16484e5fe368SSuraj Jitindar Singh 16494e5fe368SSuraj Jitindar Singh return 0; 16504e5fe368SSuraj Jitindar Singh } 16514e5fe368SSuraj Jitindar Singh 1652880ae7deSDavid Gibson static bool version_before_3(void *opaque, int version_id) 1653880ae7deSDavid Gibson { 1654880ae7deSDavid Gibson return version_id < 3; 1655880ae7deSDavid Gibson } 1656880ae7deSDavid Gibson 1657fd38804bSDaniel Henrique Barboza static bool spapr_pending_events_needed(void *opaque) 1658fd38804bSDaniel Henrique Barboza { 1659fd38804bSDaniel Henrique Barboza sPAPRMachineState *spapr = (sPAPRMachineState *)opaque; 1660fd38804bSDaniel Henrique Barboza return !QTAILQ_EMPTY(&spapr->pending_events); 1661fd38804bSDaniel Henrique Barboza } 1662fd38804bSDaniel Henrique Barboza 1663fd38804bSDaniel Henrique Barboza static const VMStateDescription vmstate_spapr_event_entry = { 1664fd38804bSDaniel Henrique Barboza .name = "spapr_event_log_entry", 1665fd38804bSDaniel Henrique Barboza .version_id = 1, 1666fd38804bSDaniel Henrique Barboza .minimum_version_id = 1, 1667fd38804bSDaniel Henrique Barboza .fields = (VMStateField[]) { 16685341258eSDavid Gibson VMSTATE_UINT32(summary, sPAPREventLogEntry), 16695341258eSDavid Gibson VMSTATE_UINT32(extended_length, sPAPREventLogEntry), 1670fd38804bSDaniel Henrique Barboza VMSTATE_VBUFFER_ALLOC_UINT32(extended_log, sPAPREventLogEntry, 0, 16715341258eSDavid Gibson NULL, extended_length), 1672fd38804bSDaniel Henrique Barboza VMSTATE_END_OF_LIST() 1673fd38804bSDaniel Henrique Barboza }, 1674fd38804bSDaniel Henrique Barboza }; 1675fd38804bSDaniel Henrique Barboza 1676fd38804bSDaniel Henrique Barboza static const VMStateDescription vmstate_spapr_pending_events = { 1677fd38804bSDaniel Henrique Barboza .name = "spapr_pending_events", 1678fd38804bSDaniel Henrique Barboza .version_id = 1, 1679fd38804bSDaniel Henrique Barboza .minimum_version_id = 1, 1680fd38804bSDaniel Henrique Barboza .needed = spapr_pending_events_needed, 1681fd38804bSDaniel Henrique Barboza .fields = (VMStateField[]) { 1682fd38804bSDaniel Henrique Barboza VMSTATE_QTAILQ_V(pending_events, sPAPRMachineState, 1, 1683fd38804bSDaniel Henrique Barboza vmstate_spapr_event_entry, sPAPREventLogEntry, next), 1684fd38804bSDaniel Henrique Barboza VMSTATE_END_OF_LIST() 1685fd38804bSDaniel Henrique Barboza }, 1686fd38804bSDaniel Henrique Barboza }; 1687fd38804bSDaniel Henrique Barboza 168862ef3760SMichael Roth static bool spapr_ov5_cas_needed(void *opaque) 168962ef3760SMichael Roth { 169062ef3760SMichael Roth sPAPRMachineState *spapr = opaque; 169162ef3760SMichael Roth sPAPROptionVector *ov5_mask = spapr_ovec_new(); 169262ef3760SMichael Roth sPAPROptionVector *ov5_legacy = spapr_ovec_new(); 169362ef3760SMichael Roth sPAPROptionVector *ov5_removed = spapr_ovec_new(); 169462ef3760SMichael Roth bool cas_needed; 169562ef3760SMichael Roth 169662ef3760SMichael Roth /* Prior to the introduction of sPAPROptionVector, we had two option 169762ef3760SMichael Roth * vectors we dealt with: OV5_FORM1_AFFINITY, and OV5_DRCONF_MEMORY. 169862ef3760SMichael Roth * Both of these options encode machine topology into the device-tree 169962ef3760SMichael Roth * in such a way that the now-booted OS should still be able to interact 170062ef3760SMichael Roth * appropriately with QEMU regardless of what options were actually 170162ef3760SMichael Roth * negotiatied on the source side. 170262ef3760SMichael Roth * 170362ef3760SMichael Roth * As such, we can avoid migrating the CAS-negotiated options if these 170462ef3760SMichael Roth * are the only options available on the current machine/platform. 170562ef3760SMichael Roth * Since these are the only options available for pseries-2.7 and 170662ef3760SMichael Roth * earlier, this allows us to maintain old->new/new->old migration 170762ef3760SMichael Roth * compatibility. 170862ef3760SMichael Roth * 170962ef3760SMichael Roth * For QEMU 2.8+, there are additional CAS-negotiatable options available 171062ef3760SMichael Roth * via default pseries-2.8 machines and explicit command-line parameters. 171162ef3760SMichael Roth * Some of these options, like OV5_HP_EVT, *do* require QEMU to be aware 171262ef3760SMichael Roth * of the actual CAS-negotiated values to continue working properly. For 171362ef3760SMichael Roth * example, availability of memory unplug depends on knowing whether 171462ef3760SMichael Roth * OV5_HP_EVT was negotiated via CAS. 171562ef3760SMichael Roth * 171662ef3760SMichael Roth * Thus, for any cases where the set of available CAS-negotiatable 171762ef3760SMichael Roth * options extends beyond OV5_FORM1_AFFINITY and OV5_DRCONF_MEMORY, we 171862ef3760SMichael Roth * include the CAS-negotiated options in the migration stream. 171962ef3760SMichael Roth */ 172062ef3760SMichael Roth spapr_ovec_set(ov5_mask, OV5_FORM1_AFFINITY); 172162ef3760SMichael Roth spapr_ovec_set(ov5_mask, OV5_DRCONF_MEMORY); 172262ef3760SMichael Roth 172362ef3760SMichael Roth /* spapr_ovec_diff returns true if bits were removed. we avoid using 172462ef3760SMichael Roth * the mask itself since in the future it's possible "legacy" bits may be 172562ef3760SMichael Roth * removed via machine options, which could generate a false positive 172662ef3760SMichael Roth * that breaks migration. 172762ef3760SMichael Roth */ 172862ef3760SMichael Roth spapr_ovec_intersect(ov5_legacy, spapr->ov5, ov5_mask); 172962ef3760SMichael Roth cas_needed = spapr_ovec_diff(ov5_removed, spapr->ov5, ov5_legacy); 173062ef3760SMichael Roth 173162ef3760SMichael Roth spapr_ovec_cleanup(ov5_mask); 173262ef3760SMichael Roth spapr_ovec_cleanup(ov5_legacy); 173362ef3760SMichael Roth spapr_ovec_cleanup(ov5_removed); 173462ef3760SMichael Roth 173562ef3760SMichael Roth return cas_needed; 173662ef3760SMichael Roth } 173762ef3760SMichael Roth 173862ef3760SMichael Roth static const VMStateDescription vmstate_spapr_ov5_cas = { 173962ef3760SMichael Roth .name = "spapr_option_vector_ov5_cas", 174062ef3760SMichael Roth .version_id = 1, 174162ef3760SMichael Roth .minimum_version_id = 1, 174262ef3760SMichael Roth .needed = spapr_ov5_cas_needed, 174362ef3760SMichael Roth .fields = (VMStateField[]) { 174462ef3760SMichael Roth VMSTATE_STRUCT_POINTER_V(ov5_cas, sPAPRMachineState, 1, 174562ef3760SMichael Roth vmstate_spapr_ovec, sPAPROptionVector), 174662ef3760SMichael Roth VMSTATE_END_OF_LIST() 174762ef3760SMichael Roth }, 174862ef3760SMichael Roth }; 174962ef3760SMichael Roth 17509861bb3eSSuraj Jitindar Singh static bool spapr_patb_entry_needed(void *opaque) 17519861bb3eSSuraj Jitindar Singh { 17529861bb3eSSuraj Jitindar Singh sPAPRMachineState *spapr = opaque; 17539861bb3eSSuraj Jitindar Singh 17549861bb3eSSuraj Jitindar Singh return !!spapr->patb_entry; 17559861bb3eSSuraj Jitindar Singh } 17569861bb3eSSuraj Jitindar Singh 17579861bb3eSSuraj Jitindar Singh static const VMStateDescription vmstate_spapr_patb_entry = { 17589861bb3eSSuraj Jitindar Singh .name = "spapr_patb_entry", 17599861bb3eSSuraj Jitindar Singh .version_id = 1, 17609861bb3eSSuraj Jitindar Singh .minimum_version_id = 1, 17619861bb3eSSuraj Jitindar Singh .needed = spapr_patb_entry_needed, 17629861bb3eSSuraj Jitindar Singh .fields = (VMStateField[]) { 17639861bb3eSSuraj Jitindar Singh VMSTATE_UINT64(patb_entry, sPAPRMachineState), 17649861bb3eSSuraj Jitindar Singh VMSTATE_END_OF_LIST() 17659861bb3eSSuraj Jitindar Singh }, 17669861bb3eSSuraj Jitindar Singh }; 17679861bb3eSSuraj Jitindar Singh 17684be21d56SDavid Gibson static const VMStateDescription vmstate_spapr = { 17694be21d56SDavid Gibson .name = "spapr", 1770880ae7deSDavid Gibson .version_id = 3, 17714be21d56SDavid Gibson .minimum_version_id = 1, 17724e5fe368SSuraj Jitindar Singh .pre_load = spapr_pre_load, 1773880ae7deSDavid Gibson .post_load = spapr_post_load, 17744e5fe368SSuraj Jitindar Singh .pre_save = spapr_pre_save, 17754be21d56SDavid Gibson .fields = (VMStateField[]) { 1776880ae7deSDavid Gibson /* used to be @next_irq */ 1777880ae7deSDavid Gibson VMSTATE_UNUSED_BUFFER(version_before_3, 0, 4), 17784be21d56SDavid Gibson 17794be21d56SDavid Gibson /* RTC offset */ 178028e02042SDavid Gibson VMSTATE_UINT64_TEST(rtc_offset, sPAPRMachineState, version_before_3), 1781880ae7deSDavid Gibson 178228e02042SDavid Gibson VMSTATE_PPC_TIMEBASE_V(tb, sPAPRMachineState, 2), 17834be21d56SDavid Gibson VMSTATE_END_OF_LIST() 17844be21d56SDavid Gibson }, 178562ef3760SMichael Roth .subsections = (const VMStateDescription*[]) { 178662ef3760SMichael Roth &vmstate_spapr_ov5_cas, 17879861bb3eSSuraj Jitindar Singh &vmstate_spapr_patb_entry, 1788fd38804bSDaniel Henrique Barboza &vmstate_spapr_pending_events, 17894e5fe368SSuraj Jitindar Singh &vmstate_spapr_cap_htm, 17904e5fe368SSuraj Jitindar Singh &vmstate_spapr_cap_vsx, 17914e5fe368SSuraj Jitindar Singh &vmstate_spapr_cap_dfp, 17928f38eaf8SSuraj Jitindar Singh &vmstate_spapr_cap_cfpc, 179309114fd8SSuraj Jitindar Singh &vmstate_spapr_cap_sbbc, 17944be8d4e7SSuraj Jitindar Singh &vmstate_spapr_cap_ibs, 179562ef3760SMichael Roth NULL 179662ef3760SMichael Roth } 17974be21d56SDavid Gibson }; 17984be21d56SDavid Gibson 17994be21d56SDavid Gibson static int htab_save_setup(QEMUFile *f, void *opaque) 18004be21d56SDavid Gibson { 180128e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 18024be21d56SDavid Gibson 18034be21d56SDavid Gibson /* "Iteration" header */ 18043a384297SBharata B Rao if (!spapr->htab_shift) { 18053a384297SBharata B Rao qemu_put_be32(f, -1); 18063a384297SBharata B Rao } else { 18074be21d56SDavid Gibson qemu_put_be32(f, spapr->htab_shift); 18083a384297SBharata B Rao } 18094be21d56SDavid Gibson 1810e68cb8b4SAlexey Kardashevskiy if (spapr->htab) { 1811e68cb8b4SAlexey Kardashevskiy spapr->htab_save_index = 0; 1812e68cb8b4SAlexey Kardashevskiy spapr->htab_first_pass = true; 1813e68cb8b4SAlexey Kardashevskiy } else { 18143a384297SBharata B Rao if (spapr->htab_shift) { 1815e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 18164be21d56SDavid Gibson } 18173a384297SBharata B Rao } 18184be21d56SDavid Gibson 1819e68cb8b4SAlexey Kardashevskiy 1820e68cb8b4SAlexey Kardashevskiy return 0; 1821e68cb8b4SAlexey Kardashevskiy } 18224be21d56SDavid Gibson 1823332f7721SGreg Kurz static void htab_save_chunk(QEMUFile *f, sPAPRMachineState *spapr, 1824332f7721SGreg Kurz int chunkstart, int n_valid, int n_invalid) 1825332f7721SGreg Kurz { 1826332f7721SGreg Kurz qemu_put_be32(f, chunkstart); 1827332f7721SGreg Kurz qemu_put_be16(f, n_valid); 1828332f7721SGreg Kurz qemu_put_be16(f, n_invalid); 1829332f7721SGreg Kurz qemu_put_buffer(f, HPTE(spapr->htab, chunkstart), 1830332f7721SGreg Kurz HASH_PTE_SIZE_64 * n_valid); 1831332f7721SGreg Kurz } 1832332f7721SGreg Kurz 1833332f7721SGreg Kurz static void htab_save_end_marker(QEMUFile *f) 1834332f7721SGreg Kurz { 1835332f7721SGreg Kurz qemu_put_be32(f, 0); 1836332f7721SGreg Kurz qemu_put_be16(f, 0); 1837332f7721SGreg Kurz qemu_put_be16(f, 0); 1838332f7721SGreg Kurz } 1839332f7721SGreg Kurz 184028e02042SDavid Gibson static void htab_save_first_pass(QEMUFile *f, sPAPRMachineState *spapr, 18414be21d56SDavid Gibson int64_t max_ns) 18424be21d56SDavid Gibson { 1843378bc217SDavid Gibson bool has_timeout = max_ns != -1; 18444be21d56SDavid Gibson int htabslots = HTAB_SIZE(spapr) / HASH_PTE_SIZE_64; 18454be21d56SDavid Gibson int index = spapr->htab_save_index; 1846bc72ad67SAlex Bligh int64_t starttime = qemu_clock_get_ns(QEMU_CLOCK_REALTIME); 18474be21d56SDavid Gibson 18484be21d56SDavid Gibson assert(spapr->htab_first_pass); 18494be21d56SDavid Gibson 18504be21d56SDavid Gibson do { 18514be21d56SDavid Gibson int chunkstart; 18524be21d56SDavid Gibson 18534be21d56SDavid Gibson /* Consume invalid HPTEs */ 18544be21d56SDavid Gibson while ((index < htabslots) 18554be21d56SDavid Gibson && !HPTE_VALID(HPTE(spapr->htab, index))) { 18564be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 185724ec2863SMarc-André Lureau index++; 18584be21d56SDavid Gibson } 18594be21d56SDavid Gibson 18604be21d56SDavid Gibson /* Consume valid HPTEs */ 18614be21d56SDavid Gibson chunkstart = index; 1862338c25b6SSamuel Mendoza-Jonas while ((index < htabslots) && (index - chunkstart < USHRT_MAX) 18634be21d56SDavid Gibson && HPTE_VALID(HPTE(spapr->htab, index))) { 18644be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 186524ec2863SMarc-André Lureau index++; 18664be21d56SDavid Gibson } 18674be21d56SDavid Gibson 18684be21d56SDavid Gibson if (index > chunkstart) { 18694be21d56SDavid Gibson int n_valid = index - chunkstart; 18704be21d56SDavid Gibson 1871332f7721SGreg Kurz htab_save_chunk(f, spapr, chunkstart, n_valid, 0); 18724be21d56SDavid Gibson 1873378bc217SDavid Gibson if (has_timeout && 1874378bc217SDavid Gibson (qemu_clock_get_ns(QEMU_CLOCK_REALTIME) - starttime) > max_ns) { 18754be21d56SDavid Gibson break; 18764be21d56SDavid Gibson } 18774be21d56SDavid Gibson } 18784be21d56SDavid Gibson } while ((index < htabslots) && !qemu_file_rate_limit(f)); 18794be21d56SDavid Gibson 18804be21d56SDavid Gibson if (index >= htabslots) { 18814be21d56SDavid Gibson assert(index == htabslots); 18824be21d56SDavid Gibson index = 0; 18834be21d56SDavid Gibson spapr->htab_first_pass = false; 18844be21d56SDavid Gibson } 18854be21d56SDavid Gibson spapr->htab_save_index = index; 18864be21d56SDavid Gibson } 18874be21d56SDavid Gibson 188828e02042SDavid Gibson static int htab_save_later_pass(QEMUFile *f, sPAPRMachineState *spapr, 18894be21d56SDavid Gibson int64_t max_ns) 18904be21d56SDavid Gibson { 18914be21d56SDavid Gibson bool final = max_ns < 0; 18924be21d56SDavid Gibson int htabslots = HTAB_SIZE(spapr) / HASH_PTE_SIZE_64; 18934be21d56SDavid Gibson int examined = 0, sent = 0; 18944be21d56SDavid Gibson int index = spapr->htab_save_index; 1895bc72ad67SAlex Bligh int64_t starttime = qemu_clock_get_ns(QEMU_CLOCK_REALTIME); 18964be21d56SDavid Gibson 18974be21d56SDavid Gibson assert(!spapr->htab_first_pass); 18984be21d56SDavid Gibson 18994be21d56SDavid Gibson do { 19004be21d56SDavid Gibson int chunkstart, invalidstart; 19014be21d56SDavid Gibson 19024be21d56SDavid Gibson /* Consume non-dirty HPTEs */ 19034be21d56SDavid Gibson while ((index < htabslots) 19044be21d56SDavid Gibson && !HPTE_DIRTY(HPTE(spapr->htab, index))) { 19054be21d56SDavid Gibson index++; 19064be21d56SDavid Gibson examined++; 19074be21d56SDavid Gibson } 19084be21d56SDavid Gibson 19094be21d56SDavid Gibson chunkstart = index; 19104be21d56SDavid Gibson /* Consume valid dirty HPTEs */ 1911338c25b6SSamuel Mendoza-Jonas while ((index < htabslots) && (index - chunkstart < USHRT_MAX) 19124be21d56SDavid Gibson && HPTE_DIRTY(HPTE(spapr->htab, index)) 19134be21d56SDavid Gibson && HPTE_VALID(HPTE(spapr->htab, index))) { 19144be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 19154be21d56SDavid Gibson index++; 19164be21d56SDavid Gibson examined++; 19174be21d56SDavid Gibson } 19184be21d56SDavid Gibson 19194be21d56SDavid Gibson invalidstart = index; 19204be21d56SDavid Gibson /* Consume invalid dirty HPTEs */ 1921338c25b6SSamuel Mendoza-Jonas while ((index < htabslots) && (index - invalidstart < USHRT_MAX) 19224be21d56SDavid Gibson && HPTE_DIRTY(HPTE(spapr->htab, index)) 19234be21d56SDavid Gibson && !HPTE_VALID(HPTE(spapr->htab, index))) { 19244be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 19254be21d56SDavid Gibson index++; 19264be21d56SDavid Gibson examined++; 19274be21d56SDavid Gibson } 19284be21d56SDavid Gibson 19294be21d56SDavid Gibson if (index > chunkstart) { 19304be21d56SDavid Gibson int n_valid = invalidstart - chunkstart; 19314be21d56SDavid Gibson int n_invalid = index - invalidstart; 19324be21d56SDavid Gibson 1933332f7721SGreg Kurz htab_save_chunk(f, spapr, chunkstart, n_valid, n_invalid); 19344be21d56SDavid Gibson sent += index - chunkstart; 19354be21d56SDavid Gibson 1936bc72ad67SAlex Bligh if (!final && (qemu_clock_get_ns(QEMU_CLOCK_REALTIME) - starttime) > max_ns) { 19374be21d56SDavid Gibson break; 19384be21d56SDavid Gibson } 19394be21d56SDavid Gibson } 19404be21d56SDavid Gibson 19414be21d56SDavid Gibson if (examined >= htabslots) { 19424be21d56SDavid Gibson break; 19434be21d56SDavid Gibson } 19444be21d56SDavid Gibson 19454be21d56SDavid Gibson if (index >= htabslots) { 19464be21d56SDavid Gibson assert(index == htabslots); 19474be21d56SDavid Gibson index = 0; 19484be21d56SDavid Gibson } 19494be21d56SDavid Gibson } while ((examined < htabslots) && (!qemu_file_rate_limit(f) || final)); 19504be21d56SDavid Gibson 19514be21d56SDavid Gibson if (index >= htabslots) { 19524be21d56SDavid Gibson assert(index == htabslots); 19534be21d56SDavid Gibson index = 0; 19544be21d56SDavid Gibson } 19554be21d56SDavid Gibson 19564be21d56SDavid Gibson spapr->htab_save_index = index; 19574be21d56SDavid Gibson 1958e68cb8b4SAlexey Kardashevskiy return (examined >= htabslots) && (sent == 0) ? 1 : 0; 19594be21d56SDavid Gibson } 19604be21d56SDavid Gibson 1961e68cb8b4SAlexey Kardashevskiy #define MAX_ITERATION_NS 5000000 /* 5 ms */ 1962e68cb8b4SAlexey Kardashevskiy #define MAX_KVM_BUF_SIZE 2048 1963e68cb8b4SAlexey Kardashevskiy 19644be21d56SDavid Gibson static int htab_save_iterate(QEMUFile *f, void *opaque) 19654be21d56SDavid Gibson { 196628e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 1967715c5407SDavid Gibson int fd; 1968e68cb8b4SAlexey Kardashevskiy int rc = 0; 19694be21d56SDavid Gibson 19704be21d56SDavid Gibson /* Iteration header */ 19713a384297SBharata B Rao if (!spapr->htab_shift) { 19723a384297SBharata B Rao qemu_put_be32(f, -1); 1973e8cd4247SLaurent Vivier return 1; 19743a384297SBharata B Rao } else { 19754be21d56SDavid Gibson qemu_put_be32(f, 0); 19763a384297SBharata B Rao } 19774be21d56SDavid Gibson 1978e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1979e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 1980e68cb8b4SAlexey Kardashevskiy 1981715c5407SDavid Gibson fd = get_htab_fd(spapr); 1982715c5407SDavid Gibson if (fd < 0) { 1983715c5407SDavid Gibson return fd; 198401a57972SSamuel Mendoza-Jonas } 198501a57972SSamuel Mendoza-Jonas 1986715c5407SDavid Gibson rc = kvmppc_save_htab(f, fd, MAX_KVM_BUF_SIZE, MAX_ITERATION_NS); 1987e68cb8b4SAlexey Kardashevskiy if (rc < 0) { 1988e68cb8b4SAlexey Kardashevskiy return rc; 1989e68cb8b4SAlexey Kardashevskiy } 1990e68cb8b4SAlexey Kardashevskiy } else if (spapr->htab_first_pass) { 19914be21d56SDavid Gibson htab_save_first_pass(f, spapr, MAX_ITERATION_NS); 19924be21d56SDavid Gibson } else { 1993e68cb8b4SAlexey Kardashevskiy rc = htab_save_later_pass(f, spapr, MAX_ITERATION_NS); 19944be21d56SDavid Gibson } 19954be21d56SDavid Gibson 1996332f7721SGreg Kurz htab_save_end_marker(f); 19974be21d56SDavid Gibson 1998e68cb8b4SAlexey Kardashevskiy return rc; 19994be21d56SDavid Gibson } 20004be21d56SDavid Gibson 20014be21d56SDavid Gibson static int htab_save_complete(QEMUFile *f, void *opaque) 20024be21d56SDavid Gibson { 200328e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 2004715c5407SDavid Gibson int fd; 20054be21d56SDavid Gibson 20064be21d56SDavid Gibson /* Iteration header */ 20073a384297SBharata B Rao if (!spapr->htab_shift) { 20083a384297SBharata B Rao qemu_put_be32(f, -1); 20093a384297SBharata B Rao return 0; 20103a384297SBharata B Rao } else { 20114be21d56SDavid Gibson qemu_put_be32(f, 0); 20123a384297SBharata B Rao } 20134be21d56SDavid Gibson 2014e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 2015e68cb8b4SAlexey Kardashevskiy int rc; 2016e68cb8b4SAlexey Kardashevskiy 2017e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 2018e68cb8b4SAlexey Kardashevskiy 2019715c5407SDavid Gibson fd = get_htab_fd(spapr); 2020715c5407SDavid Gibson if (fd < 0) { 2021715c5407SDavid Gibson return fd; 202201a57972SSamuel Mendoza-Jonas } 202301a57972SSamuel Mendoza-Jonas 2024715c5407SDavid Gibson rc = kvmppc_save_htab(f, fd, MAX_KVM_BUF_SIZE, -1); 2025e68cb8b4SAlexey Kardashevskiy if (rc < 0) { 2026e68cb8b4SAlexey Kardashevskiy return rc; 2027e68cb8b4SAlexey Kardashevskiy } 2028e68cb8b4SAlexey Kardashevskiy } else { 2029378bc217SDavid Gibson if (spapr->htab_first_pass) { 2030378bc217SDavid Gibson htab_save_first_pass(f, spapr, -1); 2031378bc217SDavid Gibson } 20324be21d56SDavid Gibson htab_save_later_pass(f, spapr, -1); 2033e68cb8b4SAlexey Kardashevskiy } 20344be21d56SDavid Gibson 20354be21d56SDavid Gibson /* End marker */ 2036332f7721SGreg Kurz htab_save_end_marker(f); 20374be21d56SDavid Gibson 20384be21d56SDavid Gibson return 0; 20394be21d56SDavid Gibson } 20404be21d56SDavid Gibson 20414be21d56SDavid Gibson static int htab_load(QEMUFile *f, void *opaque, int version_id) 20424be21d56SDavid Gibson { 204328e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 20444be21d56SDavid Gibson uint32_t section_hdr; 2045e68cb8b4SAlexey Kardashevskiy int fd = -1; 204614b0d748SGreg Kurz Error *local_err = NULL; 20474be21d56SDavid Gibson 20484be21d56SDavid Gibson if (version_id < 1 || version_id > 1) { 204998a5d100SDavid Gibson error_report("htab_load() bad version"); 20504be21d56SDavid Gibson return -EINVAL; 20514be21d56SDavid Gibson } 20524be21d56SDavid Gibson 20534be21d56SDavid Gibson section_hdr = qemu_get_be32(f); 20544be21d56SDavid Gibson 20553a384297SBharata B Rao if (section_hdr == -1) { 20563a384297SBharata B Rao spapr_free_hpt(spapr); 20573a384297SBharata B Rao return 0; 20583a384297SBharata B Rao } 20593a384297SBharata B Rao 20604be21d56SDavid Gibson if (section_hdr) { 2061c5f54f3eSDavid Gibson /* First section gives the htab size */ 2062c5f54f3eSDavid Gibson spapr_reallocate_hpt(spapr, section_hdr, &local_err); 2063c5f54f3eSDavid Gibson if (local_err) { 2064c5f54f3eSDavid Gibson error_report_err(local_err); 20654be21d56SDavid Gibson return -EINVAL; 20664be21d56SDavid Gibson } 20674be21d56SDavid Gibson return 0; 20684be21d56SDavid Gibson } 20694be21d56SDavid Gibson 2070e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 2071e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 2072e68cb8b4SAlexey Kardashevskiy 207314b0d748SGreg Kurz fd = kvmppc_get_htab_fd(true, 0, &local_err); 2074e68cb8b4SAlexey Kardashevskiy if (fd < 0) { 207514b0d748SGreg Kurz error_report_err(local_err); 207682be8e73SGreg Kurz return fd; 2077e68cb8b4SAlexey Kardashevskiy } 2078e68cb8b4SAlexey Kardashevskiy } 2079e68cb8b4SAlexey Kardashevskiy 20804be21d56SDavid Gibson while (true) { 20814be21d56SDavid Gibson uint32_t index; 20824be21d56SDavid Gibson uint16_t n_valid, n_invalid; 20834be21d56SDavid Gibson 20844be21d56SDavid Gibson index = qemu_get_be32(f); 20854be21d56SDavid Gibson n_valid = qemu_get_be16(f); 20864be21d56SDavid Gibson n_invalid = qemu_get_be16(f); 20874be21d56SDavid Gibson 20884be21d56SDavid Gibson if ((index == 0) && (n_valid == 0) && (n_invalid == 0)) { 20894be21d56SDavid Gibson /* End of Stream */ 20904be21d56SDavid Gibson break; 20914be21d56SDavid Gibson } 20924be21d56SDavid Gibson 2093e68cb8b4SAlexey Kardashevskiy if ((index + n_valid + n_invalid) > 20944be21d56SDavid Gibson (HTAB_SIZE(spapr) / HASH_PTE_SIZE_64)) { 20954be21d56SDavid Gibson /* Bad index in stream */ 209698a5d100SDavid Gibson error_report( 209798a5d100SDavid Gibson "htab_load() bad index %d (%hd+%hd entries) in htab stream (htab_shift=%d)", 209898a5d100SDavid Gibson index, n_valid, n_invalid, spapr->htab_shift); 20994be21d56SDavid Gibson return -EINVAL; 21004be21d56SDavid Gibson } 21014be21d56SDavid Gibson 2102e68cb8b4SAlexey Kardashevskiy if (spapr->htab) { 21034be21d56SDavid Gibson if (n_valid) { 21044be21d56SDavid Gibson qemu_get_buffer(f, HPTE(spapr->htab, index), 21054be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_valid); 21064be21d56SDavid Gibson } 21074be21d56SDavid Gibson if (n_invalid) { 21084be21d56SDavid Gibson memset(HPTE(spapr->htab, index + n_valid), 0, 21094be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_invalid); 21104be21d56SDavid Gibson } 2111e68cb8b4SAlexey Kardashevskiy } else { 2112e68cb8b4SAlexey Kardashevskiy int rc; 2113e68cb8b4SAlexey Kardashevskiy 2114e68cb8b4SAlexey Kardashevskiy assert(fd >= 0); 2115e68cb8b4SAlexey Kardashevskiy 2116e68cb8b4SAlexey Kardashevskiy rc = kvmppc_load_htab_chunk(f, fd, index, n_valid, n_invalid); 2117e68cb8b4SAlexey Kardashevskiy if (rc < 0) { 2118e68cb8b4SAlexey Kardashevskiy return rc; 2119e68cb8b4SAlexey Kardashevskiy } 2120e68cb8b4SAlexey Kardashevskiy } 2121e68cb8b4SAlexey Kardashevskiy } 2122e68cb8b4SAlexey Kardashevskiy 2123e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 2124e68cb8b4SAlexey Kardashevskiy assert(fd >= 0); 2125e68cb8b4SAlexey Kardashevskiy close(fd); 21264be21d56SDavid Gibson } 21274be21d56SDavid Gibson 21284be21d56SDavid Gibson return 0; 21294be21d56SDavid Gibson } 21304be21d56SDavid Gibson 213170f794fcSJuan Quintela static void htab_save_cleanup(void *opaque) 2132c573fc03SThomas Huth { 2133c573fc03SThomas Huth sPAPRMachineState *spapr = opaque; 2134c573fc03SThomas Huth 2135c573fc03SThomas Huth close_htab_fd(spapr); 2136c573fc03SThomas Huth } 2137c573fc03SThomas Huth 21384be21d56SDavid Gibson static SaveVMHandlers savevm_htab_handlers = { 21399907e842SJuan Quintela .save_setup = htab_save_setup, 21404be21d56SDavid Gibson .save_live_iterate = htab_save_iterate, 2141a3e06c3dSDr. David Alan Gilbert .save_live_complete_precopy = htab_save_complete, 214270f794fcSJuan Quintela .save_cleanup = htab_save_cleanup, 21434be21d56SDavid Gibson .load_state = htab_load, 21444be21d56SDavid Gibson }; 21454be21d56SDavid Gibson 21465b2128d2SAlexander Graf static void spapr_boot_set(void *opaque, const char *boot_device, 21475b2128d2SAlexander Graf Error **errp) 21485b2128d2SAlexander Graf { 2149c86c1affSDaniel Henrique Barboza MachineState *machine = MACHINE(opaque); 21505b2128d2SAlexander Graf machine->boot_order = g_strdup(boot_device); 21515b2128d2SAlexander Graf } 21525b2128d2SAlexander Graf 2153224245bfSDavid Gibson static void spapr_create_lmb_dr_connectors(sPAPRMachineState *spapr) 2154224245bfSDavid Gibson { 2155224245bfSDavid Gibson MachineState *machine = MACHINE(spapr); 2156224245bfSDavid Gibson uint64_t lmb_size = SPAPR_MEMORY_BLOCK_SIZE; 2157e8f986fcSBharata B Rao uint32_t nr_lmbs = (machine->maxram_size - machine->ram_size)/lmb_size; 2158224245bfSDavid Gibson int i; 2159224245bfSDavid Gibson 2160224245bfSDavid Gibson for (i = 0; i < nr_lmbs; i++) { 2161224245bfSDavid Gibson uint64_t addr; 2162224245bfSDavid Gibson 2163e8f986fcSBharata B Rao addr = i * lmb_size + spapr->hotplug_memory.base; 21646caf3ac6SDavid Gibson spapr_dr_connector_new(OBJECT(spapr), TYPE_SPAPR_DRC_LMB, 2165224245bfSDavid Gibson addr / lmb_size); 2166224245bfSDavid Gibson } 2167224245bfSDavid Gibson } 2168224245bfSDavid Gibson 2169224245bfSDavid Gibson /* 2170224245bfSDavid Gibson * If RAM size, maxmem size and individual node mem sizes aren't aligned 2171224245bfSDavid Gibson * to SPAPR_MEMORY_BLOCK_SIZE(256MB), then refuse to start the guest 2172224245bfSDavid Gibson * since we can't support such unaligned sizes with DRCONF_MEMORY. 2173224245bfSDavid Gibson */ 21747c150d6fSDavid Gibson static void spapr_validate_node_memory(MachineState *machine, Error **errp) 2175224245bfSDavid Gibson { 2176224245bfSDavid Gibson int i; 2177224245bfSDavid Gibson 21787c150d6fSDavid Gibson if (machine->ram_size % SPAPR_MEMORY_BLOCK_SIZE) { 21797c150d6fSDavid Gibson error_setg(errp, "Memory size 0x" RAM_ADDR_FMT 21807c150d6fSDavid Gibson " is not aligned to %llu MiB", 21817c150d6fSDavid Gibson machine->ram_size, 2182224245bfSDavid Gibson SPAPR_MEMORY_BLOCK_SIZE / M_BYTE); 21837c150d6fSDavid Gibson return; 21847c150d6fSDavid Gibson } 21857c150d6fSDavid Gibson 21867c150d6fSDavid Gibson if (machine->maxram_size % SPAPR_MEMORY_BLOCK_SIZE) { 21877c150d6fSDavid Gibson error_setg(errp, "Maximum memory size 0x" RAM_ADDR_FMT 21887c150d6fSDavid Gibson " is not aligned to %llu MiB", 21897c150d6fSDavid Gibson machine->ram_size, 21907c150d6fSDavid Gibson SPAPR_MEMORY_BLOCK_SIZE / M_BYTE); 21917c150d6fSDavid Gibson return; 2192224245bfSDavid Gibson } 2193224245bfSDavid Gibson 2194224245bfSDavid Gibson for (i = 0; i < nb_numa_nodes; i++) { 2195224245bfSDavid Gibson if (numa_info[i].node_mem % SPAPR_MEMORY_BLOCK_SIZE) { 21967c150d6fSDavid Gibson error_setg(errp, 21977c150d6fSDavid Gibson "Node %d memory size 0x%" PRIx64 21987c150d6fSDavid Gibson " is not aligned to %llu MiB", 21997c150d6fSDavid Gibson i, numa_info[i].node_mem, 2200224245bfSDavid Gibson SPAPR_MEMORY_BLOCK_SIZE / M_BYTE); 22017c150d6fSDavid Gibson return; 2202224245bfSDavid Gibson } 2203224245bfSDavid Gibson } 2204224245bfSDavid Gibson } 2205224245bfSDavid Gibson 2206535455fdSIgor Mammedov /* find cpu slot in machine->possible_cpus by core_id */ 2207535455fdSIgor Mammedov static CPUArchId *spapr_find_cpu_slot(MachineState *ms, uint32_t id, int *idx) 2208535455fdSIgor Mammedov { 2209535455fdSIgor Mammedov int index = id / smp_threads; 2210535455fdSIgor Mammedov 2211535455fdSIgor Mammedov if (index >= ms->possible_cpus->len) { 2212535455fdSIgor Mammedov return NULL; 2213535455fdSIgor Mammedov } 2214535455fdSIgor Mammedov if (idx) { 2215535455fdSIgor Mammedov *idx = index; 2216535455fdSIgor Mammedov } 2217535455fdSIgor Mammedov return &ms->possible_cpus->cpus[index]; 2218535455fdSIgor Mammedov } 2219535455fdSIgor Mammedov 22200c86d0fdSDavid Gibson static void spapr_init_cpus(sPAPRMachineState *spapr) 22210c86d0fdSDavid Gibson { 22220c86d0fdSDavid Gibson MachineState *machine = MACHINE(spapr); 22230c86d0fdSDavid Gibson MachineClass *mc = MACHINE_GET_CLASS(machine); 22242e9c10ebSIgor Mammedov const char *type = spapr_get_cpu_core_type(machine->cpu_type); 2225535455fdSIgor Mammedov const CPUArchIdList *possible_cpus; 2226535455fdSIgor Mammedov int boot_cores_nr = smp_cpus / smp_threads; 22270c86d0fdSDavid Gibson int i; 22280c86d0fdSDavid Gibson 2229535455fdSIgor Mammedov possible_cpus = mc->possible_cpu_arch_ids(machine); 2230c5514d0eSIgor Mammedov if (mc->has_hotpluggable_cpus) { 22310c86d0fdSDavid Gibson if (smp_cpus % smp_threads) { 22320c86d0fdSDavid Gibson error_report("smp_cpus (%u) must be multiple of threads (%u)", 22330c86d0fdSDavid Gibson smp_cpus, smp_threads); 22340c86d0fdSDavid Gibson exit(1); 22350c86d0fdSDavid Gibson } 22360c86d0fdSDavid Gibson if (max_cpus % smp_threads) { 22370c86d0fdSDavid Gibson error_report("max_cpus (%u) must be multiple of threads (%u)", 22380c86d0fdSDavid Gibson max_cpus, smp_threads); 22390c86d0fdSDavid Gibson exit(1); 22400c86d0fdSDavid Gibson } 22410c86d0fdSDavid Gibson } else { 22420c86d0fdSDavid Gibson if (max_cpus != smp_cpus) { 22430c86d0fdSDavid Gibson error_report("This machine version does not support CPU hotplug"); 22440c86d0fdSDavid Gibson exit(1); 22450c86d0fdSDavid Gibson } 2246535455fdSIgor Mammedov boot_cores_nr = possible_cpus->len; 22470c86d0fdSDavid Gibson } 22480c86d0fdSDavid Gibson 2249535455fdSIgor Mammedov for (i = 0; i < possible_cpus->len; i++) { 22500c86d0fdSDavid Gibson int core_id = i * smp_threads; 22510c86d0fdSDavid Gibson 2252c5514d0eSIgor Mammedov if (mc->has_hotpluggable_cpus) { 22532d335818SDavid Gibson spapr_dr_connector_new(OBJECT(spapr), TYPE_SPAPR_DRC_CPU, 2254*72194664SGreg Kurz (core_id / smp_threads) * spapr->vsmt); 22550c86d0fdSDavid Gibson } 22560c86d0fdSDavid Gibson 2257535455fdSIgor Mammedov if (i < boot_cores_nr) { 22580c86d0fdSDavid Gibson Object *core = object_new(type); 22590c86d0fdSDavid Gibson int nr_threads = smp_threads; 22600c86d0fdSDavid Gibson 22610c86d0fdSDavid Gibson /* Handle the partially filled core for older machine types */ 22620c86d0fdSDavid Gibson if ((i + 1) * smp_threads >= smp_cpus) { 22630c86d0fdSDavid Gibson nr_threads = smp_cpus - i * smp_threads; 22640c86d0fdSDavid Gibson } 22650c86d0fdSDavid Gibson 22660c86d0fdSDavid Gibson object_property_set_int(core, nr_threads, "nr-threads", 22670c86d0fdSDavid Gibson &error_fatal); 22680c86d0fdSDavid Gibson object_property_set_int(core, core_id, CPU_CORE_PROP_CORE_ID, 22690c86d0fdSDavid Gibson &error_fatal); 22700c86d0fdSDavid Gibson object_property_set_bool(core, true, "realized", &error_fatal); 22710c86d0fdSDavid Gibson } 22720c86d0fdSDavid Gibson } 22730c86d0fdSDavid Gibson } 22740c86d0fdSDavid Gibson 2275fa98fbfcSSam Bobroff static void spapr_set_vsmt_mode(sPAPRMachineState *spapr, Error **errp) 2276fa98fbfcSSam Bobroff { 2277fa98fbfcSSam Bobroff Error *local_err = NULL; 2278fa98fbfcSSam Bobroff bool vsmt_user = !!spapr->vsmt; 2279fa98fbfcSSam Bobroff int kvm_smt = kvmppc_smt_threads(); 2280fa98fbfcSSam Bobroff int ret; 2281fa98fbfcSSam Bobroff 2282fa98fbfcSSam Bobroff if (!kvm_enabled() && (smp_threads > 1)) { 2283fa98fbfcSSam Bobroff error_setg(&local_err, "TCG cannot support more than 1 thread/core " 2284fa98fbfcSSam Bobroff "on a pseries machine"); 2285fa98fbfcSSam Bobroff goto out; 2286fa98fbfcSSam Bobroff } 2287fa98fbfcSSam Bobroff if (!is_power_of_2(smp_threads)) { 2288fa98fbfcSSam Bobroff error_setg(&local_err, "Cannot support %d threads/core on a pseries " 2289fa98fbfcSSam Bobroff "machine because it must be a power of 2", smp_threads); 2290fa98fbfcSSam Bobroff goto out; 2291fa98fbfcSSam Bobroff } 2292fa98fbfcSSam Bobroff 2293fa98fbfcSSam Bobroff /* Detemine the VSMT mode to use: */ 2294fa98fbfcSSam Bobroff if (vsmt_user) { 2295fa98fbfcSSam Bobroff if (spapr->vsmt < smp_threads) { 2296fa98fbfcSSam Bobroff error_setg(&local_err, "Cannot support VSMT mode %d" 2297fa98fbfcSSam Bobroff " because it must be >= threads/core (%d)", 2298fa98fbfcSSam Bobroff spapr->vsmt, smp_threads); 2299fa98fbfcSSam Bobroff goto out; 2300fa98fbfcSSam Bobroff } 2301fa98fbfcSSam Bobroff /* In this case, spapr->vsmt has been set by the command line */ 2302fa98fbfcSSam Bobroff } else { 23038904e5a7SDavid Gibson /* 23048904e5a7SDavid Gibson * Default VSMT value is tricky, because we need it to be as 23058904e5a7SDavid Gibson * consistent as possible (for migration), but this requires 23068904e5a7SDavid Gibson * changing it for at least some existing cases. We pick 8 as 23078904e5a7SDavid Gibson * the value that we'd get with KVM on POWER8, the 23088904e5a7SDavid Gibson * overwhelmingly common case in production systems. 23098904e5a7SDavid Gibson */ 23104ad64cbdSLaurent Vivier spapr->vsmt = MAX(8, smp_threads); 2311fa98fbfcSSam Bobroff } 2312fa98fbfcSSam Bobroff 2313fa98fbfcSSam Bobroff /* KVM: If necessary, set the SMT mode: */ 2314fa98fbfcSSam Bobroff if (kvm_enabled() && (spapr->vsmt != kvm_smt)) { 2315fa98fbfcSSam Bobroff ret = kvmppc_set_smt_threads(spapr->vsmt); 2316fa98fbfcSSam Bobroff if (ret) { 23171f20f2e0SDavid Gibson /* Looks like KVM isn't able to change VSMT mode */ 2318fa98fbfcSSam Bobroff error_setg(&local_err, 2319fa98fbfcSSam Bobroff "Failed to set KVM's VSMT mode to %d (errno %d)", 2320fa98fbfcSSam Bobroff spapr->vsmt, ret); 23211f20f2e0SDavid Gibson /* We can live with that if the default one is big enough 23221f20f2e0SDavid Gibson * for the number of threads, and a submultiple of the one 23231f20f2e0SDavid Gibson * we want. In this case we'll waste some vcpu ids, but 23241f20f2e0SDavid Gibson * behaviour will be correct */ 23251f20f2e0SDavid Gibson if ((kvm_smt >= smp_threads) && ((spapr->vsmt % kvm_smt) == 0)) { 23261f20f2e0SDavid Gibson warn_report_err(local_err); 23271f20f2e0SDavid Gibson local_err = NULL; 23281f20f2e0SDavid Gibson goto out; 23291f20f2e0SDavid Gibson } else { 2330fa98fbfcSSam Bobroff if (!vsmt_user) { 23311f20f2e0SDavid Gibson error_append_hint(&local_err, 23321f20f2e0SDavid Gibson "On PPC, a VM with %d threads/core" 23331f20f2e0SDavid Gibson " on a host with %d threads/core" 23341f20f2e0SDavid Gibson " requires the use of VSMT mode %d.\n", 2335fa98fbfcSSam Bobroff smp_threads, kvm_smt, spapr->vsmt); 2336fa98fbfcSSam Bobroff } 2337fa98fbfcSSam Bobroff kvmppc_hint_smt_possible(&local_err); 2338fa98fbfcSSam Bobroff goto out; 2339fa98fbfcSSam Bobroff } 2340fa98fbfcSSam Bobroff } 23411f20f2e0SDavid Gibson } 2342fa98fbfcSSam Bobroff /* else TCG: nothing to do currently */ 2343fa98fbfcSSam Bobroff out: 2344fa98fbfcSSam Bobroff error_propagate(errp, local_err); 2345fa98fbfcSSam Bobroff } 2346fa98fbfcSSam Bobroff 234753018216SPaolo Bonzini /* pSeries LPAR / sPAPR hardware init */ 2348bcb5ce08SDavid Gibson static void spapr_machine_init(MachineState *machine) 234953018216SPaolo Bonzini { 235028e02042SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(machine); 2351224245bfSDavid Gibson sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(machine); 23523ef96221SMarcel Apfelbaum const char *kernel_filename = machine->kernel_filename; 23533ef96221SMarcel Apfelbaum const char *initrd_filename = machine->initrd_filename; 235453018216SPaolo Bonzini PCIHostState *phb; 235553018216SPaolo Bonzini int i; 235653018216SPaolo Bonzini MemoryRegion *sysmem = get_system_memory(); 235753018216SPaolo Bonzini MemoryRegion *ram = g_new(MemoryRegion, 1); 2358658fa66bSAlexey Kardashevskiy MemoryRegion *rma_region; 2359658fa66bSAlexey Kardashevskiy void *rma = NULL; 236053018216SPaolo Bonzini hwaddr rma_alloc_size; 2361c86c1affSDaniel Henrique Barboza hwaddr node0_size = spapr_node0_size(machine); 2362b7d1f77aSBenjamin Herrenschmidt long load_limit, fw_size; 236353018216SPaolo Bonzini char *filename; 236430f4b05bSDavid Gibson Error *resize_hpt_err = NULL; 236553018216SPaolo Bonzini 2366226419d6SMichael S. Tsirkin msi_nonbroken = true; 236753018216SPaolo Bonzini 236853018216SPaolo Bonzini QLIST_INIT(&spapr->phbs); 23690cffce56SDavid Gibson QTAILQ_INIT(&spapr->pending_dimm_unplugs); 237053018216SPaolo Bonzini 237130f4b05bSDavid Gibson /* Check HPT resizing availability */ 237230f4b05bSDavid Gibson kvmppc_check_papr_resize_hpt(&resize_hpt_err); 237330f4b05bSDavid Gibson if (spapr->resize_hpt == SPAPR_RESIZE_HPT_DEFAULT) { 237430f4b05bSDavid Gibson /* 237530f4b05bSDavid Gibson * If the user explicitly requested a mode we should either 237630f4b05bSDavid Gibson * supply it, or fail completely (which we do below). But if 237730f4b05bSDavid Gibson * it's not set explicitly, we reset our mode to something 237830f4b05bSDavid Gibson * that works 237930f4b05bSDavid Gibson */ 238030f4b05bSDavid Gibson if (resize_hpt_err) { 238130f4b05bSDavid Gibson spapr->resize_hpt = SPAPR_RESIZE_HPT_DISABLED; 238230f4b05bSDavid Gibson error_free(resize_hpt_err); 238330f4b05bSDavid Gibson resize_hpt_err = NULL; 238430f4b05bSDavid Gibson } else { 238530f4b05bSDavid Gibson spapr->resize_hpt = smc->resize_hpt_default; 238630f4b05bSDavid Gibson } 238730f4b05bSDavid Gibson } 238830f4b05bSDavid Gibson 238930f4b05bSDavid Gibson assert(spapr->resize_hpt != SPAPR_RESIZE_HPT_DEFAULT); 239030f4b05bSDavid Gibson 239130f4b05bSDavid Gibson if ((spapr->resize_hpt != SPAPR_RESIZE_HPT_DISABLED) && resize_hpt_err) { 239230f4b05bSDavid Gibson /* 239330f4b05bSDavid Gibson * User requested HPT resize, but this host can't supply it. Bail out 239430f4b05bSDavid Gibson */ 239530f4b05bSDavid Gibson error_report_err(resize_hpt_err); 239630f4b05bSDavid Gibson exit(1); 239730f4b05bSDavid Gibson } 239830f4b05bSDavid Gibson 239953018216SPaolo Bonzini /* Allocate RMA if necessary */ 2400658fa66bSAlexey Kardashevskiy rma_alloc_size = kvmppc_alloc_rma(&rma); 240153018216SPaolo Bonzini 240253018216SPaolo Bonzini if (rma_alloc_size == -1) { 2403730fce59SThomas Huth error_report("Unable to create RMA"); 240453018216SPaolo Bonzini exit(1); 240553018216SPaolo Bonzini } 240653018216SPaolo Bonzini 2407c4177479SAlexey Kardashevskiy if (rma_alloc_size && (rma_alloc_size < node0_size)) { 240853018216SPaolo Bonzini spapr->rma_size = rma_alloc_size; 240953018216SPaolo Bonzini } else { 2410c4177479SAlexey Kardashevskiy spapr->rma_size = node0_size; 241153018216SPaolo Bonzini 241253018216SPaolo Bonzini /* With KVM, we don't actually know whether KVM supports an 241353018216SPaolo Bonzini * unbounded RMA (PR KVM) or is limited by the hash table size 241453018216SPaolo Bonzini * (HV KVM using VRMA), so we always assume the latter 241553018216SPaolo Bonzini * 241653018216SPaolo Bonzini * In that case, we also limit the initial allocations for RTAS 241753018216SPaolo Bonzini * etc... to 256M since we have no way to know what the VRMA size 241853018216SPaolo Bonzini * is going to be as it depends on the size of the hash table 241953018216SPaolo Bonzini * isn't determined yet. 242053018216SPaolo Bonzini */ 242153018216SPaolo Bonzini if (kvm_enabled()) { 242253018216SPaolo Bonzini spapr->vrma_adjust = 1; 242353018216SPaolo Bonzini spapr->rma_size = MIN(spapr->rma_size, 0x10000000); 242453018216SPaolo Bonzini } 2425912acdf4SBenjamin Herrenschmidt 2426912acdf4SBenjamin Herrenschmidt /* Actually we don't support unbounded RMA anymore since we 2427912acdf4SBenjamin Herrenschmidt * added proper emulation of HV mode. The max we can get is 2428912acdf4SBenjamin Herrenschmidt * 16G which also happens to be what we configure for PAPR 2429912acdf4SBenjamin Herrenschmidt * mode so make sure we don't do anything bigger than that 2430912acdf4SBenjamin Herrenschmidt */ 2431912acdf4SBenjamin Herrenschmidt spapr->rma_size = MIN(spapr->rma_size, 0x400000000ull); 243253018216SPaolo Bonzini } 243353018216SPaolo Bonzini 2434c4177479SAlexey Kardashevskiy if (spapr->rma_size > node0_size) { 2435d54e4d76SDavid Gibson error_report("Numa node 0 has to span the RMA (%#08"HWADDR_PRIx")", 2436c4177479SAlexey Kardashevskiy spapr->rma_size); 2437c4177479SAlexey Kardashevskiy exit(1); 2438c4177479SAlexey Kardashevskiy } 2439c4177479SAlexey Kardashevskiy 2440b7d1f77aSBenjamin Herrenschmidt /* Setup a load limit for the ramdisk leaving room for SLOF and FDT */ 2441b7d1f77aSBenjamin Herrenschmidt load_limit = MIN(spapr->rma_size, RTAS_MAX_ADDR) - FW_OVERHEAD; 244253018216SPaolo Bonzini 24437b565160SDavid Gibson /* Set up Interrupt Controller before we create the VCPUs */ 244471cd4dacSCédric Le Goater xics_system_init(machine, XICS_IRQS_SPAPR, &error_fatal); 24457b565160SDavid Gibson 2446dc1b5eeeSGreg Kurz /* Set up containers for ibm,client-architecture-support negotiated options 2447dc1b5eeeSGreg Kurz */ 2448facdb8b6SMichael Roth spapr->ov5 = spapr_ovec_new(); 2449facdb8b6SMichael Roth spapr->ov5_cas = spapr_ovec_new(); 2450facdb8b6SMichael Roth 2451224245bfSDavid Gibson if (smc->dr_lmb_enabled) { 2452facdb8b6SMichael Roth spapr_ovec_set(spapr->ov5, OV5_DRCONF_MEMORY); 24537c150d6fSDavid Gibson spapr_validate_node_memory(machine, &error_fatal); 2454224245bfSDavid Gibson } 2455224245bfSDavid Gibson 2456417ece33SMichael Roth spapr_ovec_set(spapr->ov5, OV5_FORM1_AFFINITY); 2457545d6e2bSSuraj Jitindar Singh if (!kvm_enabled() || kvmppc_has_cap_mmu_radix()) { 2458545d6e2bSSuraj Jitindar Singh /* KVM and TCG always allow GTSE with radix... */ 24599fb4541fSSam Bobroff spapr_ovec_set(spapr->ov5, OV5_MMU_RADIX_GTSE); 24609fb4541fSSam Bobroff } 24619fb4541fSSam Bobroff /* ... but not with hash (currently). */ 2462417ece33SMichael Roth 2463ffbb1705SMichael Roth /* advertise support for dedicated HP event source to guests */ 2464ffbb1705SMichael Roth if (spapr->use_hotplug_event_source) { 2465ffbb1705SMichael Roth spapr_ovec_set(spapr->ov5, OV5_HP_EVT); 2466ffbb1705SMichael Roth } 2467ffbb1705SMichael Roth 24682772cf6bSDavid Gibson /* advertise support for HPT resizing */ 24692772cf6bSDavid Gibson if (spapr->resize_hpt != SPAPR_RESIZE_HPT_DISABLED) { 24702772cf6bSDavid Gibson spapr_ovec_set(spapr->ov5, OV5_HPT_RESIZE); 24712772cf6bSDavid Gibson } 24722772cf6bSDavid Gibson 247353018216SPaolo Bonzini /* init CPUs */ 2474fa98fbfcSSam Bobroff spapr_set_vsmt_mode(spapr, &error_fatal); 2475fa98fbfcSSam Bobroff 24760c86d0fdSDavid Gibson spapr_init_cpus(spapr); 247753018216SPaolo Bonzini 2478026bfd89SDavid Gibson if (kvm_enabled()) { 2479026bfd89SDavid Gibson /* Enable H_LOGICAL_CI_* so SLOF can talk to in-kernel devices */ 2480026bfd89SDavid Gibson kvmppc_enable_logical_ci_hcalls(); 2481ef9971ddSAlexey Kardashevskiy kvmppc_enable_set_mode_hcall(); 24825145ad4fSNathan Whitehorn 24835145ad4fSNathan Whitehorn /* H_CLEAR_MOD/_REF are mandatory in PAPR, but off by default */ 24845145ad4fSNathan Whitehorn kvmppc_enable_clear_ref_mod_hcalls(); 2485026bfd89SDavid Gibson } 2486026bfd89SDavid Gibson 248753018216SPaolo Bonzini /* allocate RAM */ 2488f92f5da1SAlexey Kardashevskiy memory_region_allocate_system_memory(ram, NULL, "ppc_spapr.ram", 2489fb164994SDavid Gibson machine->ram_size); 2490f92f5da1SAlexey Kardashevskiy memory_region_add_subregion(sysmem, 0, ram); 249153018216SPaolo Bonzini 2492658fa66bSAlexey Kardashevskiy if (rma_alloc_size && rma) { 2493658fa66bSAlexey Kardashevskiy rma_region = g_new(MemoryRegion, 1); 2494658fa66bSAlexey Kardashevskiy memory_region_init_ram_ptr(rma_region, NULL, "ppc_spapr.rma", 2495658fa66bSAlexey Kardashevskiy rma_alloc_size, rma); 2496658fa66bSAlexey Kardashevskiy vmstate_register_ram_global(rma_region); 2497658fa66bSAlexey Kardashevskiy memory_region_add_subregion(sysmem, 0, rma_region); 2498658fa66bSAlexey Kardashevskiy } 2499658fa66bSAlexey Kardashevskiy 25004a1c9cf0SBharata B Rao /* initialize hotplug memory address space */ 25014a1c9cf0SBharata B Rao if (machine->ram_size < machine->maxram_size) { 25024a1c9cf0SBharata B Rao ram_addr_t hotplug_mem_size = machine->maxram_size - machine->ram_size; 250371c9a3ddSBharata B Rao /* 250471c9a3ddSBharata B Rao * Limit the number of hotpluggable memory slots to half the number 250571c9a3ddSBharata B Rao * slots that KVM supports, leaving the other half for PCI and other 250671c9a3ddSBharata B Rao * devices. However ensure that number of slots doesn't drop below 32. 250771c9a3ddSBharata B Rao */ 250871c9a3ddSBharata B Rao int max_memslots = kvm_enabled() ? kvm_get_max_memslots() / 2 : 250971c9a3ddSBharata B Rao SPAPR_MAX_RAM_SLOTS; 25104a1c9cf0SBharata B Rao 251171c9a3ddSBharata B Rao if (max_memslots < SPAPR_MAX_RAM_SLOTS) { 251271c9a3ddSBharata B Rao max_memslots = SPAPR_MAX_RAM_SLOTS; 251371c9a3ddSBharata B Rao } 251471c9a3ddSBharata B Rao if (machine->ram_slots > max_memslots) { 2515d54e4d76SDavid Gibson error_report("Specified number of memory slots %" 2516d54e4d76SDavid Gibson PRIu64" exceeds max supported %d", 251771c9a3ddSBharata B Rao machine->ram_slots, max_memslots); 2518d54e4d76SDavid Gibson exit(1); 25194a1c9cf0SBharata B Rao } 25204a1c9cf0SBharata B Rao 25214a1c9cf0SBharata B Rao spapr->hotplug_memory.base = ROUND_UP(machine->ram_size, 25224a1c9cf0SBharata B Rao SPAPR_HOTPLUG_MEM_ALIGN); 25234a1c9cf0SBharata B Rao memory_region_init(&spapr->hotplug_memory.mr, OBJECT(spapr), 25244a1c9cf0SBharata B Rao "hotplug-memory", hotplug_mem_size); 25254a1c9cf0SBharata B Rao memory_region_add_subregion(sysmem, spapr->hotplug_memory.base, 25264a1c9cf0SBharata B Rao &spapr->hotplug_memory.mr); 25274a1c9cf0SBharata B Rao } 25284a1c9cf0SBharata B Rao 2529224245bfSDavid Gibson if (smc->dr_lmb_enabled) { 2530224245bfSDavid Gibson spapr_create_lmb_dr_connectors(spapr); 2531224245bfSDavid Gibson } 2532224245bfSDavid Gibson 253353018216SPaolo Bonzini filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, "spapr-rtas.bin"); 25344c56440dSStefan Weil if (!filename) { 2535730fce59SThomas Huth error_report("Could not find LPAR rtas '%s'", "spapr-rtas.bin"); 25364c56440dSStefan Weil exit(1); 25374c56440dSStefan Weil } 2538b7d1f77aSBenjamin Herrenschmidt spapr->rtas_size = get_image_size(filename); 25398afc22a2SZhou Jie if (spapr->rtas_size < 0) { 25408afc22a2SZhou Jie error_report("Could not get size of LPAR rtas '%s'", filename); 25418afc22a2SZhou Jie exit(1); 25428afc22a2SZhou Jie } 2543b7d1f77aSBenjamin Herrenschmidt spapr->rtas_blob = g_malloc(spapr->rtas_size); 2544b7d1f77aSBenjamin Herrenschmidt if (load_image_size(filename, spapr->rtas_blob, spapr->rtas_size) < 0) { 2545730fce59SThomas Huth error_report("Could not load LPAR rtas '%s'", filename); 254653018216SPaolo Bonzini exit(1); 254753018216SPaolo Bonzini } 254853018216SPaolo Bonzini if (spapr->rtas_size > RTAS_MAX_SIZE) { 2549730fce59SThomas Huth error_report("RTAS too big ! 0x%zx bytes (max is 0x%x)", 25502f285bddSPeter Maydell (size_t)spapr->rtas_size, RTAS_MAX_SIZE); 255153018216SPaolo Bonzini exit(1); 255253018216SPaolo Bonzini } 255353018216SPaolo Bonzini g_free(filename); 255453018216SPaolo Bonzini 2555ffbb1705SMichael Roth /* Set up RTAS event infrastructure */ 255653018216SPaolo Bonzini spapr_events_init(spapr); 255753018216SPaolo Bonzini 255812f42174SDavid Gibson /* Set up the RTC RTAS interfaces */ 255928df36a1SDavid Gibson spapr_rtc_create(spapr); 256012f42174SDavid Gibson 256153018216SPaolo Bonzini /* Set up VIO bus */ 256253018216SPaolo Bonzini spapr->vio_bus = spapr_vio_bus_init(); 256353018216SPaolo Bonzini 256453018216SPaolo Bonzini for (i = 0; i < MAX_SERIAL_PORTS; i++) { 256553018216SPaolo Bonzini if (serial_hds[i]) { 256653018216SPaolo Bonzini spapr_vty_create(spapr->vio_bus, serial_hds[i]); 256753018216SPaolo Bonzini } 256853018216SPaolo Bonzini } 256953018216SPaolo Bonzini 257053018216SPaolo Bonzini /* We always have at least the nvram device on VIO */ 257153018216SPaolo Bonzini spapr_create_nvram(spapr); 257253018216SPaolo Bonzini 257353018216SPaolo Bonzini /* Set up PCI */ 257453018216SPaolo Bonzini spapr_pci_rtas_init(); 257553018216SPaolo Bonzini 257689dfd6e1SDavid Gibson phb = spapr_create_phb(spapr, 0); 257753018216SPaolo Bonzini 257853018216SPaolo Bonzini for (i = 0; i < nb_nics; i++) { 257953018216SPaolo Bonzini NICInfo *nd = &nd_table[i]; 258053018216SPaolo Bonzini 258153018216SPaolo Bonzini if (!nd->model) { 258253018216SPaolo Bonzini nd->model = g_strdup("ibmveth"); 258353018216SPaolo Bonzini } 258453018216SPaolo Bonzini 258553018216SPaolo Bonzini if (strcmp(nd->model, "ibmveth") == 0) { 258653018216SPaolo Bonzini spapr_vlan_create(spapr->vio_bus, nd); 258753018216SPaolo Bonzini } else { 258829b358f9SDavid Gibson pci_nic_init_nofail(&nd_table[i], phb->bus, nd->model, NULL); 258953018216SPaolo Bonzini } 259053018216SPaolo Bonzini } 259153018216SPaolo Bonzini 259253018216SPaolo Bonzini for (i = 0; i <= drive_get_max_bus(IF_SCSI); i++) { 259353018216SPaolo Bonzini spapr_vscsi_create(spapr->vio_bus); 259453018216SPaolo Bonzini } 259553018216SPaolo Bonzini 259653018216SPaolo Bonzini /* Graphics */ 259714c6a894SDavid Gibson if (spapr_vga_init(phb->bus, &error_fatal)) { 259853018216SPaolo Bonzini spapr->has_graphics = true; 2599c6e76503SPaolo Bonzini machine->usb |= defaults_enabled() && !machine->usb_disabled; 260053018216SPaolo Bonzini } 260153018216SPaolo Bonzini 26024ee9ced9SMarcel Apfelbaum if (machine->usb) { 260357040d45SThomas Huth if (smc->use_ohci_by_default) { 260453018216SPaolo Bonzini pci_create_simple(phb->bus, -1, "pci-ohci"); 260557040d45SThomas Huth } else { 260657040d45SThomas Huth pci_create_simple(phb->bus, -1, "nec-usb-xhci"); 260757040d45SThomas Huth } 2608c86580b8SMarkus Armbruster 260953018216SPaolo Bonzini if (spapr->has_graphics) { 2610c86580b8SMarkus Armbruster USBBus *usb_bus = usb_bus_find(-1); 2611c86580b8SMarkus Armbruster 2612c86580b8SMarkus Armbruster usb_create_simple(usb_bus, "usb-kbd"); 2613c86580b8SMarkus Armbruster usb_create_simple(usb_bus, "usb-mouse"); 261453018216SPaolo Bonzini } 261553018216SPaolo Bonzini } 261653018216SPaolo Bonzini 261753018216SPaolo Bonzini if (spapr->rma_size < (MIN_RMA_SLOF << 20)) { 2618d54e4d76SDavid Gibson error_report( 2619d54e4d76SDavid Gibson "pSeries SLOF firmware requires >= %ldM guest RMA (Real Mode Area memory)", 2620d54e4d76SDavid Gibson MIN_RMA_SLOF); 262153018216SPaolo Bonzini exit(1); 262253018216SPaolo Bonzini } 262353018216SPaolo Bonzini 262453018216SPaolo Bonzini if (kernel_filename) { 262553018216SPaolo Bonzini uint64_t lowaddr = 0; 262653018216SPaolo Bonzini 2627a19f7fb0SDavid Gibson spapr->kernel_size = load_elf(kernel_filename, translate_kernel_address, 2628a19f7fb0SDavid Gibson NULL, NULL, &lowaddr, NULL, 1, 2629a19f7fb0SDavid Gibson PPC_ELF_MACHINE, 0, 0); 2630a19f7fb0SDavid Gibson if (spapr->kernel_size == ELF_LOAD_WRONG_ENDIAN) { 2631a19f7fb0SDavid Gibson spapr->kernel_size = load_elf(kernel_filename, 2632a19f7fb0SDavid Gibson translate_kernel_address, NULL, NULL, 2633a19f7fb0SDavid Gibson &lowaddr, NULL, 0, PPC_ELF_MACHINE, 26347ef295eaSPeter Crosthwaite 0, 0); 2635a19f7fb0SDavid Gibson spapr->kernel_le = spapr->kernel_size > 0; 263616457e7fSBenjamin Herrenschmidt } 2637a19f7fb0SDavid Gibson if (spapr->kernel_size < 0) { 2638a19f7fb0SDavid Gibson error_report("error loading %s: %s", kernel_filename, 2639a19f7fb0SDavid Gibson load_elf_strerror(spapr->kernel_size)); 264053018216SPaolo Bonzini exit(1); 264153018216SPaolo Bonzini } 264253018216SPaolo Bonzini 264353018216SPaolo Bonzini /* load initrd */ 264453018216SPaolo Bonzini if (initrd_filename) { 264553018216SPaolo Bonzini /* Try to locate the initrd in the gap between the kernel 264653018216SPaolo Bonzini * and the firmware. Add a bit of space just in case 264753018216SPaolo Bonzini */ 2648a19f7fb0SDavid Gibson spapr->initrd_base = (KERNEL_LOAD_ADDR + spapr->kernel_size 2649a19f7fb0SDavid Gibson + 0x1ffff) & ~0xffff; 2650a19f7fb0SDavid Gibson spapr->initrd_size = load_image_targphys(initrd_filename, 2651a19f7fb0SDavid Gibson spapr->initrd_base, 2652a19f7fb0SDavid Gibson load_limit 2653a19f7fb0SDavid Gibson - spapr->initrd_base); 2654a19f7fb0SDavid Gibson if (spapr->initrd_size < 0) { 2655d54e4d76SDavid Gibson error_report("could not load initial ram disk '%s'", 265653018216SPaolo Bonzini initrd_filename); 265753018216SPaolo Bonzini exit(1); 265853018216SPaolo Bonzini } 265953018216SPaolo Bonzini } 266053018216SPaolo Bonzini } 266153018216SPaolo Bonzini 26628e7ea787SAndreas Färber if (bios_name == NULL) { 26638e7ea787SAndreas Färber bios_name = FW_FILE_NAME; 26648e7ea787SAndreas Färber } 26658e7ea787SAndreas Färber filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name); 26664c56440dSStefan Weil if (!filename) { 266768fea5a0SThomas Huth error_report("Could not find LPAR firmware '%s'", bios_name); 26684c56440dSStefan Weil exit(1); 26694c56440dSStefan Weil } 267053018216SPaolo Bonzini fw_size = load_image_targphys(filename, 0, FW_MAX_SIZE); 267168fea5a0SThomas Huth if (fw_size <= 0) { 267268fea5a0SThomas Huth error_report("Could not load LPAR firmware '%s'", filename); 267353018216SPaolo Bonzini exit(1); 267453018216SPaolo Bonzini } 267553018216SPaolo Bonzini g_free(filename); 267653018216SPaolo Bonzini 267728e02042SDavid Gibson /* FIXME: Should register things through the MachineState's qdev 267828e02042SDavid Gibson * interface, this is a legacy from the sPAPREnvironment structure 267928e02042SDavid Gibson * which predated MachineState but had a similar function */ 26804be21d56SDavid Gibson vmstate_register(NULL, 0, &vmstate_spapr, spapr); 26814be21d56SDavid Gibson register_savevm_live(NULL, "spapr/htab", -1, 1, 26824be21d56SDavid Gibson &savevm_htab_handlers, spapr); 26834be21d56SDavid Gibson 26845b2128d2SAlexander Graf qemu_register_boot_set(spapr_boot_set, spapr); 268542043e4fSLaurent Vivier 268642043e4fSLaurent Vivier if (kvm_enabled()) { 26873dc410aeSAlexey Kardashevskiy /* to stop and start vmclock */ 268842043e4fSLaurent Vivier qemu_add_vm_change_state_handler(cpu_ppc_clock_vm_state_change, 268942043e4fSLaurent Vivier &spapr->tb); 26903dc410aeSAlexey Kardashevskiy 26913dc410aeSAlexey Kardashevskiy kvmppc_spapr_enable_inkernel_multitce(); 269242043e4fSLaurent Vivier } 269353018216SPaolo Bonzini } 269453018216SPaolo Bonzini 2695135a129aSAneesh Kumar K.V static int spapr_kvm_type(const char *vm_type) 2696135a129aSAneesh Kumar K.V { 2697135a129aSAneesh Kumar K.V if (!vm_type) { 2698135a129aSAneesh Kumar K.V return 0; 2699135a129aSAneesh Kumar K.V } 2700135a129aSAneesh Kumar K.V 2701135a129aSAneesh Kumar K.V if (!strcmp(vm_type, "HV")) { 2702135a129aSAneesh Kumar K.V return 1; 2703135a129aSAneesh Kumar K.V } 2704135a129aSAneesh Kumar K.V 2705135a129aSAneesh Kumar K.V if (!strcmp(vm_type, "PR")) { 2706135a129aSAneesh Kumar K.V return 2; 2707135a129aSAneesh Kumar K.V } 2708135a129aSAneesh Kumar K.V 2709135a129aSAneesh Kumar K.V error_report("Unknown kvm-type specified '%s'", vm_type); 2710135a129aSAneesh Kumar K.V exit(1); 2711135a129aSAneesh Kumar K.V } 2712135a129aSAneesh Kumar K.V 271371461b0fSAlexey Kardashevskiy /* 2714627b84f4SGonglei * Implementation of an interface to adjust firmware path 271571461b0fSAlexey Kardashevskiy * for the bootindex property handling. 271671461b0fSAlexey Kardashevskiy */ 271771461b0fSAlexey Kardashevskiy static char *spapr_get_fw_dev_path(FWPathProvider *p, BusState *bus, 271871461b0fSAlexey Kardashevskiy DeviceState *dev) 271971461b0fSAlexey Kardashevskiy { 272071461b0fSAlexey Kardashevskiy #define CAST(type, obj, name) \ 272171461b0fSAlexey Kardashevskiy ((type *)object_dynamic_cast(OBJECT(obj), (name))) 272271461b0fSAlexey Kardashevskiy SCSIDevice *d = CAST(SCSIDevice, dev, TYPE_SCSI_DEVICE); 272371461b0fSAlexey Kardashevskiy sPAPRPHBState *phb = CAST(sPAPRPHBState, dev, TYPE_SPAPR_PCI_HOST_BRIDGE); 2724c4e13492SFelipe Franciosi VHostSCSICommon *vsc = CAST(VHostSCSICommon, dev, TYPE_VHOST_SCSI_COMMON); 272571461b0fSAlexey Kardashevskiy 272671461b0fSAlexey Kardashevskiy if (d) { 272771461b0fSAlexey Kardashevskiy void *spapr = CAST(void, bus->parent, "spapr-vscsi"); 272871461b0fSAlexey Kardashevskiy VirtIOSCSI *virtio = CAST(VirtIOSCSI, bus->parent, TYPE_VIRTIO_SCSI); 272971461b0fSAlexey Kardashevskiy USBDevice *usb = CAST(USBDevice, bus->parent, TYPE_USB_DEVICE); 273071461b0fSAlexey Kardashevskiy 273171461b0fSAlexey Kardashevskiy if (spapr) { 273271461b0fSAlexey Kardashevskiy /* 273371461b0fSAlexey Kardashevskiy * Replace "channel@0/disk@0,0" with "disk@8000000000000000": 273471461b0fSAlexey Kardashevskiy * We use SRP luns of the form 8000 | (bus << 8) | (id << 5) | lun 273571461b0fSAlexey Kardashevskiy * in the top 16 bits of the 64-bit LUN 273671461b0fSAlexey Kardashevskiy */ 273771461b0fSAlexey Kardashevskiy unsigned id = 0x8000 | (d->id << 8) | d->lun; 273871461b0fSAlexey Kardashevskiy return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev), 273971461b0fSAlexey Kardashevskiy (uint64_t)id << 48); 274071461b0fSAlexey Kardashevskiy } else if (virtio) { 274171461b0fSAlexey Kardashevskiy /* 274271461b0fSAlexey Kardashevskiy * We use SRP luns of the form 01000000 | (target << 8) | lun 274371461b0fSAlexey Kardashevskiy * in the top 32 bits of the 64-bit LUN 274471461b0fSAlexey Kardashevskiy * Note: the quote above is from SLOF and it is wrong, 274571461b0fSAlexey Kardashevskiy * the actual binding is: 274671461b0fSAlexey Kardashevskiy * swap 0100 or 10 << or 20 << ( target lun-id -- srplun ) 274771461b0fSAlexey Kardashevskiy */ 274871461b0fSAlexey Kardashevskiy unsigned id = 0x1000000 | (d->id << 16) | d->lun; 2749bac658d1SThomas Huth if (d->lun >= 256) { 2750bac658d1SThomas Huth /* Use the LUN "flat space addressing method" */ 2751bac658d1SThomas Huth id |= 0x4000; 2752bac658d1SThomas Huth } 275371461b0fSAlexey Kardashevskiy return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev), 275471461b0fSAlexey Kardashevskiy (uint64_t)id << 32); 275571461b0fSAlexey Kardashevskiy } else if (usb) { 275671461b0fSAlexey Kardashevskiy /* 275771461b0fSAlexey Kardashevskiy * We use SRP luns of the form 01000000 | (usb-port << 16) | lun 275871461b0fSAlexey Kardashevskiy * in the top 32 bits of the 64-bit LUN 275971461b0fSAlexey Kardashevskiy */ 276071461b0fSAlexey Kardashevskiy unsigned usb_port = atoi(usb->port->path); 276171461b0fSAlexey Kardashevskiy unsigned id = 0x1000000 | (usb_port << 16) | d->lun; 276271461b0fSAlexey Kardashevskiy return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev), 276371461b0fSAlexey Kardashevskiy (uint64_t)id << 32); 276471461b0fSAlexey Kardashevskiy } 276571461b0fSAlexey Kardashevskiy } 276671461b0fSAlexey Kardashevskiy 2767b99260ebSThomas Huth /* 2768b99260ebSThomas Huth * SLOF probes the USB devices, and if it recognizes that the device is a 2769b99260ebSThomas Huth * storage device, it changes its name to "storage" instead of "usb-host", 2770b99260ebSThomas Huth * and additionally adds a child node for the SCSI LUN, so the correct 2771b99260ebSThomas Huth * boot path in SLOF is something like .../storage@1/disk@xxx" instead. 2772b99260ebSThomas Huth */ 2773b99260ebSThomas Huth if (strcmp("usb-host", qdev_fw_name(dev)) == 0) { 2774b99260ebSThomas Huth USBDevice *usbdev = CAST(USBDevice, dev, TYPE_USB_DEVICE); 2775b99260ebSThomas Huth if (usb_host_dev_is_scsi_storage(usbdev)) { 2776b99260ebSThomas Huth return g_strdup_printf("storage@%s/disk", usbdev->port->path); 2777b99260ebSThomas Huth } 2778b99260ebSThomas Huth } 2779b99260ebSThomas Huth 278071461b0fSAlexey Kardashevskiy if (phb) { 278171461b0fSAlexey Kardashevskiy /* Replace "pci" with "pci@800000020000000" */ 278271461b0fSAlexey Kardashevskiy return g_strdup_printf("pci@%"PRIX64, phb->buid); 278371461b0fSAlexey Kardashevskiy } 278471461b0fSAlexey Kardashevskiy 2785c4e13492SFelipe Franciosi if (vsc) { 2786c4e13492SFelipe Franciosi /* Same logic as virtio above */ 2787c4e13492SFelipe Franciosi unsigned id = 0x1000000 | (vsc->target << 16) | vsc->lun; 2788c4e13492SFelipe Franciosi return g_strdup_printf("disk@%"PRIX64, (uint64_t)id << 32); 2789c4e13492SFelipe Franciosi } 2790c4e13492SFelipe Franciosi 27914871dd4cSThomas Huth if (g_str_equal("pci-bridge", qdev_fw_name(dev))) { 27924871dd4cSThomas Huth /* SLOF uses "pci" instead of "pci-bridge" for PCI bridges */ 27934871dd4cSThomas Huth PCIDevice *pcidev = CAST(PCIDevice, dev, TYPE_PCI_DEVICE); 27944871dd4cSThomas Huth return g_strdup_printf("pci@%x", PCI_SLOT(pcidev->devfn)); 27954871dd4cSThomas Huth } 27964871dd4cSThomas Huth 279771461b0fSAlexey Kardashevskiy return NULL; 279871461b0fSAlexey Kardashevskiy } 279971461b0fSAlexey Kardashevskiy 280023825581SEduardo Habkost static char *spapr_get_kvm_type(Object *obj, Error **errp) 280123825581SEduardo Habkost { 280228e02042SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 280323825581SEduardo Habkost 280428e02042SDavid Gibson return g_strdup(spapr->kvm_type); 280523825581SEduardo Habkost } 280623825581SEduardo Habkost 280723825581SEduardo Habkost static void spapr_set_kvm_type(Object *obj, const char *value, Error **errp) 280823825581SEduardo Habkost { 280928e02042SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 281023825581SEduardo Habkost 281128e02042SDavid Gibson g_free(spapr->kvm_type); 281228e02042SDavid Gibson spapr->kvm_type = g_strdup(value); 281323825581SEduardo Habkost } 281423825581SEduardo Habkost 2815f6229214SMichael Roth static bool spapr_get_modern_hotplug_events(Object *obj, Error **errp) 2816f6229214SMichael Roth { 2817f6229214SMichael Roth sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 2818f6229214SMichael Roth 2819f6229214SMichael Roth return spapr->use_hotplug_event_source; 2820f6229214SMichael Roth } 2821f6229214SMichael Roth 2822f6229214SMichael Roth static void spapr_set_modern_hotplug_events(Object *obj, bool value, 2823f6229214SMichael Roth Error **errp) 2824f6229214SMichael Roth { 2825f6229214SMichael Roth sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 2826f6229214SMichael Roth 2827f6229214SMichael Roth spapr->use_hotplug_event_source = value; 2828f6229214SMichael Roth } 2829f6229214SMichael Roth 283030f4b05bSDavid Gibson static char *spapr_get_resize_hpt(Object *obj, Error **errp) 283130f4b05bSDavid Gibson { 283230f4b05bSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 283330f4b05bSDavid Gibson 283430f4b05bSDavid Gibson switch (spapr->resize_hpt) { 283530f4b05bSDavid Gibson case SPAPR_RESIZE_HPT_DEFAULT: 283630f4b05bSDavid Gibson return g_strdup("default"); 283730f4b05bSDavid Gibson case SPAPR_RESIZE_HPT_DISABLED: 283830f4b05bSDavid Gibson return g_strdup("disabled"); 283930f4b05bSDavid Gibson case SPAPR_RESIZE_HPT_ENABLED: 284030f4b05bSDavid Gibson return g_strdup("enabled"); 284130f4b05bSDavid Gibson case SPAPR_RESIZE_HPT_REQUIRED: 284230f4b05bSDavid Gibson return g_strdup("required"); 284330f4b05bSDavid Gibson } 284430f4b05bSDavid Gibson g_assert_not_reached(); 284530f4b05bSDavid Gibson } 284630f4b05bSDavid Gibson 284730f4b05bSDavid Gibson static void spapr_set_resize_hpt(Object *obj, const char *value, Error **errp) 284830f4b05bSDavid Gibson { 284930f4b05bSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 285030f4b05bSDavid Gibson 285130f4b05bSDavid Gibson if (strcmp(value, "default") == 0) { 285230f4b05bSDavid Gibson spapr->resize_hpt = SPAPR_RESIZE_HPT_DEFAULT; 285330f4b05bSDavid Gibson } else if (strcmp(value, "disabled") == 0) { 285430f4b05bSDavid Gibson spapr->resize_hpt = SPAPR_RESIZE_HPT_DISABLED; 285530f4b05bSDavid Gibson } else if (strcmp(value, "enabled") == 0) { 285630f4b05bSDavid Gibson spapr->resize_hpt = SPAPR_RESIZE_HPT_ENABLED; 285730f4b05bSDavid Gibson } else if (strcmp(value, "required") == 0) { 285830f4b05bSDavid Gibson spapr->resize_hpt = SPAPR_RESIZE_HPT_REQUIRED; 285930f4b05bSDavid Gibson } else { 286030f4b05bSDavid Gibson error_setg(errp, "Bad value for \"resize-hpt\" property"); 286130f4b05bSDavid Gibson } 286230f4b05bSDavid Gibson } 286330f4b05bSDavid Gibson 2864fa98fbfcSSam Bobroff static void spapr_get_vsmt(Object *obj, Visitor *v, const char *name, 2865fa98fbfcSSam Bobroff void *opaque, Error **errp) 2866fa98fbfcSSam Bobroff { 2867fa98fbfcSSam Bobroff visit_type_uint32(v, name, (uint32_t *)opaque, errp); 2868fa98fbfcSSam Bobroff } 2869fa98fbfcSSam Bobroff 2870fa98fbfcSSam Bobroff static void spapr_set_vsmt(Object *obj, Visitor *v, const char *name, 2871fa98fbfcSSam Bobroff void *opaque, Error **errp) 2872fa98fbfcSSam Bobroff { 2873fa98fbfcSSam Bobroff visit_type_uint32(v, name, (uint32_t *)opaque, errp); 2874fa98fbfcSSam Bobroff } 2875fa98fbfcSSam Bobroff 2876bcb5ce08SDavid Gibson static void spapr_instance_init(Object *obj) 287723825581SEduardo Habkost { 2878715c5407SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 2879715c5407SDavid Gibson 2880715c5407SDavid Gibson spapr->htab_fd = -1; 2881f6229214SMichael Roth spapr->use_hotplug_event_source = true; 288223825581SEduardo Habkost object_property_add_str(obj, "kvm-type", 288323825581SEduardo Habkost spapr_get_kvm_type, spapr_set_kvm_type, NULL); 288449d2e648SMarcel Apfelbaum object_property_set_description(obj, "kvm-type", 288549d2e648SMarcel Apfelbaum "Specifies the KVM virtualization mode (HV, PR)", 288649d2e648SMarcel Apfelbaum NULL); 2887f6229214SMichael Roth object_property_add_bool(obj, "modern-hotplug-events", 2888f6229214SMichael Roth spapr_get_modern_hotplug_events, 2889f6229214SMichael Roth spapr_set_modern_hotplug_events, 2890f6229214SMichael Roth NULL); 2891f6229214SMichael Roth object_property_set_description(obj, "modern-hotplug-events", 2892f6229214SMichael Roth "Use dedicated hotplug event mechanism in" 2893f6229214SMichael Roth " place of standard EPOW events when possible" 2894f6229214SMichael Roth " (required for memory hot-unplug support)", 2895f6229214SMichael Roth NULL); 28967843c0d6SDavid Gibson 28977843c0d6SDavid Gibson ppc_compat_add_property(obj, "max-cpu-compat", &spapr->max_compat_pvr, 28987843c0d6SDavid Gibson "Maximum permitted CPU compatibility mode", 28997843c0d6SDavid Gibson &error_fatal); 290030f4b05bSDavid Gibson 290130f4b05bSDavid Gibson object_property_add_str(obj, "resize-hpt", 290230f4b05bSDavid Gibson spapr_get_resize_hpt, spapr_set_resize_hpt, NULL); 290330f4b05bSDavid Gibson object_property_set_description(obj, "resize-hpt", 290430f4b05bSDavid Gibson "Resizing of the Hash Page Table (enabled, disabled, required)", 290530f4b05bSDavid Gibson NULL); 2906fa98fbfcSSam Bobroff object_property_add(obj, "vsmt", "uint32", spapr_get_vsmt, 2907fa98fbfcSSam Bobroff spapr_set_vsmt, NULL, &spapr->vsmt, &error_abort); 2908fa98fbfcSSam Bobroff object_property_set_description(obj, "vsmt", 2909fa98fbfcSSam Bobroff "Virtual SMT: KVM behaves as if this were" 2910fa98fbfcSSam Bobroff " the host's SMT mode", &error_abort); 291123825581SEduardo Habkost } 291223825581SEduardo Habkost 291387bbdd9cSDavid Gibson static void spapr_machine_finalizefn(Object *obj) 291487bbdd9cSDavid Gibson { 291587bbdd9cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 291687bbdd9cSDavid Gibson 291787bbdd9cSDavid Gibson g_free(spapr->kvm_type); 291887bbdd9cSDavid Gibson } 291987bbdd9cSDavid Gibson 29201c7ad77eSNicholas Piggin void spapr_do_system_reset_on_cpu(CPUState *cs, run_on_cpu_data arg) 292134316482SAlexey Kardashevskiy { 292234316482SAlexey Kardashevskiy cpu_synchronize_state(cs); 292334316482SAlexey Kardashevskiy ppc_cpu_do_system_reset(cs); 292434316482SAlexey Kardashevskiy } 292534316482SAlexey Kardashevskiy 292634316482SAlexey Kardashevskiy static void spapr_nmi(NMIState *n, int cpu_index, Error **errp) 292734316482SAlexey Kardashevskiy { 292834316482SAlexey Kardashevskiy CPUState *cs; 292934316482SAlexey Kardashevskiy 293034316482SAlexey Kardashevskiy CPU_FOREACH(cs) { 29311c7ad77eSNicholas Piggin async_run_on_cpu(cs, spapr_do_system_reset_on_cpu, RUN_ON_CPU_NULL); 293234316482SAlexey Kardashevskiy } 293334316482SAlexey Kardashevskiy } 293434316482SAlexey Kardashevskiy 293579b78a6bSMichael Roth static void spapr_add_lmbs(DeviceState *dev, uint64_t addr_start, uint64_t size, 293679b78a6bSMichael Roth uint32_t node, bool dedicated_hp_event_source, 293779b78a6bSMichael Roth Error **errp) 2938c20d332aSBharata B Rao { 2939c20d332aSBharata B Rao sPAPRDRConnector *drc; 2940c20d332aSBharata B Rao uint32_t nr_lmbs = size/SPAPR_MEMORY_BLOCK_SIZE; 2941c20d332aSBharata B Rao int i, fdt_offset, fdt_size; 2942c20d332aSBharata B Rao void *fdt; 294379b78a6bSMichael Roth uint64_t addr = addr_start; 294494fd9cbaSLaurent Vivier bool hotplugged = spapr_drc_hotplugged(dev); 2945160bb678SGreg Kurz Error *local_err = NULL; 2946c20d332aSBharata B Rao 2947c20d332aSBharata B Rao for (i = 0; i < nr_lmbs; i++) { 2948fbf55397SDavid Gibson drc = spapr_drc_by_id(TYPE_SPAPR_DRC_LMB, 2949c20d332aSBharata B Rao addr / SPAPR_MEMORY_BLOCK_SIZE); 2950c20d332aSBharata B Rao g_assert(drc); 2951c20d332aSBharata B Rao 2952c20d332aSBharata B Rao fdt = create_device_tree(&fdt_size); 2953c20d332aSBharata B Rao fdt_offset = spapr_populate_memory_node(fdt, node, addr, 2954c20d332aSBharata B Rao SPAPR_MEMORY_BLOCK_SIZE); 2955c20d332aSBharata B Rao 2956160bb678SGreg Kurz spapr_drc_attach(drc, dev, fdt, fdt_offset, &local_err); 2957160bb678SGreg Kurz if (local_err) { 2958160bb678SGreg Kurz while (addr > addr_start) { 2959160bb678SGreg Kurz addr -= SPAPR_MEMORY_BLOCK_SIZE; 2960160bb678SGreg Kurz drc = spapr_drc_by_id(TYPE_SPAPR_DRC_LMB, 2961160bb678SGreg Kurz addr / SPAPR_MEMORY_BLOCK_SIZE); 2962a8dc47fdSDavid Gibson spapr_drc_detach(drc); 2963160bb678SGreg Kurz } 2964160bb678SGreg Kurz g_free(fdt); 2965160bb678SGreg Kurz error_propagate(errp, local_err); 2966160bb678SGreg Kurz return; 2967160bb678SGreg Kurz } 296894fd9cbaSLaurent Vivier if (!hotplugged) { 296994fd9cbaSLaurent Vivier spapr_drc_reset(drc); 297094fd9cbaSLaurent Vivier } 2971c20d332aSBharata B Rao addr += SPAPR_MEMORY_BLOCK_SIZE; 2972c20d332aSBharata B Rao } 29735dd5238cSJianjun Duan /* send hotplug notification to the 29745dd5238cSJianjun Duan * guest only in case of hotplugged memory 29755dd5238cSJianjun Duan */ 297694fd9cbaSLaurent Vivier if (hotplugged) { 297779b78a6bSMichael Roth if (dedicated_hp_event_source) { 2978fbf55397SDavid Gibson drc = spapr_drc_by_id(TYPE_SPAPR_DRC_LMB, 297979b78a6bSMichael Roth addr_start / SPAPR_MEMORY_BLOCK_SIZE); 298079b78a6bSMichael Roth spapr_hotplug_req_add_by_count_indexed(SPAPR_DR_CONNECTOR_TYPE_LMB, 298179b78a6bSMichael Roth nr_lmbs, 29820b55aa91SDavid Gibson spapr_drc_index(drc)); 298379b78a6bSMichael Roth } else { 298479b78a6bSMichael Roth spapr_hotplug_req_add_by_count(SPAPR_DR_CONNECTOR_TYPE_LMB, 298579b78a6bSMichael Roth nr_lmbs); 298679b78a6bSMichael Roth } 2987c20d332aSBharata B Rao } 29885dd5238cSJianjun Duan } 2989c20d332aSBharata B Rao 2990c20d332aSBharata B Rao static void spapr_memory_plug(HotplugHandler *hotplug_dev, DeviceState *dev, 2991c20d332aSBharata B Rao uint32_t node, Error **errp) 2992c20d332aSBharata B Rao { 2993c20d332aSBharata B Rao Error *local_err = NULL; 2994c20d332aSBharata B Rao sPAPRMachineState *ms = SPAPR_MACHINE(hotplug_dev); 2995c20d332aSBharata B Rao PCDIMMDevice *dimm = PC_DIMM(dev); 2996c20d332aSBharata B Rao PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); 299704790978SThomas Huth MemoryRegion *mr; 299804790978SThomas Huth uint64_t align, size, addr; 299904790978SThomas Huth 300004790978SThomas Huth mr = ddc->get_memory_region(dimm, &local_err); 300104790978SThomas Huth if (local_err) { 300204790978SThomas Huth goto out; 300304790978SThomas Huth } 300404790978SThomas Huth align = memory_region_get_alignment(mr); 300504790978SThomas Huth size = memory_region_size(mr); 3006df587133SThomas Huth 3007d6a9b0b8SMichael S. Tsirkin pc_dimm_memory_plug(dev, &ms->hotplug_memory, mr, align, &local_err); 3008c20d332aSBharata B Rao if (local_err) { 3009c20d332aSBharata B Rao goto out; 3010c20d332aSBharata B Rao } 3011c20d332aSBharata B Rao 30129ed442b8SMarc-André Lureau addr = object_property_get_uint(OBJECT(dimm), 30139ed442b8SMarc-André Lureau PC_DIMM_ADDR_PROP, &local_err); 3014c20d332aSBharata B Rao if (local_err) { 3015160bb678SGreg Kurz goto out_unplug; 3016c20d332aSBharata B Rao } 3017c20d332aSBharata B Rao 301879b78a6bSMichael Roth spapr_add_lmbs(dev, addr, size, node, 301979b78a6bSMichael Roth spapr_ovec_test(ms->ov5_cas, OV5_HP_EVT), 3020160bb678SGreg Kurz &local_err); 3021160bb678SGreg Kurz if (local_err) { 3022160bb678SGreg Kurz goto out_unplug; 3023160bb678SGreg Kurz } 3024c20d332aSBharata B Rao 3025160bb678SGreg Kurz return; 3026160bb678SGreg Kurz 3027160bb678SGreg Kurz out_unplug: 3028160bb678SGreg Kurz pc_dimm_memory_unplug(dev, &ms->hotplug_memory, mr); 3029c20d332aSBharata B Rao out: 3030c20d332aSBharata B Rao error_propagate(errp, local_err); 3031c20d332aSBharata B Rao } 3032c20d332aSBharata B Rao 3033c871bc70SLaurent Vivier static void spapr_memory_pre_plug(HotplugHandler *hotplug_dev, DeviceState *dev, 3034c871bc70SLaurent Vivier Error **errp) 3035c871bc70SLaurent Vivier { 3036c871bc70SLaurent Vivier PCDIMMDevice *dimm = PC_DIMM(dev); 3037c871bc70SLaurent Vivier PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); 303804790978SThomas Huth MemoryRegion *mr; 303904790978SThomas Huth uint64_t size; 3040c871bc70SLaurent Vivier char *mem_dev; 3041c871bc70SLaurent Vivier 304204790978SThomas Huth mr = ddc->get_memory_region(dimm, errp); 304304790978SThomas Huth if (!mr) { 304404790978SThomas Huth return; 304504790978SThomas Huth } 304604790978SThomas Huth size = memory_region_size(mr); 304704790978SThomas Huth 3048c871bc70SLaurent Vivier if (size % SPAPR_MEMORY_BLOCK_SIZE) { 3049c871bc70SLaurent Vivier error_setg(errp, "Hotplugged memory size must be a multiple of " 3050c871bc70SLaurent Vivier "%lld MB", SPAPR_MEMORY_BLOCK_SIZE / M_BYTE); 3051c871bc70SLaurent Vivier return; 3052c871bc70SLaurent Vivier } 3053c871bc70SLaurent Vivier 3054c871bc70SLaurent Vivier mem_dev = object_property_get_str(OBJECT(dimm), PC_DIMM_MEMDEV_PROP, NULL); 3055c871bc70SLaurent Vivier if (mem_dev && !kvmppc_is_mem_backend_page_size_ok(mem_dev)) { 3056c871bc70SLaurent Vivier error_setg(errp, "Memory backend has bad page size. " 3057c871bc70SLaurent Vivier "Use 'memory-backend-file' with correct mem-path."); 30588a9e0e7bSGreg Kurz goto out; 3059c871bc70SLaurent Vivier } 30608a9e0e7bSGreg Kurz 30618a9e0e7bSGreg Kurz out: 30628a9e0e7bSGreg Kurz g_free(mem_dev); 3063c871bc70SLaurent Vivier } 3064c871bc70SLaurent Vivier 30650cffce56SDavid Gibson struct sPAPRDIMMState { 30660cffce56SDavid Gibson PCDIMMDevice *dimm; 3067cf632463SBharata B Rao uint32_t nr_lmbs; 30680cffce56SDavid Gibson QTAILQ_ENTRY(sPAPRDIMMState) next; 30690cffce56SDavid Gibson }; 30700cffce56SDavid Gibson 30710cffce56SDavid Gibson static sPAPRDIMMState *spapr_pending_dimm_unplugs_find(sPAPRMachineState *s, 30720cffce56SDavid Gibson PCDIMMDevice *dimm) 30730cffce56SDavid Gibson { 30740cffce56SDavid Gibson sPAPRDIMMState *dimm_state = NULL; 30750cffce56SDavid Gibson 30760cffce56SDavid Gibson QTAILQ_FOREACH(dimm_state, &s->pending_dimm_unplugs, next) { 30770cffce56SDavid Gibson if (dimm_state->dimm == dimm) { 30780cffce56SDavid Gibson break; 30790cffce56SDavid Gibson } 30800cffce56SDavid Gibson } 30810cffce56SDavid Gibson return dimm_state; 30820cffce56SDavid Gibson } 30830cffce56SDavid Gibson 30848d5981c4SBharata B Rao static sPAPRDIMMState *spapr_pending_dimm_unplugs_add(sPAPRMachineState *spapr, 30858d5981c4SBharata B Rao uint32_t nr_lmbs, 30868d5981c4SBharata B Rao PCDIMMDevice *dimm) 30870cffce56SDavid Gibson { 30888d5981c4SBharata B Rao sPAPRDIMMState *ds = NULL; 30898d5981c4SBharata B Rao 30908d5981c4SBharata B Rao /* 30918d5981c4SBharata B Rao * If this request is for a DIMM whose removal had failed earlier 30928d5981c4SBharata B Rao * (due to guest's refusal to remove the LMBs), we would have this 30938d5981c4SBharata B Rao * dimm already in the pending_dimm_unplugs list. In that 30948d5981c4SBharata B Rao * case don't add again. 30958d5981c4SBharata B Rao */ 30968d5981c4SBharata B Rao ds = spapr_pending_dimm_unplugs_find(spapr, dimm); 30978d5981c4SBharata B Rao if (!ds) { 30988d5981c4SBharata B Rao ds = g_malloc0(sizeof(sPAPRDIMMState)); 30998d5981c4SBharata B Rao ds->nr_lmbs = nr_lmbs; 31008d5981c4SBharata B Rao ds->dimm = dimm; 31018d5981c4SBharata B Rao QTAILQ_INSERT_HEAD(&spapr->pending_dimm_unplugs, ds, next); 31028d5981c4SBharata B Rao } 31038d5981c4SBharata B Rao return ds; 31040cffce56SDavid Gibson } 31050cffce56SDavid Gibson 31060cffce56SDavid Gibson static void spapr_pending_dimm_unplugs_remove(sPAPRMachineState *spapr, 31070cffce56SDavid Gibson sPAPRDIMMState *dimm_state) 31080cffce56SDavid Gibson { 31090cffce56SDavid Gibson QTAILQ_REMOVE(&spapr->pending_dimm_unplugs, dimm_state, next); 31100cffce56SDavid Gibson g_free(dimm_state); 31110cffce56SDavid Gibson } 3112cf632463SBharata B Rao 311316ee9980SDaniel Henrique Barboza static sPAPRDIMMState *spapr_recover_pending_dimm_state(sPAPRMachineState *ms, 311416ee9980SDaniel Henrique Barboza PCDIMMDevice *dimm) 311516ee9980SDaniel Henrique Barboza { 311616ee9980SDaniel Henrique Barboza sPAPRDRConnector *drc; 311716ee9980SDaniel Henrique Barboza PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); 311804790978SThomas Huth MemoryRegion *mr = ddc->get_memory_region(dimm, &error_abort); 311916ee9980SDaniel Henrique Barboza uint64_t size = memory_region_size(mr); 312016ee9980SDaniel Henrique Barboza uint32_t nr_lmbs = size / SPAPR_MEMORY_BLOCK_SIZE; 312116ee9980SDaniel Henrique Barboza uint32_t avail_lmbs = 0; 312216ee9980SDaniel Henrique Barboza uint64_t addr_start, addr; 312316ee9980SDaniel Henrique Barboza int i; 312416ee9980SDaniel Henrique Barboza 312516ee9980SDaniel Henrique Barboza addr_start = object_property_get_int(OBJECT(dimm), PC_DIMM_ADDR_PROP, 312616ee9980SDaniel Henrique Barboza &error_abort); 312716ee9980SDaniel Henrique Barboza 312816ee9980SDaniel Henrique Barboza addr = addr_start; 312916ee9980SDaniel Henrique Barboza for (i = 0; i < nr_lmbs; i++) { 3130fbf55397SDavid Gibson drc = spapr_drc_by_id(TYPE_SPAPR_DRC_LMB, 313116ee9980SDaniel Henrique Barboza addr / SPAPR_MEMORY_BLOCK_SIZE); 313216ee9980SDaniel Henrique Barboza g_assert(drc); 3133454b580aSDavid Gibson if (drc->dev) { 313416ee9980SDaniel Henrique Barboza avail_lmbs++; 313516ee9980SDaniel Henrique Barboza } 313616ee9980SDaniel Henrique Barboza addr += SPAPR_MEMORY_BLOCK_SIZE; 313716ee9980SDaniel Henrique Barboza } 313816ee9980SDaniel Henrique Barboza 31398d5981c4SBharata B Rao return spapr_pending_dimm_unplugs_add(ms, avail_lmbs, dimm); 314016ee9980SDaniel Henrique Barboza } 314116ee9980SDaniel Henrique Barboza 314231834723SDaniel Henrique Barboza /* Callback to be called during DRC release. */ 314331834723SDaniel Henrique Barboza void spapr_lmb_release(DeviceState *dev) 3144cf632463SBharata B Rao { 3145765d1bddSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(qdev_get_hotplug_handler(dev)); 3146765d1bddSDavid Gibson PCDIMMDevice *dimm = PC_DIMM(dev); 3147765d1bddSDavid Gibson PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); 314804790978SThomas Huth MemoryRegion *mr = ddc->get_memory_region(dimm, &error_abort); 31490cffce56SDavid Gibson sPAPRDIMMState *ds = spapr_pending_dimm_unplugs_find(spapr, PC_DIMM(dev)); 3150cf632463SBharata B Rao 315116ee9980SDaniel Henrique Barboza /* This information will get lost if a migration occurs 315216ee9980SDaniel Henrique Barboza * during the unplug process. In this case recover it. */ 315316ee9980SDaniel Henrique Barboza if (ds == NULL) { 315416ee9980SDaniel Henrique Barboza ds = spapr_recover_pending_dimm_state(spapr, PC_DIMM(dev)); 31558d5981c4SBharata B Rao g_assert(ds); 3156454b580aSDavid Gibson /* The DRC being examined by the caller at least must be counted */ 3157454b580aSDavid Gibson g_assert(ds->nr_lmbs); 315816ee9980SDaniel Henrique Barboza } 3159454b580aSDavid Gibson 3160454b580aSDavid Gibson if (--ds->nr_lmbs) { 3161cf632463SBharata B Rao return; 3162cf632463SBharata B Rao } 3163cf632463SBharata B Rao 3164cf632463SBharata B Rao /* 3165cf632463SBharata B Rao * Now that all the LMBs have been removed by the guest, call the 3166cf632463SBharata B Rao * pc-dimm unplug handler to cleanup up the pc-dimm device. 3167cf632463SBharata B Rao */ 3168765d1bddSDavid Gibson pc_dimm_memory_unplug(dev, &spapr->hotplug_memory, mr); 3169cf632463SBharata B Rao object_unparent(OBJECT(dev)); 31702a129767SDaniel Henrique Barboza spapr_pending_dimm_unplugs_remove(spapr, ds); 3171cf632463SBharata B Rao } 3172cf632463SBharata B Rao 3173cf632463SBharata B Rao static void spapr_memory_unplug_request(HotplugHandler *hotplug_dev, 3174cf632463SBharata B Rao DeviceState *dev, Error **errp) 3175cf632463SBharata B Rao { 31760cffce56SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(hotplug_dev); 3177cf632463SBharata B Rao Error *local_err = NULL; 3178cf632463SBharata B Rao PCDIMMDevice *dimm = PC_DIMM(dev); 3179cf632463SBharata B Rao PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); 318004790978SThomas Huth MemoryRegion *mr; 318104790978SThomas Huth uint32_t nr_lmbs; 318204790978SThomas Huth uint64_t size, addr_start, addr; 31830cffce56SDavid Gibson int i; 31840cffce56SDavid Gibson sPAPRDRConnector *drc; 318504790978SThomas Huth 318604790978SThomas Huth mr = ddc->get_memory_region(dimm, &local_err); 318704790978SThomas Huth if (local_err) { 318804790978SThomas Huth goto out; 318904790978SThomas Huth } 319004790978SThomas Huth size = memory_region_size(mr); 319104790978SThomas Huth nr_lmbs = size / SPAPR_MEMORY_BLOCK_SIZE; 319204790978SThomas Huth 31939ed442b8SMarc-André Lureau addr_start = object_property_get_uint(OBJECT(dimm), PC_DIMM_ADDR_PROP, 31940cffce56SDavid Gibson &local_err); 3195cf632463SBharata B Rao if (local_err) { 3196cf632463SBharata B Rao goto out; 3197cf632463SBharata B Rao } 3198cf632463SBharata B Rao 31992a129767SDaniel Henrique Barboza /* 32002a129767SDaniel Henrique Barboza * An existing pending dimm state for this DIMM means that there is an 32012a129767SDaniel Henrique Barboza * unplug operation in progress, waiting for the spapr_lmb_release 32022a129767SDaniel Henrique Barboza * callback to complete the job (BQL can't cover that far). In this case, 32032a129767SDaniel Henrique Barboza * bail out to avoid detaching DRCs that were already released. 32042a129767SDaniel Henrique Barboza */ 32052a129767SDaniel Henrique Barboza if (spapr_pending_dimm_unplugs_find(spapr, dimm)) { 32062a129767SDaniel Henrique Barboza error_setg(&local_err, 32072a129767SDaniel Henrique Barboza "Memory unplug already in progress for device %s", 32082a129767SDaniel Henrique Barboza dev->id); 32092a129767SDaniel Henrique Barboza goto out; 32102a129767SDaniel Henrique Barboza } 32112a129767SDaniel Henrique Barboza 32128d5981c4SBharata B Rao spapr_pending_dimm_unplugs_add(spapr, nr_lmbs, dimm); 32130cffce56SDavid Gibson 32140cffce56SDavid Gibson addr = addr_start; 32150cffce56SDavid Gibson for (i = 0; i < nr_lmbs; i++) { 3216fbf55397SDavid Gibson drc = spapr_drc_by_id(TYPE_SPAPR_DRC_LMB, 32170cffce56SDavid Gibson addr / SPAPR_MEMORY_BLOCK_SIZE); 32180cffce56SDavid Gibson g_assert(drc); 32190cffce56SDavid Gibson 3220a8dc47fdSDavid Gibson spapr_drc_detach(drc); 32210cffce56SDavid Gibson addr += SPAPR_MEMORY_BLOCK_SIZE; 32220cffce56SDavid Gibson } 32230cffce56SDavid Gibson 3224fbf55397SDavid Gibson drc = spapr_drc_by_id(TYPE_SPAPR_DRC_LMB, 32250cffce56SDavid Gibson addr_start / SPAPR_MEMORY_BLOCK_SIZE); 32260cffce56SDavid Gibson spapr_hotplug_req_remove_by_count_indexed(SPAPR_DR_CONNECTOR_TYPE_LMB, 32270b55aa91SDavid Gibson nr_lmbs, spapr_drc_index(drc)); 3228cf632463SBharata B Rao out: 3229cf632463SBharata B Rao error_propagate(errp, local_err); 3230cf632463SBharata B Rao } 3231cf632463SBharata B Rao 323204d0ffbdSGreg Kurz static void *spapr_populate_hotplug_cpu_dt(CPUState *cs, int *fdt_offset, 3233af81cf32SBharata B Rao sPAPRMachineState *spapr) 3234af81cf32SBharata B Rao { 3235af81cf32SBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(cs); 3236af81cf32SBharata B Rao DeviceClass *dc = DEVICE_GET_CLASS(cs); 32372e886fb3SSam Bobroff int id = spapr_vcpu_id(cpu); 3238af81cf32SBharata B Rao void *fdt; 3239af81cf32SBharata B Rao int offset, fdt_size; 3240af81cf32SBharata B Rao char *nodename; 3241af81cf32SBharata B Rao 3242af81cf32SBharata B Rao fdt = create_device_tree(&fdt_size); 3243af81cf32SBharata B Rao nodename = g_strdup_printf("%s@%x", dc->fw_name, id); 3244af81cf32SBharata B Rao offset = fdt_add_subnode(fdt, 0, nodename); 3245af81cf32SBharata B Rao 3246af81cf32SBharata B Rao spapr_populate_cpu_dt(cs, fdt, offset, spapr); 3247af81cf32SBharata B Rao g_free(nodename); 3248af81cf32SBharata B Rao 3249af81cf32SBharata B Rao *fdt_offset = offset; 3250af81cf32SBharata B Rao return fdt; 3251af81cf32SBharata B Rao } 3252af81cf32SBharata B Rao 3253765d1bddSDavid Gibson /* Callback to be called during DRC release. */ 3254765d1bddSDavid Gibson void spapr_core_release(DeviceState *dev) 3255ff9006ddSIgor Mammedov { 3256765d1bddSDavid Gibson MachineState *ms = MACHINE(qdev_get_hotplug_handler(dev)); 325746f7afa3SGreg Kurz sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(ms); 3258ff9006ddSIgor Mammedov CPUCore *cc = CPU_CORE(dev); 3259535455fdSIgor Mammedov CPUArchId *core_slot = spapr_find_cpu_slot(ms, cc->core_id, NULL); 3260ff9006ddSIgor Mammedov 326146f7afa3SGreg Kurz if (smc->pre_2_10_has_unused_icps) { 326246f7afa3SGreg Kurz sPAPRCPUCore *sc = SPAPR_CPU_CORE(OBJECT(dev)); 326346f7afa3SGreg Kurz int i; 326446f7afa3SGreg Kurz 326546f7afa3SGreg Kurz for (i = 0; i < cc->nr_threads; i++) { 326694ad93bdSGreg Kurz CPUState *cs = CPU(sc->threads[i]); 326746f7afa3SGreg Kurz 326846f7afa3SGreg Kurz pre_2_10_vmstate_register_dummy_icp(cs->cpu_index); 326946f7afa3SGreg Kurz } 327046f7afa3SGreg Kurz } 327146f7afa3SGreg Kurz 327207572c06SGreg Kurz assert(core_slot); 3273535455fdSIgor Mammedov core_slot->cpu = NULL; 3274ff9006ddSIgor Mammedov object_unparent(OBJECT(dev)); 3275ff9006ddSIgor Mammedov } 3276ff9006ddSIgor Mammedov 3277115debf2SIgor Mammedov static 3278115debf2SIgor Mammedov void spapr_core_unplug_request(HotplugHandler *hotplug_dev, DeviceState *dev, 3279ff9006ddSIgor Mammedov Error **errp) 3280ff9006ddSIgor Mammedov { 3281*72194664SGreg Kurz sPAPRMachineState *spapr = SPAPR_MACHINE(OBJECT(hotplug_dev)); 3282535455fdSIgor Mammedov int index; 3283535455fdSIgor Mammedov sPAPRDRConnector *drc; 3284535455fdSIgor Mammedov CPUCore *cc = CPU_CORE(dev); 3285ff9006ddSIgor Mammedov 3286535455fdSIgor Mammedov if (!spapr_find_cpu_slot(MACHINE(hotplug_dev), cc->core_id, &index)) { 3287535455fdSIgor Mammedov error_setg(errp, "Unable to find CPU core with core-id: %d", 3288535455fdSIgor Mammedov cc->core_id); 3289535455fdSIgor Mammedov return; 3290535455fdSIgor Mammedov } 3291ff9006ddSIgor Mammedov if (index == 0) { 3292ff9006ddSIgor Mammedov error_setg(errp, "Boot CPU core may not be unplugged"); 3293ff9006ddSIgor Mammedov return; 3294ff9006ddSIgor Mammedov } 3295ff9006ddSIgor Mammedov 3296*72194664SGreg Kurz drc = spapr_drc_by_id(TYPE_SPAPR_DRC_CPU, index * spapr->vsmt); 3297ff9006ddSIgor Mammedov g_assert(drc); 3298ff9006ddSIgor Mammedov 3299a8dc47fdSDavid Gibson spapr_drc_detach(drc); 3300ff9006ddSIgor Mammedov 3301ff9006ddSIgor Mammedov spapr_hotplug_req_remove_by_index(drc); 3302ff9006ddSIgor Mammedov } 3303ff9006ddSIgor Mammedov 3304ff9006ddSIgor Mammedov static void spapr_core_plug(HotplugHandler *hotplug_dev, DeviceState *dev, 3305ff9006ddSIgor Mammedov Error **errp) 3306ff9006ddSIgor Mammedov { 3307ff9006ddSIgor Mammedov sPAPRMachineState *spapr = SPAPR_MACHINE(OBJECT(hotplug_dev)); 3308ff9006ddSIgor Mammedov MachineClass *mc = MACHINE_GET_CLASS(spapr); 330946f7afa3SGreg Kurz sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); 3310ff9006ddSIgor Mammedov sPAPRCPUCore *core = SPAPR_CPU_CORE(OBJECT(dev)); 3311ff9006ddSIgor Mammedov CPUCore *cc = CPU_CORE(dev); 331294ad93bdSGreg Kurz CPUState *cs = CPU(core->threads[0]); 3313ff9006ddSIgor Mammedov sPAPRDRConnector *drc; 3314ff9006ddSIgor Mammedov Error *local_err = NULL; 3315535455fdSIgor Mammedov CPUArchId *core_slot; 3316535455fdSIgor Mammedov int index; 331794fd9cbaSLaurent Vivier bool hotplugged = spapr_drc_hotplugged(dev); 3318ff9006ddSIgor Mammedov 3319535455fdSIgor Mammedov core_slot = spapr_find_cpu_slot(MACHINE(hotplug_dev), cc->core_id, &index); 3320535455fdSIgor Mammedov if (!core_slot) { 3321535455fdSIgor Mammedov error_setg(errp, "Unable to find CPU core with core-id: %d", 3322535455fdSIgor Mammedov cc->core_id); 3323535455fdSIgor Mammedov return; 3324535455fdSIgor Mammedov } 3325*72194664SGreg Kurz drc = spapr_drc_by_id(TYPE_SPAPR_DRC_CPU, index * spapr->vsmt); 3326ff9006ddSIgor Mammedov 3327c5514d0eSIgor Mammedov g_assert(drc || !mc->has_hotpluggable_cpus); 3328ff9006ddSIgor Mammedov 3329e49c63d5SGreg Kurz if (drc) { 3330e49c63d5SGreg Kurz void *fdt; 3331e49c63d5SGreg Kurz int fdt_offset; 3332e49c63d5SGreg Kurz 3333ff9006ddSIgor Mammedov fdt = spapr_populate_hotplug_cpu_dt(cs, &fdt_offset, spapr); 3334ff9006ddSIgor Mammedov 33355c1da812SDavid Gibson spapr_drc_attach(drc, dev, fdt, fdt_offset, &local_err); 3336ff9006ddSIgor Mammedov if (local_err) { 3337ff9006ddSIgor Mammedov g_free(fdt); 3338ff9006ddSIgor Mammedov error_propagate(errp, local_err); 3339ff9006ddSIgor Mammedov return; 3340ff9006ddSIgor Mammedov } 3341ff9006ddSIgor Mammedov 334294fd9cbaSLaurent Vivier if (hotplugged) { 3343ff9006ddSIgor Mammedov /* 334494fd9cbaSLaurent Vivier * Send hotplug notification interrupt to the guest only 334594fd9cbaSLaurent Vivier * in case of hotplugged CPUs. 3346ff9006ddSIgor Mammedov */ 3347ff9006ddSIgor Mammedov spapr_hotplug_req_add_by_index(drc); 334894fd9cbaSLaurent Vivier } else { 334994fd9cbaSLaurent Vivier spapr_drc_reset(drc); 3350ff9006ddSIgor Mammedov } 335194fd9cbaSLaurent Vivier } 335294fd9cbaSLaurent Vivier 3353535455fdSIgor Mammedov core_slot->cpu = OBJECT(dev); 335446f7afa3SGreg Kurz 335546f7afa3SGreg Kurz if (smc->pre_2_10_has_unused_icps) { 335646f7afa3SGreg Kurz int i; 335746f7afa3SGreg Kurz 335846f7afa3SGreg Kurz for (i = 0; i < cc->nr_threads; i++) { 3359bc877283SGreg Kurz cs = CPU(core->threads[i]); 336046f7afa3SGreg Kurz pre_2_10_vmstate_unregister_dummy_icp(cs->cpu_index); 336146f7afa3SGreg Kurz } 336246f7afa3SGreg Kurz } 3363ff9006ddSIgor Mammedov } 3364ff9006ddSIgor Mammedov 3365ff9006ddSIgor Mammedov static void spapr_core_pre_plug(HotplugHandler *hotplug_dev, DeviceState *dev, 3366ff9006ddSIgor Mammedov Error **errp) 3367ff9006ddSIgor Mammedov { 3368ff9006ddSIgor Mammedov MachineState *machine = MACHINE(OBJECT(hotplug_dev)); 3369ff9006ddSIgor Mammedov MachineClass *mc = MACHINE_GET_CLASS(hotplug_dev); 3370ff9006ddSIgor Mammedov Error *local_err = NULL; 3371ff9006ddSIgor Mammedov CPUCore *cc = CPU_CORE(dev); 33722e9c10ebSIgor Mammedov const char *base_core_type = spapr_get_cpu_core_type(machine->cpu_type); 3373ff9006ddSIgor Mammedov const char *type = object_get_typename(OBJECT(dev)); 3374535455fdSIgor Mammedov CPUArchId *core_slot; 3375535455fdSIgor Mammedov int index; 3376ff9006ddSIgor Mammedov 3377c5514d0eSIgor Mammedov if (dev->hotplugged && !mc->has_hotpluggable_cpus) { 3378ff9006ddSIgor Mammedov error_setg(&local_err, "CPU hotplug not supported for this machine"); 3379ff9006ddSIgor Mammedov goto out; 3380ff9006ddSIgor Mammedov } 3381ff9006ddSIgor Mammedov 3382ff9006ddSIgor Mammedov if (strcmp(base_core_type, type)) { 3383ff9006ddSIgor Mammedov error_setg(&local_err, "CPU core type should be %s", base_core_type); 3384ff9006ddSIgor Mammedov goto out; 3385ff9006ddSIgor Mammedov } 3386ff9006ddSIgor Mammedov 3387ff9006ddSIgor Mammedov if (cc->core_id % smp_threads) { 3388ff9006ddSIgor Mammedov error_setg(&local_err, "invalid core id %d", cc->core_id); 3389ff9006ddSIgor Mammedov goto out; 3390ff9006ddSIgor Mammedov } 3391ff9006ddSIgor Mammedov 3392459264efSDavid Gibson /* 3393459264efSDavid Gibson * In general we should have homogeneous threads-per-core, but old 3394459264efSDavid Gibson * (pre hotplug support) machine types allow the last core to have 3395459264efSDavid Gibson * reduced threads as a compatibility hack for when we allowed 3396459264efSDavid Gibson * total vcpus not a multiple of threads-per-core. 3397459264efSDavid Gibson */ 3398459264efSDavid Gibson if (mc->has_hotpluggable_cpus && (cc->nr_threads != smp_threads)) { 3399df8658deSGreg Kurz error_setg(&local_err, "invalid nr-threads %d, must be %d", 34008149e299SDavid Gibson cc->nr_threads, smp_threads); 3401df8658deSGreg Kurz goto out; 34028149e299SDavid Gibson } 34038149e299SDavid Gibson 3404535455fdSIgor Mammedov core_slot = spapr_find_cpu_slot(MACHINE(hotplug_dev), cc->core_id, &index); 3405535455fdSIgor Mammedov if (!core_slot) { 3406ff9006ddSIgor Mammedov error_setg(&local_err, "core id %d out of range", cc->core_id); 3407ff9006ddSIgor Mammedov goto out; 3408ff9006ddSIgor Mammedov } 3409ff9006ddSIgor Mammedov 3410535455fdSIgor Mammedov if (core_slot->cpu) { 3411ff9006ddSIgor Mammedov error_setg(&local_err, "core %d already populated", cc->core_id); 3412ff9006ddSIgor Mammedov goto out; 3413ff9006ddSIgor Mammedov } 3414ff9006ddSIgor Mammedov 3415a0ceb640SIgor Mammedov numa_cpu_pre_plug(core_slot, dev, &local_err); 34160b8497f0SIgor Mammedov 3417ff9006ddSIgor Mammedov out: 3418ff9006ddSIgor Mammedov error_propagate(errp, local_err); 3419ff9006ddSIgor Mammedov } 3420ff9006ddSIgor Mammedov 3421c20d332aSBharata B Rao static void spapr_machine_device_plug(HotplugHandler *hotplug_dev, 3422c20d332aSBharata B Rao DeviceState *dev, Error **errp) 3423c20d332aSBharata B Rao { 3424c86c1affSDaniel Henrique Barboza MachineState *ms = MACHINE(hotplug_dev); 3425c86c1affSDaniel Henrique Barboza sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(ms); 3426c20d332aSBharata B Rao 3427c20d332aSBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { 3428b556854bSBharata B Rao int node; 3429c20d332aSBharata B Rao 3430c20d332aSBharata B Rao if (!smc->dr_lmb_enabled) { 3431c20d332aSBharata B Rao error_setg(errp, "Memory hotplug not supported for this machine"); 3432c20d332aSBharata B Rao return; 3433c20d332aSBharata B Rao } 34349ed442b8SMarc-André Lureau node = object_property_get_uint(OBJECT(dev), PC_DIMM_NODE_PROP, errp); 3435c20d332aSBharata B Rao if (*errp) { 3436c20d332aSBharata B Rao return; 3437c20d332aSBharata B Rao } 34381a5512bbSGonglei if (node < 0 || node >= MAX_NODES) { 34391a5512bbSGonglei error_setg(errp, "Invaild node %d", node); 34401a5512bbSGonglei return; 34411a5512bbSGonglei } 3442c20d332aSBharata B Rao 3443b556854bSBharata B Rao /* 3444b556854bSBharata B Rao * Currently PowerPC kernel doesn't allow hot-adding memory to 3445b556854bSBharata B Rao * memory-less node, but instead will silently add the memory 3446b556854bSBharata B Rao * to the first node that has some memory. This causes two 3447b556854bSBharata B Rao * unexpected behaviours for the user. 3448b556854bSBharata B Rao * 3449b556854bSBharata B Rao * - Memory gets hotplugged to a different node than what the user 3450b556854bSBharata B Rao * specified. 3451b556854bSBharata B Rao * - Since pc-dimm subsystem in QEMU still thinks that memory belongs 3452b556854bSBharata B Rao * to memory-less node, a reboot will set things accordingly 3453b556854bSBharata B Rao * and the previously hotplugged memory now ends in the right node. 3454b556854bSBharata B Rao * This appears as if some memory moved from one node to another. 3455b556854bSBharata B Rao * 3456b556854bSBharata B Rao * So until kernel starts supporting memory hotplug to memory-less 3457b556854bSBharata B Rao * nodes, just prevent such attempts upfront in QEMU. 3458b556854bSBharata B Rao */ 3459b556854bSBharata B Rao if (nb_numa_nodes && !numa_info[node].node_mem) { 3460b556854bSBharata B Rao error_setg(errp, "Can't hotplug memory to memory-less node %d", 3461b556854bSBharata B Rao node); 3462b556854bSBharata B Rao return; 3463b556854bSBharata B Rao } 3464b556854bSBharata B Rao 3465c20d332aSBharata B Rao spapr_memory_plug(hotplug_dev, dev, node, errp); 3466af81cf32SBharata B Rao } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 3467af81cf32SBharata B Rao spapr_core_plug(hotplug_dev, dev, errp); 3468c20d332aSBharata B Rao } 3469c20d332aSBharata B Rao } 3470c20d332aSBharata B Rao 3471cf632463SBharata B Rao static void spapr_machine_device_unplug_request(HotplugHandler *hotplug_dev, 3472cf632463SBharata B Rao DeviceState *dev, Error **errp) 3473cf632463SBharata B Rao { 3474c86c1affSDaniel Henrique Barboza sPAPRMachineState *sms = SPAPR_MACHINE(OBJECT(hotplug_dev)); 3475c86c1affSDaniel Henrique Barboza MachineClass *mc = MACHINE_GET_CLASS(sms); 3476cf632463SBharata B Rao 3477cf632463SBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { 3478cf632463SBharata B Rao if (spapr_ovec_test(sms->ov5_cas, OV5_HP_EVT)) { 3479cf632463SBharata B Rao spapr_memory_unplug_request(hotplug_dev, dev, errp); 3480cf632463SBharata B Rao } else { 3481cf632463SBharata B Rao /* NOTE: this means there is a window after guest reset, prior to 3482cf632463SBharata B Rao * CAS negotiation, where unplug requests will fail due to the 3483cf632463SBharata B Rao * capability not being detected yet. This is a bit different than 3484cf632463SBharata B Rao * the case with PCI unplug, where the events will be queued and 3485cf632463SBharata B Rao * eventually handled by the guest after boot 3486cf632463SBharata B Rao */ 3487cf632463SBharata B Rao error_setg(errp, "Memory hot unplug not supported for this guest"); 3488cf632463SBharata B Rao } 34896f4b5c3eSBharata B Rao } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 3490c5514d0eSIgor Mammedov if (!mc->has_hotpluggable_cpus) { 34916f4b5c3eSBharata B Rao error_setg(errp, "CPU hot unplug not supported on this machine"); 34926f4b5c3eSBharata B Rao return; 34936f4b5c3eSBharata B Rao } 3494115debf2SIgor Mammedov spapr_core_unplug_request(hotplug_dev, dev, errp); 3495c20d332aSBharata B Rao } 3496c20d332aSBharata B Rao } 3497c20d332aSBharata B Rao 349894a94e4cSBharata B Rao static void spapr_machine_device_pre_plug(HotplugHandler *hotplug_dev, 349994a94e4cSBharata B Rao DeviceState *dev, Error **errp) 350094a94e4cSBharata B Rao { 3501c871bc70SLaurent Vivier if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { 3502c871bc70SLaurent Vivier spapr_memory_pre_plug(hotplug_dev, dev, errp); 3503c871bc70SLaurent Vivier } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 350494a94e4cSBharata B Rao spapr_core_pre_plug(hotplug_dev, dev, errp); 350594a94e4cSBharata B Rao } 350694a94e4cSBharata B Rao } 350794a94e4cSBharata B Rao 35087ebaf795SBharata B Rao static HotplugHandler *spapr_get_hotplug_handler(MachineState *machine, 3509c20d332aSBharata B Rao DeviceState *dev) 3510c20d332aSBharata B Rao { 351194a94e4cSBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM) || 351294a94e4cSBharata B Rao object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 3513c20d332aSBharata B Rao return HOTPLUG_HANDLER(machine); 3514c20d332aSBharata B Rao } 3515c20d332aSBharata B Rao return NULL; 3516c20d332aSBharata B Rao } 3517c20d332aSBharata B Rao 3518ea089eebSIgor Mammedov static CpuInstanceProperties 3519ea089eebSIgor Mammedov spapr_cpu_index_to_props(MachineState *machine, unsigned cpu_index) 352020bb648dSDavid Gibson { 3521ea089eebSIgor Mammedov CPUArchId *core_slot; 3522ea089eebSIgor Mammedov MachineClass *mc = MACHINE_GET_CLASS(machine); 3523ea089eebSIgor Mammedov 3524ea089eebSIgor Mammedov /* make sure possible_cpu are intialized */ 3525ea089eebSIgor Mammedov mc->possible_cpu_arch_ids(machine); 3526ea089eebSIgor Mammedov /* get CPU core slot containing thread that matches cpu_index */ 3527ea089eebSIgor Mammedov core_slot = spapr_find_cpu_slot(machine, cpu_index, NULL); 3528ea089eebSIgor Mammedov assert(core_slot); 3529ea089eebSIgor Mammedov return core_slot->props; 353020bb648dSDavid Gibson } 353120bb648dSDavid Gibson 353279e07936SIgor Mammedov static int64_t spapr_get_default_cpu_node_id(const MachineState *ms, int idx) 353379e07936SIgor Mammedov { 353479e07936SIgor Mammedov return idx / smp_cores % nb_numa_nodes; 353579e07936SIgor Mammedov } 353679e07936SIgor Mammedov 3537535455fdSIgor Mammedov static const CPUArchIdList *spapr_possible_cpu_arch_ids(MachineState *machine) 3538535455fdSIgor Mammedov { 3539535455fdSIgor Mammedov int i; 3540d342eb76SIgor Mammedov const char *core_type; 3541535455fdSIgor Mammedov int spapr_max_cores = max_cpus / smp_threads; 3542535455fdSIgor Mammedov MachineClass *mc = MACHINE_GET_CLASS(machine); 3543535455fdSIgor Mammedov 3544c5514d0eSIgor Mammedov if (!mc->has_hotpluggable_cpus) { 3545535455fdSIgor Mammedov spapr_max_cores = QEMU_ALIGN_UP(smp_cpus, smp_threads) / smp_threads; 3546535455fdSIgor Mammedov } 3547535455fdSIgor Mammedov if (machine->possible_cpus) { 3548535455fdSIgor Mammedov assert(machine->possible_cpus->len == spapr_max_cores); 3549535455fdSIgor Mammedov return machine->possible_cpus; 3550535455fdSIgor Mammedov } 3551535455fdSIgor Mammedov 3552d342eb76SIgor Mammedov core_type = spapr_get_cpu_core_type(machine->cpu_type); 3553d342eb76SIgor Mammedov if (!core_type) { 3554d342eb76SIgor Mammedov error_report("Unable to find sPAPR CPU Core definition"); 3555d342eb76SIgor Mammedov exit(1); 3556d342eb76SIgor Mammedov } 3557d342eb76SIgor Mammedov 3558535455fdSIgor Mammedov machine->possible_cpus = g_malloc0(sizeof(CPUArchIdList) + 3559535455fdSIgor Mammedov sizeof(CPUArchId) * spapr_max_cores); 3560535455fdSIgor Mammedov machine->possible_cpus->len = spapr_max_cores; 3561535455fdSIgor Mammedov for (i = 0; i < machine->possible_cpus->len; i++) { 3562535455fdSIgor Mammedov int core_id = i * smp_threads; 3563535455fdSIgor Mammedov 3564d342eb76SIgor Mammedov machine->possible_cpus->cpus[i].type = core_type; 3565f2d672c2SIgor Mammedov machine->possible_cpus->cpus[i].vcpus_count = smp_threads; 3566535455fdSIgor Mammedov machine->possible_cpus->cpus[i].arch_id = core_id; 3567535455fdSIgor Mammedov machine->possible_cpus->cpus[i].props.has_core_id = true; 3568535455fdSIgor Mammedov machine->possible_cpus->cpus[i].props.core_id = core_id; 3569535455fdSIgor Mammedov } 3570535455fdSIgor Mammedov return machine->possible_cpus; 3571535455fdSIgor Mammedov } 3572535455fdSIgor Mammedov 35736737d9adSDavid Gibson static void spapr_phb_placement(sPAPRMachineState *spapr, uint32_t index, 3574daa23699SDavid Gibson uint64_t *buid, hwaddr *pio, 3575daa23699SDavid Gibson hwaddr *mmio32, hwaddr *mmio64, 35766737d9adSDavid Gibson unsigned n_dma, uint32_t *liobns, Error **errp) 35776737d9adSDavid Gibson { 3578357d1e3bSDavid Gibson /* 3579357d1e3bSDavid Gibson * New-style PHB window placement. 3580357d1e3bSDavid Gibson * 3581357d1e3bSDavid Gibson * Goals: Gives large (1TiB), naturally aligned 64-bit MMIO window 3582357d1e3bSDavid Gibson * for each PHB, in addition to 2GiB 32-bit MMIO and 64kiB PIO 3583357d1e3bSDavid Gibson * windows. 3584357d1e3bSDavid Gibson * 3585357d1e3bSDavid Gibson * Some guest kernels can't work with MMIO windows above 1<<46 3586357d1e3bSDavid Gibson * (64TiB), so we place up to 31 PHBs in the area 32TiB..64TiB 3587357d1e3bSDavid Gibson * 3588357d1e3bSDavid Gibson * 32TiB..(33TiB+1984kiB) contains the 64kiB PIO windows for each 3589357d1e3bSDavid Gibson * PHB stacked together. (32TiB+2GiB)..(32TiB+64GiB) contains the 3590357d1e3bSDavid Gibson * 2GiB 32-bit MMIO windows for each PHB. Then 33..64TiB has the 3591357d1e3bSDavid Gibson * 1TiB 64-bit MMIO windows for each PHB. 3592357d1e3bSDavid Gibson */ 35936737d9adSDavid Gibson const uint64_t base_buid = 0x800000020000000ULL; 359425e6a118SMichael S. Tsirkin #define SPAPR_MAX_PHBS ((SPAPR_PCI_LIMIT - SPAPR_PCI_BASE) / \ 359525e6a118SMichael S. Tsirkin SPAPR_PCI_MEM64_WIN_SIZE - 1) 35966737d9adSDavid Gibson int i; 35976737d9adSDavid Gibson 3598357d1e3bSDavid Gibson /* Sanity check natural alignments */ 3599357d1e3bSDavid Gibson QEMU_BUILD_BUG_ON((SPAPR_PCI_BASE % SPAPR_PCI_MEM64_WIN_SIZE) != 0); 3600357d1e3bSDavid Gibson QEMU_BUILD_BUG_ON((SPAPR_PCI_LIMIT % SPAPR_PCI_MEM64_WIN_SIZE) != 0); 3601357d1e3bSDavid Gibson QEMU_BUILD_BUG_ON((SPAPR_PCI_MEM64_WIN_SIZE % SPAPR_PCI_MEM32_WIN_SIZE) != 0); 3602357d1e3bSDavid Gibson QEMU_BUILD_BUG_ON((SPAPR_PCI_MEM32_WIN_SIZE % SPAPR_PCI_IO_WIN_SIZE) != 0); 3603357d1e3bSDavid Gibson /* Sanity check bounds */ 360425e6a118SMichael S. Tsirkin QEMU_BUILD_BUG_ON((SPAPR_MAX_PHBS * SPAPR_PCI_IO_WIN_SIZE) > 360525e6a118SMichael S. Tsirkin SPAPR_PCI_MEM32_WIN_SIZE); 360625e6a118SMichael S. Tsirkin QEMU_BUILD_BUG_ON((SPAPR_MAX_PHBS * SPAPR_PCI_MEM32_WIN_SIZE) > 360725e6a118SMichael S. Tsirkin SPAPR_PCI_MEM64_WIN_SIZE); 36082efff1c0SDavid Gibson 360925e6a118SMichael S. Tsirkin if (index >= SPAPR_MAX_PHBS) { 361025e6a118SMichael S. Tsirkin error_setg(errp, "\"index\" for PAPR PHB is too large (max %llu)", 361125e6a118SMichael S. Tsirkin SPAPR_MAX_PHBS - 1); 36126737d9adSDavid Gibson return; 36136737d9adSDavid Gibson } 36146737d9adSDavid Gibson 36156737d9adSDavid Gibson *buid = base_buid + index; 36166737d9adSDavid Gibson for (i = 0; i < n_dma; ++i) { 36176737d9adSDavid Gibson liobns[i] = SPAPR_PCI_LIOBN(index, i); 36186737d9adSDavid Gibson } 36196737d9adSDavid Gibson 3620357d1e3bSDavid Gibson *pio = SPAPR_PCI_BASE + index * SPAPR_PCI_IO_WIN_SIZE; 3621357d1e3bSDavid Gibson *mmio32 = SPAPR_PCI_BASE + (index + 1) * SPAPR_PCI_MEM32_WIN_SIZE; 3622357d1e3bSDavid Gibson *mmio64 = SPAPR_PCI_BASE + (index + 1) * SPAPR_PCI_MEM64_WIN_SIZE; 36236737d9adSDavid Gibson } 36246737d9adSDavid Gibson 36257844e12bSCédric Le Goater static ICSState *spapr_ics_get(XICSFabric *dev, int irq) 36267844e12bSCédric Le Goater { 36277844e12bSCédric Le Goater sPAPRMachineState *spapr = SPAPR_MACHINE(dev); 36287844e12bSCédric Le Goater 36297844e12bSCédric Le Goater return ics_valid_irq(spapr->ics, irq) ? spapr->ics : NULL; 36307844e12bSCédric Le Goater } 36317844e12bSCédric Le Goater 36327844e12bSCédric Le Goater static void spapr_ics_resend(XICSFabric *dev) 36337844e12bSCédric Le Goater { 36347844e12bSCédric Le Goater sPAPRMachineState *spapr = SPAPR_MACHINE(dev); 36357844e12bSCédric Le Goater 36367844e12bSCédric Le Goater ics_resend(spapr->ics); 36377844e12bSCédric Le Goater } 36387844e12bSCédric Le Goater 363981210c20SSam Bobroff static ICPState *spapr_icp_get(XICSFabric *xi, int vcpu_id) 3640b2fc59aaSCédric Le Goater { 36412e886fb3SSam Bobroff PowerPCCPU *cpu = spapr_find_cpu(vcpu_id); 3642b2fc59aaSCédric Le Goater 36435bc8d26dSCédric Le Goater return cpu ? ICP(cpu->intc) : NULL; 3644b2fc59aaSCédric Le Goater } 3645b2fc59aaSCédric Le Goater 364660c6823bSCédric Le Goater #define ICS_IRQ_FREE(ics, srcno) \ 364760c6823bSCédric Le Goater (!((ics)->irqs[(srcno)].flags & (XICS_FLAGS_IRQ_MASK))) 364860c6823bSCédric Le Goater 364960c6823bSCédric Le Goater static int ics_find_free_block(ICSState *ics, int num, int alignnum) 365060c6823bSCédric Le Goater { 365160c6823bSCédric Le Goater int first, i; 365260c6823bSCédric Le Goater 365360c6823bSCédric Le Goater for (first = 0; first < ics->nr_irqs; first += alignnum) { 365460c6823bSCédric Le Goater if (num > (ics->nr_irqs - first)) { 365560c6823bSCédric Le Goater return -1; 365660c6823bSCédric Le Goater } 365760c6823bSCédric Le Goater for (i = first; i < first + num; ++i) { 365860c6823bSCédric Le Goater if (!ICS_IRQ_FREE(ics, i)) { 365960c6823bSCédric Le Goater break; 366060c6823bSCédric Le Goater } 366160c6823bSCédric Le Goater } 366260c6823bSCédric Le Goater if (i == (first + num)) { 366360c6823bSCédric Le Goater return first; 366460c6823bSCédric Le Goater } 366560c6823bSCédric Le Goater } 366660c6823bSCédric Le Goater 366760c6823bSCédric Le Goater return -1; 366860c6823bSCédric Le Goater } 366960c6823bSCédric Le Goater 36709e7dc5fcSCédric Le Goater /* 36719e7dc5fcSCédric Le Goater * Allocate the IRQ number and set the IRQ type, LSI or MSI 36729e7dc5fcSCédric Le Goater */ 36739e7dc5fcSCédric Le Goater static void spapr_irq_set_lsi(sPAPRMachineState *spapr, int irq, bool lsi) 36749e7dc5fcSCédric Le Goater { 36759e7dc5fcSCédric Le Goater ics_set_irq_type(spapr->ics, irq - spapr->ics->offset, lsi); 36769e7dc5fcSCédric Le Goater } 36779e7dc5fcSCédric Le Goater 367860c6823bSCédric Le Goater int spapr_irq_alloc(sPAPRMachineState *spapr, int irq_hint, bool lsi, 367960c6823bSCédric Le Goater Error **errp) 368060c6823bSCédric Le Goater { 368160c6823bSCédric Le Goater ICSState *ics = spapr->ics; 368260c6823bSCédric Le Goater int irq; 368360c6823bSCédric Le Goater 368460c6823bSCédric Le Goater if (!ics) { 368560c6823bSCédric Le Goater return -1; 368660c6823bSCédric Le Goater } 368760c6823bSCédric Le Goater if (irq_hint) { 368860c6823bSCédric Le Goater if (!ICS_IRQ_FREE(ics, irq_hint - ics->offset)) { 368960c6823bSCédric Le Goater error_setg(errp, "can't allocate IRQ %d: already in use", irq_hint); 369060c6823bSCédric Le Goater return -1; 369160c6823bSCédric Le Goater } 369260c6823bSCédric Le Goater irq = irq_hint; 369360c6823bSCédric Le Goater } else { 369460c6823bSCédric Le Goater irq = ics_find_free_block(ics, 1, 1); 369560c6823bSCédric Le Goater if (irq < 0) { 369660c6823bSCédric Le Goater error_setg(errp, "can't allocate IRQ: no IRQ left"); 369760c6823bSCédric Le Goater return -1; 369860c6823bSCédric Le Goater } 369960c6823bSCédric Le Goater irq += ics->offset; 370060c6823bSCédric Le Goater } 370160c6823bSCédric Le Goater 37029e7dc5fcSCédric Le Goater spapr_irq_set_lsi(spapr, irq, lsi); 370360c6823bSCédric Le Goater trace_spapr_irq_alloc(irq); 370460c6823bSCédric Le Goater 370560c6823bSCédric Le Goater return irq; 370660c6823bSCédric Le Goater } 370760c6823bSCédric Le Goater 370860c6823bSCédric Le Goater /* 370960c6823bSCédric Le Goater * Allocate block of consecutive IRQs, and return the number of the first IRQ in 371060c6823bSCédric Le Goater * the block. If align==true, aligns the first IRQ number to num. 371160c6823bSCédric Le Goater */ 371260c6823bSCédric Le Goater int spapr_irq_alloc_block(sPAPRMachineState *spapr, int num, bool lsi, 371360c6823bSCédric Le Goater bool align, Error **errp) 371460c6823bSCédric Le Goater { 371560c6823bSCédric Le Goater ICSState *ics = spapr->ics; 371660c6823bSCédric Le Goater int i, first = -1; 371760c6823bSCédric Le Goater 371860c6823bSCédric Le Goater if (!ics) { 371960c6823bSCédric Le Goater return -1; 372060c6823bSCédric Le Goater } 372160c6823bSCédric Le Goater 372260c6823bSCédric Le Goater /* 372360c6823bSCédric Le Goater * MSIMesage::data is used for storing VIRQ so 372460c6823bSCédric Le Goater * it has to be aligned to num to support multiple 372560c6823bSCédric Le Goater * MSI vectors. MSI-X is not affected by this. 372660c6823bSCédric Le Goater * The hint is used for the first IRQ, the rest should 372760c6823bSCédric Le Goater * be allocated continuously. 372860c6823bSCédric Le Goater */ 372960c6823bSCédric Le Goater if (align) { 373060c6823bSCédric Le Goater assert((num == 1) || (num == 2) || (num == 4) || 373160c6823bSCédric Le Goater (num == 8) || (num == 16) || (num == 32)); 373260c6823bSCédric Le Goater first = ics_find_free_block(ics, num, num); 373360c6823bSCédric Le Goater } else { 373460c6823bSCédric Le Goater first = ics_find_free_block(ics, num, 1); 373560c6823bSCédric Le Goater } 373660c6823bSCédric Le Goater if (first < 0) { 373760c6823bSCédric Le Goater error_setg(errp, "can't find a free %d-IRQ block", num); 373860c6823bSCédric Le Goater return -1; 373960c6823bSCédric Le Goater } 374060c6823bSCédric Le Goater 374160c6823bSCédric Le Goater first += ics->offset; 37429e7dc5fcSCédric Le Goater for (i = first; i < first + num; ++i) { 37439e7dc5fcSCédric Le Goater spapr_irq_set_lsi(spapr, i, lsi); 37449e7dc5fcSCédric Le Goater } 374560c6823bSCédric Le Goater 374660c6823bSCédric Le Goater trace_spapr_irq_alloc_block(first, num, lsi, align); 374760c6823bSCédric Le Goater 374860c6823bSCédric Le Goater return first; 374960c6823bSCédric Le Goater } 375060c6823bSCédric Le Goater 375160c6823bSCédric Le Goater void spapr_irq_free(sPAPRMachineState *spapr, int irq, int num) 375260c6823bSCédric Le Goater { 375360c6823bSCédric Le Goater ICSState *ics = spapr->ics; 375460c6823bSCédric Le Goater int srcno = irq - ics->offset; 375560c6823bSCédric Le Goater int i; 375660c6823bSCédric Le Goater 375760c6823bSCédric Le Goater if (ics_valid_irq(ics, irq)) { 375860c6823bSCédric Le Goater trace_spapr_irq_free(0, irq, num); 375960c6823bSCédric Le Goater for (i = srcno; i < srcno + num; ++i) { 376060c6823bSCédric Le Goater if (ICS_IRQ_FREE(ics, i)) { 376160c6823bSCédric Le Goater trace_spapr_irq_free_warn(0, i + ics->offset); 376260c6823bSCédric Le Goater } 376360c6823bSCédric Le Goater memset(&ics->irqs[i], 0, sizeof(ICSIRQState)); 376460c6823bSCédric Le Goater } 376560c6823bSCédric Le Goater } 376660c6823bSCédric Le Goater } 376760c6823bSCédric Le Goater 376877183755SCédric Le Goater qemu_irq spapr_qirq(sPAPRMachineState *spapr, int irq) 376977183755SCédric Le Goater { 377077183755SCédric Le Goater ICSState *ics = spapr->ics; 377177183755SCédric Le Goater 377277183755SCédric Le Goater if (ics_valid_irq(ics, irq)) { 377377183755SCédric Le Goater return ics->qirqs[irq - ics->offset]; 377477183755SCédric Le Goater } 377577183755SCédric Le Goater 377677183755SCédric Le Goater return NULL; 377777183755SCédric Le Goater } 377877183755SCédric Le Goater 37796449da45SCédric Le Goater static void spapr_pic_print_info(InterruptStatsProvider *obj, 37806449da45SCédric Le Goater Monitor *mon) 37816449da45SCédric Le Goater { 37826449da45SCédric Le Goater sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 37835bc8d26dSCédric Le Goater CPUState *cs; 37846449da45SCédric Le Goater 37855bc8d26dSCédric Le Goater CPU_FOREACH(cs) { 37865bc8d26dSCédric Le Goater PowerPCCPU *cpu = POWERPC_CPU(cs); 37875bc8d26dSCédric Le Goater 37885bc8d26dSCédric Le Goater icp_pic_print_info(ICP(cpu->intc), mon); 37896449da45SCédric Le Goater } 37906449da45SCédric Le Goater 37916449da45SCédric Le Goater ics_pic_print_info(spapr->ics, mon); 37926449da45SCédric Le Goater } 37936449da45SCédric Le Goater 37942e886fb3SSam Bobroff int spapr_vcpu_id(PowerPCCPU *cpu) 37952e886fb3SSam Bobroff { 37962e886fb3SSam Bobroff CPUState *cs = CPU(cpu); 37972e886fb3SSam Bobroff 37982e886fb3SSam Bobroff if (kvm_enabled()) { 37992e886fb3SSam Bobroff return kvm_arch_vcpu_id(cs); 38002e886fb3SSam Bobroff } else { 38012e886fb3SSam Bobroff return cs->cpu_index; 38022e886fb3SSam Bobroff } 38032e886fb3SSam Bobroff } 38042e886fb3SSam Bobroff 38052e886fb3SSam Bobroff PowerPCCPU *spapr_find_cpu(int vcpu_id) 38062e886fb3SSam Bobroff { 38072e886fb3SSam Bobroff CPUState *cs; 38082e886fb3SSam Bobroff 38092e886fb3SSam Bobroff CPU_FOREACH(cs) { 38102e886fb3SSam Bobroff PowerPCCPU *cpu = POWERPC_CPU(cs); 38112e886fb3SSam Bobroff 38122e886fb3SSam Bobroff if (spapr_vcpu_id(cpu) == vcpu_id) { 38132e886fb3SSam Bobroff return cpu; 38142e886fb3SSam Bobroff } 38152e886fb3SSam Bobroff } 38162e886fb3SSam Bobroff 38172e886fb3SSam Bobroff return NULL; 38182e886fb3SSam Bobroff } 38192e886fb3SSam Bobroff 382029ee3247SAlexey Kardashevskiy static void spapr_machine_class_init(ObjectClass *oc, void *data) 382153018216SPaolo Bonzini { 382229ee3247SAlexey Kardashevskiy MachineClass *mc = MACHINE_CLASS(oc); 3823224245bfSDavid Gibson sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(oc); 382471461b0fSAlexey Kardashevskiy FWPathProviderClass *fwc = FW_PATH_PROVIDER_CLASS(oc); 382534316482SAlexey Kardashevskiy NMIClass *nc = NMI_CLASS(oc); 3826c20d332aSBharata B Rao HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(oc); 38271d1be34dSDavid Gibson PPCVirtualHypervisorClass *vhc = PPC_VIRTUAL_HYPERVISOR_CLASS(oc); 38287844e12bSCédric Le Goater XICSFabricClass *xic = XICS_FABRIC_CLASS(oc); 38296449da45SCédric Le Goater InterruptStatsProviderClass *ispc = INTERRUPT_STATS_PROVIDER_CLASS(oc); 383029ee3247SAlexey Kardashevskiy 38310eb9054cSDavid Gibson mc->desc = "pSeries Logical Partition (PAPR compliant)"; 3832fc9f38c3SDavid Gibson 3833fc9f38c3SDavid Gibson /* 3834fc9f38c3SDavid Gibson * We set up the default / latest behaviour here. The class_init 3835fc9f38c3SDavid Gibson * functions for the specific versioned machine types can override 3836fc9f38c3SDavid Gibson * these details for backwards compatibility 3837fc9f38c3SDavid Gibson */ 3838bcb5ce08SDavid Gibson mc->init = spapr_machine_init; 3839bcb5ce08SDavid Gibson mc->reset = spapr_machine_reset; 3840958db90cSMarcel Apfelbaum mc->block_default_type = IF_SCSI; 38416244bb7eSGreg Kurz mc->max_cpus = 1024; 3842958db90cSMarcel Apfelbaum mc->no_parallel = 1; 38435b2128d2SAlexander Graf mc->default_boot_order = ""; 3844a34944feSNikunj A Dadhania mc->default_ram_size = 512 * M_BYTE; 3845958db90cSMarcel Apfelbaum mc->kvm_type = spapr_kvm_type; 38467da79a16SEduardo Habkost machine_class_allow_dynamic_sysbus_dev(mc, TYPE_SPAPR_PCI_HOST_BRIDGE); 3847e4024630SLaurent Vivier mc->pci_allow_0_address = true; 38487ebaf795SBharata B Rao mc->get_hotplug_handler = spapr_get_hotplug_handler; 384994a94e4cSBharata B Rao hc->pre_plug = spapr_machine_device_pre_plug; 3850c20d332aSBharata B Rao hc->plug = spapr_machine_device_plug; 3851ea089eebSIgor Mammedov mc->cpu_index_to_instance_props = spapr_cpu_index_to_props; 385279e07936SIgor Mammedov mc->get_default_cpu_node_id = spapr_get_default_cpu_node_id; 3853535455fdSIgor Mammedov mc->possible_cpu_arch_ids = spapr_possible_cpu_arch_ids; 3854cf632463SBharata B Rao hc->unplug_request = spapr_machine_device_unplug_request; 385500b4fbe2SMarcel Apfelbaum 3856fc9f38c3SDavid Gibson smc->dr_lmb_enabled = true; 38572e9c10ebSIgor Mammedov mc->default_cpu_type = POWERPC_CPU_TYPE_NAME("power8_v2.0"); 3858c5514d0eSIgor Mammedov mc->has_hotpluggable_cpus = true; 385952b81ab5SDavid Gibson smc->resize_hpt_default = SPAPR_RESIZE_HPT_ENABLED; 386071461b0fSAlexey Kardashevskiy fwc->get_dev_path = spapr_get_fw_dev_path; 386134316482SAlexey Kardashevskiy nc->nmi_monitor_handler = spapr_nmi; 38626737d9adSDavid Gibson smc->phb_placement = spapr_phb_placement; 38631d1be34dSDavid Gibson vhc->hypercall = emulate_spapr_hypercall; 3864e57ca75cSDavid Gibson vhc->hpt_mask = spapr_hpt_mask; 3865e57ca75cSDavid Gibson vhc->map_hptes = spapr_map_hptes; 3866e57ca75cSDavid Gibson vhc->unmap_hptes = spapr_unmap_hptes; 3867e57ca75cSDavid Gibson vhc->store_hpte = spapr_store_hpte; 38689861bb3eSSuraj Jitindar Singh vhc->get_patbe = spapr_get_patbe; 38691ec26c75SGreg Kurz vhc->encode_hpt_for_kvm_pr = spapr_encode_hpt_for_kvm_pr; 38707844e12bSCédric Le Goater xic->ics_get = spapr_ics_get; 38717844e12bSCédric Le Goater xic->ics_resend = spapr_ics_resend; 3872b2fc59aaSCédric Le Goater xic->icp_get = spapr_icp_get; 38736449da45SCédric Le Goater ispc->print_info = spapr_pic_print_info; 387455641213SLaurent Vivier /* Force NUMA node memory size to be a multiple of 387555641213SLaurent Vivier * SPAPR_MEMORY_BLOCK_SIZE (256M) since that's the granularity 387655641213SLaurent Vivier * in which LMBs are represented and hot-added 387755641213SLaurent Vivier */ 387855641213SLaurent Vivier mc->numa_mem_align_shift = 28; 387933face6bSDavid Gibson 38804e5fe368SSuraj Jitindar Singh smc->default_caps.caps[SPAPR_CAP_HTM] = SPAPR_CAP_OFF; 38814e5fe368SSuraj Jitindar Singh smc->default_caps.caps[SPAPR_CAP_VSX] = SPAPR_CAP_ON; 38824e5fe368SSuraj Jitindar Singh smc->default_caps.caps[SPAPR_CAP_DFP] = SPAPR_CAP_ON; 38838f38eaf8SSuraj Jitindar Singh smc->default_caps.caps[SPAPR_CAP_CFPC] = SPAPR_CAP_BROKEN; 388409114fd8SSuraj Jitindar Singh smc->default_caps.caps[SPAPR_CAP_SBBC] = SPAPR_CAP_BROKEN; 38854be8d4e7SSuraj Jitindar Singh smc->default_caps.caps[SPAPR_CAP_IBS] = SPAPR_CAP_BROKEN; 388633face6bSDavid Gibson spapr_caps_add_properties(smc, &error_abort); 388753018216SPaolo Bonzini } 388853018216SPaolo Bonzini 388929ee3247SAlexey Kardashevskiy static const TypeInfo spapr_machine_info = { 389029ee3247SAlexey Kardashevskiy .name = TYPE_SPAPR_MACHINE, 389129ee3247SAlexey Kardashevskiy .parent = TYPE_MACHINE, 38924aee7362SDavid Gibson .abstract = true, 38936ca1502eSAlexey Kardashevskiy .instance_size = sizeof(sPAPRMachineState), 3894bcb5ce08SDavid Gibson .instance_init = spapr_instance_init, 389587bbdd9cSDavid Gibson .instance_finalize = spapr_machine_finalizefn, 3896183930c0SDavid Gibson .class_size = sizeof(sPAPRMachineClass), 389729ee3247SAlexey Kardashevskiy .class_init = spapr_machine_class_init, 389871461b0fSAlexey Kardashevskiy .interfaces = (InterfaceInfo[]) { 389971461b0fSAlexey Kardashevskiy { TYPE_FW_PATH_PROVIDER }, 390034316482SAlexey Kardashevskiy { TYPE_NMI }, 3901c20d332aSBharata B Rao { TYPE_HOTPLUG_HANDLER }, 39021d1be34dSDavid Gibson { TYPE_PPC_VIRTUAL_HYPERVISOR }, 39037844e12bSCédric Le Goater { TYPE_XICS_FABRIC }, 39046449da45SCédric Le Goater { TYPE_INTERRUPT_STATS_PROVIDER }, 390571461b0fSAlexey Kardashevskiy { } 390671461b0fSAlexey Kardashevskiy }, 390729ee3247SAlexey Kardashevskiy }; 390829ee3247SAlexey Kardashevskiy 3909fccbc785SDavid Gibson #define DEFINE_SPAPR_MACHINE(suffix, verstr, latest) \ 39105013c547SDavid Gibson static void spapr_machine_##suffix##_class_init(ObjectClass *oc, \ 39115013c547SDavid Gibson void *data) \ 39125013c547SDavid Gibson { \ 39135013c547SDavid Gibson MachineClass *mc = MACHINE_CLASS(oc); \ 39145013c547SDavid Gibson spapr_machine_##suffix##_class_options(mc); \ 3915fccbc785SDavid Gibson if (latest) { \ 3916fccbc785SDavid Gibson mc->alias = "pseries"; \ 3917fccbc785SDavid Gibson mc->is_default = 1; \ 3918fccbc785SDavid Gibson } \ 39195013c547SDavid Gibson } \ 39205013c547SDavid Gibson static void spapr_machine_##suffix##_instance_init(Object *obj) \ 39215013c547SDavid Gibson { \ 39225013c547SDavid Gibson MachineState *machine = MACHINE(obj); \ 39235013c547SDavid Gibson spapr_machine_##suffix##_instance_options(machine); \ 39245013c547SDavid Gibson } \ 39255013c547SDavid Gibson static const TypeInfo spapr_machine_##suffix##_info = { \ 39265013c547SDavid Gibson .name = MACHINE_TYPE_NAME("pseries-" verstr), \ 39275013c547SDavid Gibson .parent = TYPE_SPAPR_MACHINE, \ 39285013c547SDavid Gibson .class_init = spapr_machine_##suffix##_class_init, \ 39295013c547SDavid Gibson .instance_init = spapr_machine_##suffix##_instance_init, \ 39305013c547SDavid Gibson }; \ 39315013c547SDavid Gibson static void spapr_machine_register_##suffix(void) \ 39325013c547SDavid Gibson { \ 39335013c547SDavid Gibson type_register(&spapr_machine_##suffix##_info); \ 39345013c547SDavid Gibson } \ 39350e6aac87SEduardo Habkost type_init(spapr_machine_register_##suffix) 39365013c547SDavid Gibson 39371c5f29bbSDavid Gibson /* 39382b615412SDavid Gibson * pseries-2.12 3939e2676b16SGreg Kurz */ 39402b615412SDavid Gibson static void spapr_machine_2_12_instance_options(MachineState *machine) 3941e2676b16SGreg Kurz { 3942e2676b16SGreg Kurz } 3943e2676b16SGreg Kurz 39442b615412SDavid Gibson static void spapr_machine_2_12_class_options(MachineClass *mc) 3945e2676b16SGreg Kurz { 3946e2676b16SGreg Kurz /* Defaults for the latest behaviour inherited from the base class */ 3947e2676b16SGreg Kurz } 3948e2676b16SGreg Kurz 39492b615412SDavid Gibson DEFINE_SPAPR_MACHINE(2_12, "2.12", true); 39502b615412SDavid Gibson 39512b615412SDavid Gibson /* 39522b615412SDavid Gibson * pseries-2.11 39532b615412SDavid Gibson */ 39542b615412SDavid Gibson #define SPAPR_COMPAT_2_11 \ 39552b615412SDavid Gibson HW_COMPAT_2_11 39562b615412SDavid Gibson 39572b615412SDavid Gibson static void spapr_machine_2_11_instance_options(MachineState *machine) 39582b615412SDavid Gibson { 39592b615412SDavid Gibson spapr_machine_2_12_instance_options(machine); 39602b615412SDavid Gibson } 39612b615412SDavid Gibson 39622b615412SDavid Gibson static void spapr_machine_2_11_class_options(MachineClass *mc) 39632b615412SDavid Gibson { 3964ee76a09fSDavid Gibson sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); 3965ee76a09fSDavid Gibson 39662b615412SDavid Gibson spapr_machine_2_12_class_options(mc); 39674e5fe368SSuraj Jitindar Singh smc->default_caps.caps[SPAPR_CAP_HTM] = SPAPR_CAP_ON; 39682b615412SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_11); 39692b615412SDavid Gibson } 39702b615412SDavid Gibson 39712b615412SDavid Gibson DEFINE_SPAPR_MACHINE(2_11, "2.11", false); 3972e2676b16SGreg Kurz 3973e2676b16SGreg Kurz /* 39743fa14fbeSDavid Gibson * pseries-2.10 3975db800b21SDavid Gibson */ 3976e2676b16SGreg Kurz #define SPAPR_COMPAT_2_10 \ 39772b615412SDavid Gibson HW_COMPAT_2_10 3978e2676b16SGreg Kurz 39793fa14fbeSDavid Gibson static void spapr_machine_2_10_instance_options(MachineState *machine) 3980db800b21SDavid Gibson { 39812b615412SDavid Gibson spapr_machine_2_11_instance_options(machine); 3982db800b21SDavid Gibson } 3983db800b21SDavid Gibson 39843fa14fbeSDavid Gibson static void spapr_machine_2_10_class_options(MachineClass *mc) 3985db800b21SDavid Gibson { 3986e2676b16SGreg Kurz spapr_machine_2_11_class_options(mc); 3987e2676b16SGreg Kurz SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_10); 3988db800b21SDavid Gibson } 3989db800b21SDavid Gibson 3990e2676b16SGreg Kurz DEFINE_SPAPR_MACHINE(2_10, "2.10", false); 39913fa14fbeSDavid Gibson 39923fa14fbeSDavid Gibson /* 39933fa14fbeSDavid Gibson * pseries-2.9 39943fa14fbeSDavid Gibson */ 39953fa14fbeSDavid Gibson #define SPAPR_COMPAT_2_9 \ 3996d5fc133eSDavid Gibson HW_COMPAT_2_9 \ 3997d5fc133eSDavid Gibson { \ 3998d5fc133eSDavid Gibson .driver = TYPE_POWERPC_CPU, \ 3999d5fc133eSDavid Gibson .property = "pre-2.10-migration", \ 4000d5fc133eSDavid Gibson .value = "on", \ 4001d5fc133eSDavid Gibson }, \ 40023fa14fbeSDavid Gibson 40033fa14fbeSDavid Gibson static void spapr_machine_2_9_instance_options(MachineState *machine) 40043fa14fbeSDavid Gibson { 40053fa14fbeSDavid Gibson spapr_machine_2_10_instance_options(machine); 40063fa14fbeSDavid Gibson } 40073fa14fbeSDavid Gibson 40083fa14fbeSDavid Gibson static void spapr_machine_2_9_class_options(MachineClass *mc) 40093fa14fbeSDavid Gibson { 401046f7afa3SGreg Kurz sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); 401146f7afa3SGreg Kurz 40123fa14fbeSDavid Gibson spapr_machine_2_10_class_options(mc); 40133fa14fbeSDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_9); 40143bfe5716SLaurent Vivier mc->numa_auto_assign_ram = numa_legacy_auto_assign_ram; 401546f7afa3SGreg Kurz smc->pre_2_10_has_unused_icps = true; 401652b81ab5SDavid Gibson smc->resize_hpt_default = SPAPR_RESIZE_HPT_DISABLED; 40173fa14fbeSDavid Gibson } 40183fa14fbeSDavid Gibson 40193fa14fbeSDavid Gibson DEFINE_SPAPR_MACHINE(2_9, "2.9", false); 4020fa325e6cSDavid Gibson 4021fa325e6cSDavid Gibson /* 4022fa325e6cSDavid Gibson * pseries-2.8 4023fa325e6cSDavid Gibson */ 4024fa325e6cSDavid Gibson #define SPAPR_COMPAT_2_8 \ 402582516263SDavid Gibson HW_COMPAT_2_8 \ 402682516263SDavid Gibson { \ 402782516263SDavid Gibson .driver = TYPE_SPAPR_PCI_HOST_BRIDGE, \ 402882516263SDavid Gibson .property = "pcie-extended-configuration-space", \ 402982516263SDavid Gibson .value = "off", \ 403082516263SDavid Gibson }, 4031fa325e6cSDavid Gibson 4032fa325e6cSDavid Gibson static void spapr_machine_2_8_instance_options(MachineState *machine) 4033fa325e6cSDavid Gibson { 4034fa325e6cSDavid Gibson spapr_machine_2_9_instance_options(machine); 4035fa325e6cSDavid Gibson } 4036fa325e6cSDavid Gibson 4037fa325e6cSDavid Gibson static void spapr_machine_2_8_class_options(MachineClass *mc) 4038fa325e6cSDavid Gibson { 4039fa325e6cSDavid Gibson spapr_machine_2_9_class_options(mc); 4040fa325e6cSDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_8); 404155641213SLaurent Vivier mc->numa_mem_align_shift = 23; 4042fa325e6cSDavid Gibson } 4043fa325e6cSDavid Gibson 4044fa325e6cSDavid Gibson DEFINE_SPAPR_MACHINE(2_8, "2.8", false); 4045db800b21SDavid Gibson 4046db800b21SDavid Gibson /* 40471ea1eefcSBharata B Rao * pseries-2.7 40481ea1eefcSBharata B Rao */ 4049db800b21SDavid Gibson #define SPAPR_COMPAT_2_7 \ 4050db800b21SDavid Gibson HW_COMPAT_2_7 \ 4051357d1e3bSDavid Gibson { \ 4052357d1e3bSDavid Gibson .driver = TYPE_SPAPR_PCI_HOST_BRIDGE, \ 4053357d1e3bSDavid Gibson .property = "mem_win_size", \ 4054357d1e3bSDavid Gibson .value = stringify(SPAPR_PCI_2_7_MMIO_WIN_SIZE),\ 4055357d1e3bSDavid Gibson }, \ 4056357d1e3bSDavid Gibson { \ 4057357d1e3bSDavid Gibson .driver = TYPE_SPAPR_PCI_HOST_BRIDGE, \ 4058357d1e3bSDavid Gibson .property = "mem64_win_size", \ 4059357d1e3bSDavid Gibson .value = "0", \ 4060146c11f1SDavid Gibson }, \ 4061146c11f1SDavid Gibson { \ 4062146c11f1SDavid Gibson .driver = TYPE_POWERPC_CPU, \ 4063146c11f1SDavid Gibson .property = "pre-2.8-migration", \ 4064146c11f1SDavid Gibson .value = "on", \ 40655c4537bdSDavid Gibson }, \ 40665c4537bdSDavid Gibson { \ 40675c4537bdSDavid Gibson .driver = TYPE_SPAPR_PCI_HOST_BRIDGE, \ 40685c4537bdSDavid Gibson .property = "pre-2.8-migration", \ 40695c4537bdSDavid Gibson .value = "on", \ 4070357d1e3bSDavid Gibson }, 4071357d1e3bSDavid Gibson 4072357d1e3bSDavid Gibson static void phb_placement_2_7(sPAPRMachineState *spapr, uint32_t index, 4073357d1e3bSDavid Gibson uint64_t *buid, hwaddr *pio, 4074357d1e3bSDavid Gibson hwaddr *mmio32, hwaddr *mmio64, 4075357d1e3bSDavid Gibson unsigned n_dma, uint32_t *liobns, Error **errp) 4076357d1e3bSDavid Gibson { 4077357d1e3bSDavid Gibson /* Legacy PHB placement for pseries-2.7 and earlier machine types */ 4078357d1e3bSDavid Gibson const uint64_t base_buid = 0x800000020000000ULL; 4079357d1e3bSDavid Gibson const hwaddr phb_spacing = 0x1000000000ULL; /* 64 GiB */ 4080357d1e3bSDavid Gibson const hwaddr mmio_offset = 0xa0000000; /* 2 GiB + 512 MiB */ 4081357d1e3bSDavid Gibson const hwaddr pio_offset = 0x80000000; /* 2 GiB */ 4082357d1e3bSDavid Gibson const uint32_t max_index = 255; 4083357d1e3bSDavid Gibson const hwaddr phb0_alignment = 0x10000000000ULL; /* 1 TiB */ 4084357d1e3bSDavid Gibson 4085357d1e3bSDavid Gibson uint64_t ram_top = MACHINE(spapr)->ram_size; 4086357d1e3bSDavid Gibson hwaddr phb0_base, phb_base; 4087357d1e3bSDavid Gibson int i; 4088357d1e3bSDavid Gibson 4089357d1e3bSDavid Gibson /* Do we have hotpluggable memory? */ 4090357d1e3bSDavid Gibson if (MACHINE(spapr)->maxram_size > ram_top) { 4091357d1e3bSDavid Gibson /* Can't just use maxram_size, because there may be an 4092357d1e3bSDavid Gibson * alignment gap between normal and hotpluggable memory 4093357d1e3bSDavid Gibson * regions */ 4094357d1e3bSDavid Gibson ram_top = spapr->hotplug_memory.base + 4095357d1e3bSDavid Gibson memory_region_size(&spapr->hotplug_memory.mr); 4096357d1e3bSDavid Gibson } 4097357d1e3bSDavid Gibson 4098357d1e3bSDavid Gibson phb0_base = QEMU_ALIGN_UP(ram_top, phb0_alignment); 4099357d1e3bSDavid Gibson 4100357d1e3bSDavid Gibson if (index > max_index) { 4101357d1e3bSDavid Gibson error_setg(errp, "\"index\" for PAPR PHB is too large (max %u)", 4102357d1e3bSDavid Gibson max_index); 4103357d1e3bSDavid Gibson return; 4104357d1e3bSDavid Gibson } 4105357d1e3bSDavid Gibson 4106357d1e3bSDavid Gibson *buid = base_buid + index; 4107357d1e3bSDavid Gibson for (i = 0; i < n_dma; ++i) { 4108357d1e3bSDavid Gibson liobns[i] = SPAPR_PCI_LIOBN(index, i); 4109357d1e3bSDavid Gibson } 4110357d1e3bSDavid Gibson 4111357d1e3bSDavid Gibson phb_base = phb0_base + index * phb_spacing; 4112357d1e3bSDavid Gibson *pio = phb_base + pio_offset; 4113357d1e3bSDavid Gibson *mmio32 = phb_base + mmio_offset; 4114357d1e3bSDavid Gibson /* 4115357d1e3bSDavid Gibson * We don't set the 64-bit MMIO window, relying on the PHB's 4116357d1e3bSDavid Gibson * fallback behaviour of automatically splitting a large "32-bit" 4117357d1e3bSDavid Gibson * window into contiguous 32-bit and 64-bit windows 4118357d1e3bSDavid Gibson */ 4119357d1e3bSDavid Gibson } 4120db800b21SDavid Gibson 41211ea1eefcSBharata B Rao static void spapr_machine_2_7_instance_options(MachineState *machine) 41221ea1eefcSBharata B Rao { 4123f6229214SMichael Roth sPAPRMachineState *spapr = SPAPR_MACHINE(machine); 4124f6229214SMichael Roth 4125672de881SMichael Roth spapr_machine_2_8_instance_options(machine); 4126f6229214SMichael Roth spapr->use_hotplug_event_source = false; 41271ea1eefcSBharata B Rao } 41281ea1eefcSBharata B Rao 41291ea1eefcSBharata B Rao static void spapr_machine_2_7_class_options(MachineClass *mc) 41301ea1eefcSBharata B Rao { 41313daa4a9fSThomas Huth sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); 41323daa4a9fSThomas Huth 4133db800b21SDavid Gibson spapr_machine_2_8_class_options(mc); 41342e9c10ebSIgor Mammedov mc->default_cpu_type = POWERPC_CPU_TYPE_NAME("power7_v2.3"); 4135db800b21SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_7); 4136357d1e3bSDavid Gibson smc->phb_placement = phb_placement_2_7; 41371ea1eefcSBharata B Rao } 41381ea1eefcSBharata B Rao 4139db800b21SDavid Gibson DEFINE_SPAPR_MACHINE(2_7, "2.7", false); 41401ea1eefcSBharata B Rao 41411ea1eefcSBharata B Rao /* 41424b23699cSDavid Gibson * pseries-2.6 41434b23699cSDavid Gibson */ 41441ea1eefcSBharata B Rao #define SPAPR_COMPAT_2_6 \ 4145ae4de14cSAlexey Kardashevskiy HW_COMPAT_2_6 \ 4146ae4de14cSAlexey Kardashevskiy { \ 4147ae4de14cSAlexey Kardashevskiy .driver = TYPE_SPAPR_PCI_HOST_BRIDGE,\ 4148ae4de14cSAlexey Kardashevskiy .property = "ddw",\ 4149ae4de14cSAlexey Kardashevskiy .value = stringify(off),\ 4150ae4de14cSAlexey Kardashevskiy }, 41511ea1eefcSBharata B Rao 41524b23699cSDavid Gibson static void spapr_machine_2_6_instance_options(MachineState *machine) 41534b23699cSDavid Gibson { 4154672de881SMichael Roth spapr_machine_2_7_instance_options(machine); 41554b23699cSDavid Gibson } 41564b23699cSDavid Gibson 41574b23699cSDavid Gibson static void spapr_machine_2_6_class_options(MachineClass *mc) 41584b23699cSDavid Gibson { 41591ea1eefcSBharata B Rao spapr_machine_2_7_class_options(mc); 4160c5514d0eSIgor Mammedov mc->has_hotpluggable_cpus = false; 41611ea1eefcSBharata B Rao SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_6); 41624b23699cSDavid Gibson } 41634b23699cSDavid Gibson 41641ea1eefcSBharata B Rao DEFINE_SPAPR_MACHINE(2_6, "2.6", false); 41654b23699cSDavid Gibson 41664b23699cSDavid Gibson /* 41671c5f29bbSDavid Gibson * pseries-2.5 41681c5f29bbSDavid Gibson */ 41694b23699cSDavid Gibson #define SPAPR_COMPAT_2_5 \ 417057c522f4SThomas Huth HW_COMPAT_2_5 \ 417157c522f4SThomas Huth { \ 417257c522f4SThomas Huth .driver = "spapr-vlan", \ 417357c522f4SThomas Huth .property = "use-rx-buffer-pools", \ 417457c522f4SThomas Huth .value = "off", \ 417557c522f4SThomas Huth }, 41764b23699cSDavid Gibson 41775013c547SDavid Gibson static void spapr_machine_2_5_instance_options(MachineState *machine) 41781c5f29bbSDavid Gibson { 4179672de881SMichael Roth spapr_machine_2_6_instance_options(machine); 41805013c547SDavid Gibson } 41815013c547SDavid Gibson 41825013c547SDavid Gibson static void spapr_machine_2_5_class_options(MachineClass *mc) 41835013c547SDavid Gibson { 418457040d45SThomas Huth sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); 418557040d45SThomas Huth 41864b23699cSDavid Gibson spapr_machine_2_6_class_options(mc); 418757040d45SThomas Huth smc->use_ohci_by_default = true; 41884b23699cSDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_5); 41891c5f29bbSDavid Gibson } 41901c5f29bbSDavid Gibson 41914b23699cSDavid Gibson DEFINE_SPAPR_MACHINE(2_5, "2.5", false); 41921c5f29bbSDavid Gibson 41931c5f29bbSDavid Gibson /* 41941c5f29bbSDavid Gibson * pseries-2.4 41951c5f29bbSDavid Gibson */ 419680fd50f9SCornelia Huck #define SPAPR_COMPAT_2_4 \ 419780fd50f9SCornelia Huck HW_COMPAT_2_4 419880fd50f9SCornelia Huck 41995013c547SDavid Gibson static void spapr_machine_2_4_instance_options(MachineState *machine) 42001c5f29bbSDavid Gibson { 42015013c547SDavid Gibson spapr_machine_2_5_instance_options(machine); 42025013c547SDavid Gibson } 42031c5f29bbSDavid Gibson 42045013c547SDavid Gibson static void spapr_machine_2_4_class_options(MachineClass *mc) 42055013c547SDavid Gibson { 4206fc9f38c3SDavid Gibson sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); 4207fc9f38c3SDavid Gibson 4208fc9f38c3SDavid Gibson spapr_machine_2_5_class_options(mc); 4209fc9f38c3SDavid Gibson smc->dr_lmb_enabled = false; 4210f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_4); 42111c5f29bbSDavid Gibson } 42121c5f29bbSDavid Gibson 4213fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_4, "2.4", false); 42141c5f29bbSDavid Gibson 42151c5f29bbSDavid Gibson /* 42161c5f29bbSDavid Gibson * pseries-2.3 42171c5f29bbSDavid Gibson */ 421838ff32c6SEduardo Habkost #define SPAPR_COMPAT_2_3 \ 42197619c7b0SMichael Roth HW_COMPAT_2_3 \ 42207619c7b0SMichael Roth {\ 42217619c7b0SMichael Roth .driver = "spapr-pci-host-bridge",\ 42227619c7b0SMichael Roth .property = "dynamic-reconfiguration",\ 42237619c7b0SMichael Roth .value = "off",\ 42247619c7b0SMichael Roth }, 422538ff32c6SEduardo Habkost 42265013c547SDavid Gibson static void spapr_machine_2_3_instance_options(MachineState *machine) 42271c5f29bbSDavid Gibson { 42285013c547SDavid Gibson spapr_machine_2_4_instance_options(machine); 42291c5f29bbSDavid Gibson } 42301c5f29bbSDavid Gibson 42315013c547SDavid Gibson static void spapr_machine_2_3_class_options(MachineClass *mc) 42321c5f29bbSDavid Gibson { 4233fc9f38c3SDavid Gibson spapr_machine_2_4_class_options(mc); 4234f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_3); 42351c5f29bbSDavid Gibson } 4236fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_3, "2.3", false); 42371c5f29bbSDavid Gibson 42381c5f29bbSDavid Gibson /* 42391c5f29bbSDavid Gibson * pseries-2.2 42401c5f29bbSDavid Gibson */ 42411c5f29bbSDavid Gibson 4242b194df47SAlexey Kardashevskiy #define SPAPR_COMPAT_2_2 \ 42434dfd8eaaSEduardo Habkost HW_COMPAT_2_2 \ 4244b194df47SAlexey Kardashevskiy {\ 4245b194df47SAlexey Kardashevskiy .driver = TYPE_SPAPR_PCI_HOST_BRIDGE,\ 4246b194df47SAlexey Kardashevskiy .property = "mem_win_size",\ 4247b194df47SAlexey Kardashevskiy .value = "0x20000000",\ 4248dd754bafSEduardo Habkost }, 4249b194df47SAlexey Kardashevskiy 42505013c547SDavid Gibson static void spapr_machine_2_2_instance_options(MachineState *machine) 4251b0e966d0SJason Wang { 42525013c547SDavid Gibson spapr_machine_2_3_instance_options(machine); 4253cba0e779SGreg Kurz machine->suppress_vmdesc = true; 4254b0e966d0SJason Wang } 4255b0e966d0SJason Wang 42565013c547SDavid Gibson static void spapr_machine_2_2_class_options(MachineClass *mc) 4257b0e966d0SJason Wang { 4258fc9f38c3SDavid Gibson spapr_machine_2_3_class_options(mc); 4259f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_2); 42601c5f29bbSDavid Gibson } 4261fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_2, "2.2", false); 42621c5f29bbSDavid Gibson 42631c5f29bbSDavid Gibson /* 42641c5f29bbSDavid Gibson * pseries-2.1 42651c5f29bbSDavid Gibson */ 42661c5f29bbSDavid Gibson #define SPAPR_COMPAT_2_1 \ 42671c5f29bbSDavid Gibson HW_COMPAT_2_1 42681c5f29bbSDavid Gibson 42695013c547SDavid Gibson static void spapr_machine_2_1_instance_options(MachineState *machine) 42701c5f29bbSDavid Gibson { 42715013c547SDavid Gibson spapr_machine_2_2_instance_options(machine); 42721c5f29bbSDavid Gibson } 42731c5f29bbSDavid Gibson 42745013c547SDavid Gibson static void spapr_machine_2_1_class_options(MachineClass *mc) 4275b0e966d0SJason Wang { 4276fc9f38c3SDavid Gibson spapr_machine_2_2_class_options(mc); 4277f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_1); 42786026db45SAlexey Kardashevskiy } 4279fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_1, "2.1", false); 42806026db45SAlexey Kardashevskiy 428129ee3247SAlexey Kardashevskiy static void spapr_machine_register_types(void) 428229ee3247SAlexey Kardashevskiy { 428329ee3247SAlexey Kardashevskiy type_register_static(&spapr_machine_info); 428429ee3247SAlexey Kardashevskiy } 428529ee3247SAlexey Kardashevskiy 428629ee3247SAlexey Kardashevskiy type_init(spapr_machine_register_types) 4287