153018216SPaolo Bonzini /* 253018216SPaolo Bonzini * QEMU PowerPC pSeries Logical Partition (aka sPAPR) hardware System Emulator 353018216SPaolo Bonzini * 453018216SPaolo Bonzini * Copyright (c) 2004-2007 Fabrice Bellard 553018216SPaolo Bonzini * Copyright (c) 2007 Jocelyn Mayer 653018216SPaolo Bonzini * Copyright (c) 2010 David Gibson, IBM Corporation. 753018216SPaolo Bonzini * 853018216SPaolo Bonzini * Permission is hereby granted, free of charge, to any person obtaining a copy 953018216SPaolo Bonzini * of this software and associated documentation files (the "Software"), to deal 1053018216SPaolo Bonzini * in the Software without restriction, including without limitation the rights 1153018216SPaolo Bonzini * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 1253018216SPaolo Bonzini * copies of the Software, and to permit persons to whom the Software is 1353018216SPaolo Bonzini * furnished to do so, subject to the following conditions: 1453018216SPaolo Bonzini * 1553018216SPaolo Bonzini * The above copyright notice and this permission notice shall be included in 1653018216SPaolo Bonzini * all copies or substantial portions of the Software. 1753018216SPaolo Bonzini * 1853018216SPaolo Bonzini * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 1953018216SPaolo Bonzini * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 2053018216SPaolo Bonzini * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 2153018216SPaolo Bonzini * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 2253018216SPaolo Bonzini * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 2353018216SPaolo Bonzini * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 2453018216SPaolo Bonzini * THE SOFTWARE. 2553018216SPaolo Bonzini * 2653018216SPaolo Bonzini */ 270d75590dSPeter Maydell #include "qemu/osdep.h" 28da34e65cSMarkus Armbruster #include "qapi/error.h" 2953018216SPaolo Bonzini #include "sysemu/sysemu.h" 30e35704baSEduardo Habkost #include "sysemu/numa.h" 3153018216SPaolo Bonzini #include "hw/hw.h" 3203dd024fSPaolo Bonzini #include "qemu/log.h" 3371461b0fSAlexey Kardashevskiy #include "hw/fw-path-provider.h" 3453018216SPaolo Bonzini #include "elf.h" 3553018216SPaolo Bonzini #include "net/net.h" 36ad440b4aSAndrew Jones #include "sysemu/device_tree.h" 37fa1d36dfSMarkus Armbruster #include "sysemu/block-backend.h" 3853018216SPaolo Bonzini #include "sysemu/cpus.h" 39b3946626SVincent Palatin #include "sysemu/hw_accel.h" 4053018216SPaolo Bonzini #include "kvm_ppc.h" 41c4b63b7cSJuan Quintela #include "migration/misc.h" 4284a899deSJuan Quintela #include "migration/global_state.h" 43f2a8f0a6SJuan Quintela #include "migration/register.h" 444be21d56SDavid Gibson #include "mmu-hash64.h" 45b4db5413SSuraj Jitindar Singh #include "mmu-book3s-v3.h" 463794d548SAlexey Kardashevskiy #include "qom/cpu.h" 4753018216SPaolo Bonzini 4853018216SPaolo Bonzini #include "hw/boards.h" 490d09e41aSPaolo Bonzini #include "hw/ppc/ppc.h" 5053018216SPaolo Bonzini #include "hw/loader.h" 5153018216SPaolo Bonzini 527804c353SCédric Le Goater #include "hw/ppc/fdt.h" 530d09e41aSPaolo Bonzini #include "hw/ppc/spapr.h" 540d09e41aSPaolo Bonzini #include "hw/ppc/spapr_vio.h" 550d09e41aSPaolo Bonzini #include "hw/pci-host/spapr.h" 560d09e41aSPaolo Bonzini #include "hw/ppc/xics.h" 5753018216SPaolo Bonzini #include "hw/pci/msi.h" 5853018216SPaolo Bonzini 5953018216SPaolo Bonzini #include "hw/pci/pci.h" 6071461b0fSAlexey Kardashevskiy #include "hw/scsi/scsi.h" 6171461b0fSAlexey Kardashevskiy #include "hw/virtio/virtio-scsi.h" 62c4e13492SFelipe Franciosi #include "hw/virtio/vhost-scsi-common.h" 6353018216SPaolo Bonzini 6453018216SPaolo Bonzini #include "exec/address-spaces.h" 6553018216SPaolo Bonzini #include "hw/usb.h" 6653018216SPaolo Bonzini #include "qemu/config-file.h" 67135a129aSAneesh Kumar K.V #include "qemu/error-report.h" 682a6593cbSAlexey Kardashevskiy #include "trace.h" 6934316482SAlexey Kardashevskiy #include "hw/nmi.h" 706449da45SCédric Le Goater #include "hw/intc/intc.h" 7153018216SPaolo Bonzini 7268a27b20SMichael S. Tsirkin #include "hw/compat.h" 73f348b6d1SVeronia Bahaa #include "qemu/cutils.h" 7494a94e4cSBharata B Rao #include "hw/ppc/spapr_cpu_core.h" 752474bfd4SIgor Mammedov #include "qmp-commands.h" 7668a27b20SMichael S. Tsirkin 7753018216SPaolo Bonzini #include <libfdt.h> 7853018216SPaolo Bonzini 7953018216SPaolo Bonzini /* SLOF memory layout: 8053018216SPaolo Bonzini * 8153018216SPaolo Bonzini * SLOF raw image loaded at 0, copies its romfs right below the flat 8253018216SPaolo Bonzini * device-tree, then position SLOF itself 31M below that 8353018216SPaolo Bonzini * 8453018216SPaolo Bonzini * So we set FW_OVERHEAD to 40MB which should account for all of that 8553018216SPaolo Bonzini * and more 8653018216SPaolo Bonzini * 8753018216SPaolo Bonzini * We load our kernel at 4M, leaving space for SLOF initial image 8853018216SPaolo Bonzini */ 8938b02bd8SAlexey Kardashevskiy #define FDT_MAX_SIZE 0x100000 9053018216SPaolo Bonzini #define RTAS_MAX_SIZE 0x10000 91b7d1f77aSBenjamin Herrenschmidt #define RTAS_MAX_ADDR 0x80000000 /* RTAS must stay below that */ 9253018216SPaolo Bonzini #define FW_MAX_SIZE 0x400000 9353018216SPaolo Bonzini #define FW_FILE_NAME "slof.bin" 9453018216SPaolo Bonzini #define FW_OVERHEAD 0x2800000 9553018216SPaolo Bonzini #define KERNEL_LOAD_ADDR FW_MAX_SIZE 9653018216SPaolo Bonzini 9753018216SPaolo Bonzini #define MIN_RMA_SLOF 128UL 9853018216SPaolo Bonzini 9953018216SPaolo Bonzini #define PHANDLE_XICP 0x00001111 10053018216SPaolo Bonzini 10171cd4dacSCédric Le Goater static ICSState *spapr_ics_create(sPAPRMachineState *spapr, 10271cd4dacSCédric Le Goater const char *type_ics, 103817bb6a4SCédric Le Goater int nr_irqs, Error **errp) 104c04d6cfaSAnthony Liguori { 105175d2aa0SGreg Kurz Error *local_err = NULL; 10671cd4dacSCédric Le Goater Object *obj; 107c04d6cfaSAnthony Liguori 10871cd4dacSCédric Le Goater obj = object_new(type_ics); 109175d2aa0SGreg Kurz object_property_add_child(OBJECT(spapr), "ics", obj, &error_abort); 110ad265631SGreg Kurz object_property_add_const_link(obj, ICS_PROP_XICS, OBJECT(spapr), 111ad265631SGreg Kurz &error_abort); 112175d2aa0SGreg Kurz object_property_set_int(obj, nr_irqs, "nr-irqs", &local_err); 113175d2aa0SGreg Kurz if (local_err) { 114175d2aa0SGreg Kurz goto error; 115175d2aa0SGreg Kurz } 11671cd4dacSCédric Le Goater object_property_set_bool(obj, true, "realized", &local_err); 117175d2aa0SGreg Kurz if (local_err) { 118175d2aa0SGreg Kurz goto error; 119c04d6cfaSAnthony Liguori } 120c04d6cfaSAnthony Liguori 12171cd4dacSCédric Le Goater return ICS_SIMPLE(obj); 122175d2aa0SGreg Kurz 123175d2aa0SGreg Kurz error: 124175d2aa0SGreg Kurz error_propagate(errp, local_err); 125175d2aa0SGreg Kurz return NULL; 1265bc8d26dSCédric Le Goater } 1275bc8d26dSCédric Le Goater 12846f7afa3SGreg Kurz static bool pre_2_10_vmstate_dummy_icp_needed(void *opaque) 12946f7afa3SGreg Kurz { 13046f7afa3SGreg Kurz /* Dummy entries correspond to unused ICPState objects in older QEMUs, 13146f7afa3SGreg Kurz * and newer QEMUs don't even have them. In both cases, we don't want 13246f7afa3SGreg Kurz * to send anything on the wire. 13346f7afa3SGreg Kurz */ 13446f7afa3SGreg Kurz return false; 13546f7afa3SGreg Kurz } 13646f7afa3SGreg Kurz 13746f7afa3SGreg Kurz static const VMStateDescription pre_2_10_vmstate_dummy_icp = { 13846f7afa3SGreg Kurz .name = "icp/server", 13946f7afa3SGreg Kurz .version_id = 1, 14046f7afa3SGreg Kurz .minimum_version_id = 1, 14146f7afa3SGreg Kurz .needed = pre_2_10_vmstate_dummy_icp_needed, 14246f7afa3SGreg Kurz .fields = (VMStateField[]) { 14346f7afa3SGreg Kurz VMSTATE_UNUSED(4), /* uint32_t xirr */ 14446f7afa3SGreg Kurz VMSTATE_UNUSED(1), /* uint8_t pending_priority */ 14546f7afa3SGreg Kurz VMSTATE_UNUSED(1), /* uint8_t mfrr */ 14646f7afa3SGreg Kurz VMSTATE_END_OF_LIST() 14746f7afa3SGreg Kurz }, 14846f7afa3SGreg Kurz }; 14946f7afa3SGreg Kurz 15046f7afa3SGreg Kurz static void pre_2_10_vmstate_register_dummy_icp(int i) 15146f7afa3SGreg Kurz { 15246f7afa3SGreg Kurz vmstate_register(NULL, i, &pre_2_10_vmstate_dummy_icp, 15346f7afa3SGreg Kurz (void *)(uintptr_t) i); 15446f7afa3SGreg Kurz } 15546f7afa3SGreg Kurz 15646f7afa3SGreg Kurz static void pre_2_10_vmstate_unregister_dummy_icp(int i) 15746f7afa3SGreg Kurz { 15846f7afa3SGreg Kurz vmstate_unregister(NULL, &pre_2_10_vmstate_dummy_icp, 15946f7afa3SGreg Kurz (void *)(uintptr_t) i); 16046f7afa3SGreg Kurz } 16146f7afa3SGreg Kurz 16246f7afa3SGreg Kurz static inline int xics_max_server_number(void) 16346f7afa3SGreg Kurz { 16446f7afa3SGreg Kurz return DIV_ROUND_UP(max_cpus * kvmppc_smt_threads(), smp_threads); 16546f7afa3SGreg Kurz } 16646f7afa3SGreg Kurz 16771cd4dacSCédric Le Goater static void xics_system_init(MachineState *machine, int nr_irqs, Error **errp) 168c04d6cfaSAnthony Liguori { 16971cd4dacSCédric Le Goater sPAPRMachineState *spapr = SPAPR_MACHINE(machine); 17046f7afa3SGreg Kurz sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(machine); 171c04d6cfaSAnthony Liguori 17211ad93f6SDavid Gibson if (kvm_enabled()) { 1732192a930SCédric Le Goater if (machine_kernel_irqchip_allowed(machine) && 17471cd4dacSCédric Le Goater !xics_kvm_init(spapr, errp)) { 17571cd4dacSCédric Le Goater spapr->icp_type = TYPE_KVM_ICP; 1763d85885aSGreg Kurz spapr->ics = spapr_ics_create(spapr, TYPE_ICS_KVM, nr_irqs, errp); 17711ad93f6SDavid Gibson } 17871cd4dacSCédric Le Goater if (machine_kernel_irqchip_required(machine) && !spapr->ics) { 1793d85885aSGreg Kurz error_prepend(errp, "kernel_irqchip requested but unavailable: "); 1803d85885aSGreg Kurz return; 18111ad93f6SDavid Gibson } 182b83baa60SMarkus Armbruster } 18311ad93f6SDavid Gibson 18471cd4dacSCédric Le Goater if (!spapr->ics) { 185f63ebfe0SGreg Kurz xics_spapr_init(spapr); 18671cd4dacSCédric Le Goater spapr->icp_type = TYPE_ICP; 18771cd4dacSCédric Le Goater spapr->ics = spapr_ics_create(spapr, TYPE_ICS_SIMPLE, nr_irqs, errp); 1883d85885aSGreg Kurz if (!spapr->ics) { 1893d85885aSGreg Kurz return; 1903d85885aSGreg Kurz } 191c04d6cfaSAnthony Liguori } 19246f7afa3SGreg Kurz 19346f7afa3SGreg Kurz if (smc->pre_2_10_has_unused_icps) { 19446f7afa3SGreg Kurz int i; 19546f7afa3SGreg Kurz 19646f7afa3SGreg Kurz for (i = 0; i < xics_max_server_number(); i++) { 19746f7afa3SGreg Kurz /* Dummy entries get deregistered when real ICPState objects 19846f7afa3SGreg Kurz * are registered during CPU core hotplug. 19946f7afa3SGreg Kurz */ 20046f7afa3SGreg Kurz pre_2_10_vmstate_register_dummy_icp(i); 20146f7afa3SGreg Kurz } 20246f7afa3SGreg Kurz } 203c04d6cfaSAnthony Liguori } 204c04d6cfaSAnthony Liguori 205833d4668SAlexey Kardashevskiy static int spapr_fixup_cpu_smt_dt(void *fdt, int offset, PowerPCCPU *cpu, 206833d4668SAlexey Kardashevskiy int smt_threads) 207833d4668SAlexey Kardashevskiy { 208833d4668SAlexey Kardashevskiy int i, ret = 0; 209833d4668SAlexey Kardashevskiy uint32_t servers_prop[smt_threads]; 210833d4668SAlexey Kardashevskiy uint32_t gservers_prop[smt_threads * 2]; 211833d4668SAlexey Kardashevskiy int index = ppc_get_vcpu_dt_id(cpu); 212833d4668SAlexey Kardashevskiy 213d6e166c0SDavid Gibson if (cpu->compat_pvr) { 214d6e166c0SDavid Gibson ret = fdt_setprop_cell(fdt, offset, "cpu-version", cpu->compat_pvr); 2156d9412eaSAlexey Kardashevskiy if (ret < 0) { 2166d9412eaSAlexey Kardashevskiy return ret; 2176d9412eaSAlexey Kardashevskiy } 2186d9412eaSAlexey Kardashevskiy } 2196d9412eaSAlexey Kardashevskiy 220833d4668SAlexey Kardashevskiy /* Build interrupt servers and gservers properties */ 221833d4668SAlexey Kardashevskiy for (i = 0; i < smt_threads; i++) { 222833d4668SAlexey Kardashevskiy servers_prop[i] = cpu_to_be32(index + i); 223833d4668SAlexey Kardashevskiy /* Hack, direct the group queues back to cpu 0 */ 224833d4668SAlexey Kardashevskiy gservers_prop[i*2] = cpu_to_be32(index + i); 225833d4668SAlexey Kardashevskiy gservers_prop[i*2 + 1] = 0; 226833d4668SAlexey Kardashevskiy } 227833d4668SAlexey Kardashevskiy ret = fdt_setprop(fdt, offset, "ibm,ppc-interrupt-server#s", 228833d4668SAlexey Kardashevskiy servers_prop, sizeof(servers_prop)); 229833d4668SAlexey Kardashevskiy if (ret < 0) { 230833d4668SAlexey Kardashevskiy return ret; 231833d4668SAlexey Kardashevskiy } 232833d4668SAlexey Kardashevskiy ret = fdt_setprop(fdt, offset, "ibm,ppc-interrupt-gserver#s", 233833d4668SAlexey Kardashevskiy gservers_prop, sizeof(gservers_prop)); 234833d4668SAlexey Kardashevskiy 235833d4668SAlexey Kardashevskiy return ret; 236833d4668SAlexey Kardashevskiy } 237833d4668SAlexey Kardashevskiy 23899861ecbSIgor Mammedov static int spapr_fixup_cpu_numa_dt(void *fdt, int offset, PowerPCCPU *cpu) 2390da6f3feSBharata B Rao { 2400da6f3feSBharata B Rao int index = ppc_get_vcpu_dt_id(cpu); 2410da6f3feSBharata B Rao uint32_t associativity[] = {cpu_to_be32(0x5), 2420da6f3feSBharata B Rao cpu_to_be32(0x0), 2430da6f3feSBharata B Rao cpu_to_be32(0x0), 2440da6f3feSBharata B Rao cpu_to_be32(0x0), 24515f8b142SIgor Mammedov cpu_to_be32(cpu->node_id), 2460da6f3feSBharata B Rao cpu_to_be32(index)}; 2470da6f3feSBharata B Rao 2480da6f3feSBharata B Rao /* Advertise NUMA via ibm,associativity */ 24999861ecbSIgor Mammedov return fdt_setprop(fdt, offset, "ibm,associativity", associativity, 2500da6f3feSBharata B Rao sizeof(associativity)); 2510da6f3feSBharata B Rao } 2520da6f3feSBharata B Rao 25386d5771aSSam Bobroff /* Populate the "ibm,pa-features" property */ 254e957f6a9SSam Bobroff static void spapr_populate_pa_features(CPUPPCState *env, void *fdt, int offset, 255e957f6a9SSam Bobroff bool legacy_guest) 25686d5771aSSam Bobroff { 25786d5771aSSam Bobroff uint8_t pa_features_206[] = { 6, 0, 25886d5771aSSam Bobroff 0xf6, 0x1f, 0xc7, 0x00, 0x80, 0xc0 }; 25986d5771aSSam Bobroff uint8_t pa_features_207[] = { 24, 0, 26086d5771aSSam Bobroff 0xf6, 0x1f, 0xc7, 0xc0, 0x80, 0xf0, 26186d5771aSSam Bobroff 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 26286d5771aSSam Bobroff 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 26386d5771aSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x00, 0x00 }; 2649fb4541fSSam Bobroff uint8_t pa_features_300[] = { 66, 0, 2659fb4541fSSam Bobroff /* 0: MMU|FPU|SLB|RUN|DABR|NX, 1: fri[nzpm]|DABRX|SPRG3|SLB0|PP110 */ 2669fb4541fSSam Bobroff /* 2: VPM|DS205|PPR|DS202|DS206, 3: LSD|URG, SSO, 5: LE|CFAR|EB|LSQ */ 26786d5771aSSam Bobroff 0xf6, 0x1f, 0xc7, 0xc0, 0x80, 0xf0, /* 0 - 5 */ 2689fb4541fSSam Bobroff /* 6: DS207 */ 26986d5771aSSam Bobroff 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, /* 6 - 11 */ 2709fb4541fSSam Bobroff /* 16: Vector */ 27186d5771aSSam Bobroff 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, /* 12 - 17 */ 2729fb4541fSSam Bobroff /* 18: Vec. Scalar, 20: Vec. XOR, 22: HTM */ 2739bf502feSDavid Gibson 0x80, 0x00, 0x80, 0x00, 0x00, 0x00, /* 18 - 23 */ 2749fb4541fSSam Bobroff /* 24: Ext. Dec, 26: 64 bit ftrs, 28: PM ftrs */ 2759fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, /* 24 - 29 */ 2769fb4541fSSam Bobroff /* 30: MMR, 32: LE atomic, 34: EBB + ext EBB */ 2779fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0xC0, 0x00, /* 30 - 35 */ 2789fb4541fSSam Bobroff /* 36: SPR SO, 38: Copy/Paste, 40: Radix MMU */ 2799fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, /* 36 - 41 */ 2809fb4541fSSam Bobroff /* 42: PM, 44: PC RA, 46: SC vec'd */ 2819fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, /* 42 - 47 */ 2829fb4541fSSam Bobroff /* 48: SIMD, 50: QP BFP, 52: String */ 2839fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, /* 48 - 53 */ 2849fb4541fSSam Bobroff /* 54: DecFP, 56: DecI, 58: SHA */ 2859fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, /* 54 - 59 */ 2869fb4541fSSam Bobroff /* 60: NM atomic, 62: RNG */ 2879fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x00, 0x00, /* 60 - 65 */ 2889fb4541fSSam Bobroff }; 28986d5771aSSam Bobroff uint8_t *pa_features; 29086d5771aSSam Bobroff size_t pa_size; 29186d5771aSSam Bobroff 29286d5771aSSam Bobroff switch (POWERPC_MMU_VER(env->mmu_model)) { 29386d5771aSSam Bobroff case POWERPC_MMU_VER_2_06: 29486d5771aSSam Bobroff pa_features = pa_features_206; 29586d5771aSSam Bobroff pa_size = sizeof(pa_features_206); 29686d5771aSSam Bobroff break; 29786d5771aSSam Bobroff case POWERPC_MMU_VER_2_07: 29886d5771aSSam Bobroff pa_features = pa_features_207; 29986d5771aSSam Bobroff pa_size = sizeof(pa_features_207); 30086d5771aSSam Bobroff break; 30186d5771aSSam Bobroff case POWERPC_MMU_VER_3_00: 30286d5771aSSam Bobroff pa_features = pa_features_300; 30386d5771aSSam Bobroff pa_size = sizeof(pa_features_300); 30486d5771aSSam Bobroff break; 30586d5771aSSam Bobroff default: 30686d5771aSSam Bobroff return; 30786d5771aSSam Bobroff } 30886d5771aSSam Bobroff 30986d5771aSSam Bobroff if (env->ci_large_pages) { 31086d5771aSSam Bobroff /* 31186d5771aSSam Bobroff * Note: we keep CI large pages off by default because a 64K capable 31286d5771aSSam Bobroff * guest provisioned with large pages might otherwise try to map a qemu 31386d5771aSSam Bobroff * framebuffer (or other kind of memory mapped PCI BAR) using 64K pages 31486d5771aSSam Bobroff * even if that qemu runs on a 4k host. 31586d5771aSSam Bobroff * We dd this bit back here if we are confident this is not an issue 31686d5771aSSam Bobroff */ 31786d5771aSSam Bobroff pa_features[3] |= 0x20; 31886d5771aSSam Bobroff } 31986d5771aSSam Bobroff if (kvmppc_has_cap_htm() && pa_size > 24) { 32086d5771aSSam Bobroff pa_features[24] |= 0x80; /* Transactional memory support */ 32186d5771aSSam Bobroff } 322e957f6a9SSam Bobroff if (legacy_guest && pa_size > 40) { 323e957f6a9SSam Bobroff /* Workaround for broken kernels that attempt (guest) radix 324e957f6a9SSam Bobroff * mode when they can't handle it, if they see the radix bit set 325e957f6a9SSam Bobroff * in pa-features. So hide it from them. */ 326e957f6a9SSam Bobroff pa_features[40 + 2] &= ~0x80; /* Radix MMU */ 327e957f6a9SSam Bobroff } 32886d5771aSSam Bobroff 32986d5771aSSam Bobroff _FDT((fdt_setprop(fdt, offset, "ibm,pa-features", pa_features, pa_size))); 33086d5771aSSam Bobroff } 33186d5771aSSam Bobroff 33228e02042SDavid Gibson static int spapr_fixup_cpu_dt(void *fdt, sPAPRMachineState *spapr) 33353018216SPaolo Bonzini { 33482677ed2SAlexey Kardashevskiy int ret = 0, offset, cpus_offset; 33582677ed2SAlexey Kardashevskiy CPUState *cs; 33653018216SPaolo Bonzini char cpu_model[32]; 33753018216SPaolo Bonzini int smt = kvmppc_smt_threads(); 33853018216SPaolo Bonzini uint32_t pft_size_prop[] = {0, cpu_to_be32(spapr->htab_shift)}; 33953018216SPaolo Bonzini 34082677ed2SAlexey Kardashevskiy CPU_FOREACH(cs) { 34182677ed2SAlexey Kardashevskiy PowerPCCPU *cpu = POWERPC_CPU(cs); 342e957f6a9SSam Bobroff CPUPPCState *env = &cpu->env; 34382677ed2SAlexey Kardashevskiy DeviceClass *dc = DEVICE_GET_CLASS(cs); 34482677ed2SAlexey Kardashevskiy int index = ppc_get_vcpu_dt_id(cpu); 34512dbeb16SDavid Gibson int compat_smt = MIN(smp_threads, ppc_compat_max_threads(cpu)); 34653018216SPaolo Bonzini 3470f20ba62SAlexey Kardashevskiy if ((index % smt) != 0) { 34853018216SPaolo Bonzini continue; 34953018216SPaolo Bonzini } 35053018216SPaolo Bonzini 35182677ed2SAlexey Kardashevskiy snprintf(cpu_model, 32, "%s@%x", dc->fw_name, index); 35253018216SPaolo Bonzini 35382677ed2SAlexey Kardashevskiy cpus_offset = fdt_path_offset(fdt, "/cpus"); 35482677ed2SAlexey Kardashevskiy if (cpus_offset < 0) { 35582677ed2SAlexey Kardashevskiy cpus_offset = fdt_add_subnode(fdt, fdt_path_offset(fdt, "/"), 35682677ed2SAlexey Kardashevskiy "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 387e957f6a9SSam Bobroff spapr_populate_pa_features(env, fdt, offset, 388e957f6a9SSam Bobroff spapr->cas_legacy_guest_workaround); 38953018216SPaolo Bonzini } 39053018216SPaolo Bonzini return ret; 39153018216SPaolo Bonzini } 39253018216SPaolo Bonzini 393b082d65aSAlexey Kardashevskiy static hwaddr spapr_node0_size(void) 394b082d65aSAlexey Kardashevskiy { 395fb164994SDavid Gibson MachineState *machine = MACHINE(qdev_get_machine()); 396fb164994SDavid Gibson 397b082d65aSAlexey Kardashevskiy if (nb_numa_nodes) { 398b082d65aSAlexey Kardashevskiy int i; 399b082d65aSAlexey Kardashevskiy for (i = 0; i < nb_numa_nodes; ++i) { 400b082d65aSAlexey Kardashevskiy if (numa_info[i].node_mem) { 401fb164994SDavid Gibson return MIN(pow2floor(numa_info[i].node_mem), 402fb164994SDavid Gibson machine->ram_size); 403b082d65aSAlexey Kardashevskiy } 404b082d65aSAlexey Kardashevskiy } 405b082d65aSAlexey Kardashevskiy } 406fb164994SDavid Gibson return machine->ram_size; 407b082d65aSAlexey Kardashevskiy } 408b082d65aSAlexey Kardashevskiy 409a1d59c0fSAlexey Kardashevskiy static void add_str(GString *s, const gchar *s1) 410a1d59c0fSAlexey Kardashevskiy { 411a1d59c0fSAlexey Kardashevskiy g_string_append_len(s, s1, strlen(s1) + 1); 412a1d59c0fSAlexey Kardashevskiy } 41353018216SPaolo Bonzini 41403d196b7SBharata B Rao static int spapr_populate_memory_node(void *fdt, int nodeid, hwaddr start, 41526a8c353SAlexey Kardashevskiy hwaddr size) 41626a8c353SAlexey Kardashevskiy { 41726a8c353SAlexey Kardashevskiy uint32_t associativity[] = { 41826a8c353SAlexey Kardashevskiy cpu_to_be32(0x4), /* length */ 41926a8c353SAlexey Kardashevskiy cpu_to_be32(0x0), cpu_to_be32(0x0), 420c3b4f589SAlexey Kardashevskiy cpu_to_be32(0x0), cpu_to_be32(nodeid) 42126a8c353SAlexey Kardashevskiy }; 42226a8c353SAlexey Kardashevskiy char mem_name[32]; 42326a8c353SAlexey Kardashevskiy uint64_t mem_reg_property[2]; 42426a8c353SAlexey Kardashevskiy int off; 42526a8c353SAlexey Kardashevskiy 42626a8c353SAlexey Kardashevskiy mem_reg_property[0] = cpu_to_be64(start); 42726a8c353SAlexey Kardashevskiy mem_reg_property[1] = cpu_to_be64(size); 42826a8c353SAlexey Kardashevskiy 42926a8c353SAlexey Kardashevskiy sprintf(mem_name, "memory@" TARGET_FMT_lx, start); 43026a8c353SAlexey Kardashevskiy off = fdt_add_subnode(fdt, 0, mem_name); 43126a8c353SAlexey Kardashevskiy _FDT(off); 43226a8c353SAlexey Kardashevskiy _FDT((fdt_setprop_string(fdt, off, "device_type", "memory"))); 43326a8c353SAlexey Kardashevskiy _FDT((fdt_setprop(fdt, off, "reg", mem_reg_property, 43426a8c353SAlexey Kardashevskiy sizeof(mem_reg_property)))); 43526a8c353SAlexey Kardashevskiy _FDT((fdt_setprop(fdt, off, "ibm,associativity", associativity, 43626a8c353SAlexey Kardashevskiy sizeof(associativity)))); 43703d196b7SBharata B Rao return off; 43826a8c353SAlexey Kardashevskiy } 43926a8c353SAlexey Kardashevskiy 44028e02042SDavid Gibson static int spapr_populate_memory(sPAPRMachineState *spapr, void *fdt) 44153018216SPaolo Bonzini { 442fb164994SDavid Gibson MachineState *machine = MACHINE(spapr); 4437db8a127SAlexey Kardashevskiy hwaddr mem_start, node_size; 4447db8a127SAlexey Kardashevskiy int i, nb_nodes = nb_numa_nodes; 4457db8a127SAlexey Kardashevskiy NodeInfo *nodes = numa_info; 4467db8a127SAlexey Kardashevskiy NodeInfo ramnode; 44753018216SPaolo Bonzini 4487db8a127SAlexey Kardashevskiy /* No NUMA nodes, assume there is just one node with whole RAM */ 4497db8a127SAlexey Kardashevskiy if (!nb_numa_nodes) { 4507db8a127SAlexey Kardashevskiy nb_nodes = 1; 451fb164994SDavid Gibson ramnode.node_mem = machine->ram_size; 4527db8a127SAlexey Kardashevskiy nodes = &ramnode; 4535fe269b1SPaul Mackerras } 45453018216SPaolo Bonzini 4557db8a127SAlexey Kardashevskiy for (i = 0, mem_start = 0; i < nb_nodes; ++i) { 4567db8a127SAlexey Kardashevskiy if (!nodes[i].node_mem) { 4577db8a127SAlexey Kardashevskiy continue; 45853018216SPaolo Bonzini } 459fb164994SDavid Gibson if (mem_start >= machine->ram_size) { 4605fe269b1SPaul Mackerras node_size = 0; 4615fe269b1SPaul Mackerras } else { 4627db8a127SAlexey Kardashevskiy node_size = nodes[i].node_mem; 463fb164994SDavid Gibson if (node_size > machine->ram_size - mem_start) { 464fb164994SDavid Gibson node_size = machine->ram_size - mem_start; 4655fe269b1SPaul Mackerras } 4665fe269b1SPaul Mackerras } 4677db8a127SAlexey Kardashevskiy if (!mem_start) { 4687db8a127SAlexey Kardashevskiy /* ppc_spapr_init() checks for rma_size <= node0_size already */ 469e8f986fcSBharata B Rao spapr_populate_memory_node(fdt, i, 0, spapr->rma_size); 4707db8a127SAlexey Kardashevskiy mem_start += spapr->rma_size; 4717db8a127SAlexey Kardashevskiy node_size -= spapr->rma_size; 4727db8a127SAlexey Kardashevskiy } 4736010818cSAlexey Kardashevskiy for ( ; node_size; ) { 4746010818cSAlexey Kardashevskiy hwaddr sizetmp = pow2floor(node_size); 4756010818cSAlexey Kardashevskiy 4766010818cSAlexey Kardashevskiy /* mem_start != 0 here */ 4776010818cSAlexey Kardashevskiy if (ctzl(mem_start) < ctzl(sizetmp)) { 4786010818cSAlexey Kardashevskiy sizetmp = 1ULL << ctzl(mem_start); 4796010818cSAlexey Kardashevskiy } 4806010818cSAlexey Kardashevskiy 4816010818cSAlexey Kardashevskiy spapr_populate_memory_node(fdt, i, mem_start, sizetmp); 4826010818cSAlexey Kardashevskiy node_size -= sizetmp; 4836010818cSAlexey Kardashevskiy mem_start += sizetmp; 4846010818cSAlexey Kardashevskiy } 48553018216SPaolo Bonzini } 48653018216SPaolo Bonzini 48753018216SPaolo Bonzini return 0; 48853018216SPaolo Bonzini } 48953018216SPaolo Bonzini 4900da6f3feSBharata B Rao static void spapr_populate_cpu_dt(CPUState *cs, void *fdt, int offset, 4910da6f3feSBharata B Rao sPAPRMachineState *spapr) 4920da6f3feSBharata B Rao { 4930da6f3feSBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(cs); 4940da6f3feSBharata B Rao CPUPPCState *env = &cpu->env; 4950da6f3feSBharata B Rao PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(cs); 4960da6f3feSBharata B Rao int index = ppc_get_vcpu_dt_id(cpu); 4970da6f3feSBharata B Rao uint32_t segs[] = {cpu_to_be32(28), cpu_to_be32(40), 4980da6f3feSBharata B Rao 0xffffffff, 0xffffffff}; 499afd10a0fSBharata B Rao uint32_t tbfreq = kvm_enabled() ? kvmppc_get_tbfreq() 500afd10a0fSBharata B Rao : SPAPR_TIMEBASE_FREQ; 5010da6f3feSBharata B Rao uint32_t cpufreq = kvm_enabled() ? kvmppc_get_clockfreq() : 1000000000; 5020da6f3feSBharata B Rao uint32_t page_sizes_prop[64]; 5030da6f3feSBharata B Rao size_t page_sizes_prop_size; 50422419c2aSDavid Gibson uint32_t vcpus_per_socket = smp_threads * smp_cores; 5050da6f3feSBharata B Rao uint32_t pft_size_prop[] = {0, cpu_to_be32(spapr->htab_shift)}; 50612dbeb16SDavid Gibson int compat_smt = MIN(smp_threads, ppc_compat_max_threads(cpu)); 507af81cf32SBharata B Rao sPAPRDRConnector *drc; 508af81cf32SBharata B Rao int drc_index; 509c64abd1fSSam Bobroff uint32_t radix_AP_encodings[PPC_PAGE_SIZES_MAX_SZ]; 510c64abd1fSSam Bobroff int i; 511af81cf32SBharata B Rao 512fbf55397SDavid Gibson drc = spapr_drc_by_id(TYPE_SPAPR_DRC_CPU, index); 513af81cf32SBharata B Rao if (drc) { 5140b55aa91SDavid Gibson drc_index = spapr_drc_index(drc); 515af81cf32SBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,my-drc-index", drc_index))); 516af81cf32SBharata B Rao } 5170da6f3feSBharata B Rao 5180da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "reg", index))); 5190da6f3feSBharata B Rao _FDT((fdt_setprop_string(fdt, offset, "device_type", "cpu"))); 5200da6f3feSBharata B Rao 5210da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "cpu-version", env->spr[SPR_PVR]))); 5220da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "d-cache-block-size", 5230da6f3feSBharata B Rao env->dcache_line_size))); 5240da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "d-cache-line-size", 5250da6f3feSBharata B Rao env->dcache_line_size))); 5260da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "i-cache-block-size", 5270da6f3feSBharata B Rao env->icache_line_size))); 5280da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "i-cache-line-size", 5290da6f3feSBharata B Rao env->icache_line_size))); 5300da6f3feSBharata B Rao 5310da6f3feSBharata B Rao if (pcc->l1_dcache_size) { 5320da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "d-cache-size", 5330da6f3feSBharata B Rao pcc->l1_dcache_size))); 5340da6f3feSBharata B Rao } else { 5353dc6f869SAlistair Francis warn_report("Unknown L1 dcache size for cpu"); 5360da6f3feSBharata B Rao } 5370da6f3feSBharata B Rao if (pcc->l1_icache_size) { 5380da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "i-cache-size", 5390da6f3feSBharata B Rao pcc->l1_icache_size))); 5400da6f3feSBharata B Rao } else { 5413dc6f869SAlistair Francis warn_report("Unknown L1 icache size for cpu"); 5420da6f3feSBharata B Rao } 5430da6f3feSBharata B Rao 5440da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "timebase-frequency", tbfreq))); 5450da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "clock-frequency", cpufreq))); 546fd5da5c4SThomas Huth _FDT((fdt_setprop_cell(fdt, offset, "slb-size", env->slb_nr))); 5470da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,slb-size", env->slb_nr))); 5480da6f3feSBharata B Rao _FDT((fdt_setprop_string(fdt, offset, "status", "okay"))); 5490da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "64-bit", NULL, 0))); 5500da6f3feSBharata B Rao 5510da6f3feSBharata B Rao if (env->spr_cb[SPR_PURR].oea_read) { 5520da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,purr", NULL, 0))); 5530da6f3feSBharata B Rao } 5540da6f3feSBharata B Rao 5550da6f3feSBharata B Rao if (env->mmu_model & POWERPC_MMU_1TSEG) { 5560da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,processor-segment-sizes", 5570da6f3feSBharata B Rao segs, sizeof(segs)))); 5580da6f3feSBharata B Rao } 5590da6f3feSBharata B Rao 5600da6f3feSBharata B Rao /* Advertise VMX/VSX (vector extensions) if available 5610da6f3feSBharata B Rao * 0 / no property == no vector extensions 5620da6f3feSBharata B Rao * 1 == VMX / Altivec available 5630da6f3feSBharata B Rao * 2 == VSX available */ 5640da6f3feSBharata B Rao if (env->insns_flags & PPC_ALTIVEC) { 5650da6f3feSBharata B Rao uint32_t vmx = (env->insns_flags2 & PPC2_VSX) ? 2 : 1; 5660da6f3feSBharata B Rao 5670da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,vmx", vmx))); 5680da6f3feSBharata B Rao } 5690da6f3feSBharata B Rao 5700da6f3feSBharata B Rao /* Advertise DFP (Decimal Floating Point) if available 5710da6f3feSBharata B Rao * 0 / no property == no DFP 5720da6f3feSBharata B Rao * 1 == DFP available */ 5730da6f3feSBharata B Rao if (env->insns_flags2 & PPC2_DFP) { 5740da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,dfp", 1))); 5750da6f3feSBharata B Rao } 5760da6f3feSBharata B Rao 5773654fa95SCédric Le Goater page_sizes_prop_size = ppc_create_page_sizes_prop(env, page_sizes_prop, 5780da6f3feSBharata B Rao sizeof(page_sizes_prop)); 5790da6f3feSBharata B Rao if (page_sizes_prop_size) { 5800da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,segment-page-sizes", 5810da6f3feSBharata B Rao page_sizes_prop, page_sizes_prop_size))); 5820da6f3feSBharata B Rao } 5830da6f3feSBharata B Rao 584e957f6a9SSam Bobroff spapr_populate_pa_features(env, fdt, offset, false); 58590da0d5aSBenjamin Herrenschmidt 5860da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,chip-id", 58722419c2aSDavid Gibson cs->cpu_index / vcpus_per_socket))); 5880da6f3feSBharata B Rao 5890da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,pft-size", 5900da6f3feSBharata B Rao pft_size_prop, sizeof(pft_size_prop)))); 5910da6f3feSBharata B Rao 59299861ecbSIgor Mammedov if (nb_numa_nodes > 1) { 59399861ecbSIgor Mammedov _FDT(spapr_fixup_cpu_numa_dt(fdt, offset, cpu)); 59499861ecbSIgor Mammedov } 5950da6f3feSBharata B Rao 59612dbeb16SDavid Gibson _FDT(spapr_fixup_cpu_smt_dt(fdt, offset, cpu, compat_smt)); 597c64abd1fSSam Bobroff 598c64abd1fSSam Bobroff if (pcc->radix_page_info) { 599c64abd1fSSam Bobroff for (i = 0; i < pcc->radix_page_info->count; i++) { 600c64abd1fSSam Bobroff radix_AP_encodings[i] = 601c64abd1fSSam Bobroff cpu_to_be32(pcc->radix_page_info->entries[i]); 602c64abd1fSSam Bobroff } 603c64abd1fSSam Bobroff _FDT((fdt_setprop(fdt, offset, "ibm,processor-radix-AP-encodings", 604c64abd1fSSam Bobroff radix_AP_encodings, 605c64abd1fSSam Bobroff pcc->radix_page_info->count * 606c64abd1fSSam Bobroff sizeof(radix_AP_encodings[0])))); 607c64abd1fSSam Bobroff } 6080da6f3feSBharata B Rao } 6090da6f3feSBharata B Rao 6100da6f3feSBharata B Rao static void spapr_populate_cpus_dt_node(void *fdt, sPAPRMachineState *spapr) 6110da6f3feSBharata B Rao { 6120da6f3feSBharata B Rao CPUState *cs; 6130da6f3feSBharata B Rao int cpus_offset; 6140da6f3feSBharata B Rao char *nodename; 6150da6f3feSBharata B Rao int smt = kvmppc_smt_threads(); 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); 6290da6f3feSBharata B Rao int index = ppc_get_vcpu_dt_id(cpu); 6300da6f3feSBharata B Rao DeviceClass *dc = DEVICE_GET_CLASS(cs); 6310da6f3feSBharata B Rao int offset; 6320da6f3feSBharata B Rao 6330da6f3feSBharata B Rao if ((index % smt) != 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 64603d196b7SBharata B Rao /* 64703d196b7SBharata B Rao * Adds ibm,dynamic-reconfiguration-memory node. 64803d196b7SBharata B Rao * Refer to docs/specs/ppc-spapr-hotplug.txt for the documentation 64903d196b7SBharata B Rao * of this device tree node. 65003d196b7SBharata B Rao */ 65103d196b7SBharata B Rao static int spapr_populate_drconf_memory(sPAPRMachineState *spapr, void *fdt) 65203d196b7SBharata B Rao { 65303d196b7SBharata B Rao MachineState *machine = MACHINE(spapr); 65403d196b7SBharata B Rao int ret, i, offset; 65503d196b7SBharata B Rao uint64_t lmb_size = SPAPR_MEMORY_BLOCK_SIZE; 65603d196b7SBharata B Rao uint32_t prop_lmb_size[] = {0, cpu_to_be32(lmb_size)}; 657d0e5a8f2SBharata B Rao uint32_t hotplug_lmb_start = spapr->hotplug_memory.base / lmb_size; 658d0e5a8f2SBharata B Rao uint32_t nr_lmbs = (spapr->hotplug_memory.base + 659d0e5a8f2SBharata B Rao memory_region_size(&spapr->hotplug_memory.mr)) / 660d0e5a8f2SBharata B Rao lmb_size; 66103d196b7SBharata B Rao uint32_t *int_buf, *cur_index, buf_len; 6626663864eSBharata B Rao int nr_nodes = nb_numa_nodes ? nb_numa_nodes : 1; 66303d196b7SBharata B Rao 664ef001f06SThomas Huth /* 665d0e5a8f2SBharata B Rao * Don't create the node if there is no hotpluggable memory 66616c25aefSBharata B Rao */ 667d0e5a8f2SBharata B Rao if (machine->ram_size == machine->maxram_size) { 66816c25aefSBharata B Rao return 0; 66916c25aefSBharata B Rao } 67016c25aefSBharata B Rao 67116c25aefSBharata B Rao /* 672ef001f06SThomas Huth * Allocate enough buffer size to fit in ibm,dynamic-memory 673ef001f06SThomas Huth * or ibm,associativity-lookup-arrays 674ef001f06SThomas Huth */ 675ef001f06SThomas Huth buf_len = MAX(nr_lmbs * SPAPR_DR_LMB_LIST_ENTRY_SIZE + 1, nr_nodes * 4 + 2) 676ef001f06SThomas Huth * sizeof(uint32_t); 67703d196b7SBharata B Rao cur_index = int_buf = g_malloc0(buf_len); 67803d196b7SBharata B Rao 67903d196b7SBharata B Rao offset = fdt_add_subnode(fdt, 0, "ibm,dynamic-reconfiguration-memory"); 68003d196b7SBharata B Rao 68103d196b7SBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,lmb-size", prop_lmb_size, 68203d196b7SBharata B Rao sizeof(prop_lmb_size)); 68303d196b7SBharata B Rao if (ret < 0) { 68403d196b7SBharata B Rao goto out; 68503d196b7SBharata B Rao } 68603d196b7SBharata B Rao 68703d196b7SBharata B Rao ret = fdt_setprop_cell(fdt, offset, "ibm,memory-flags-mask", 0xff); 68803d196b7SBharata B Rao if (ret < 0) { 68903d196b7SBharata B Rao goto out; 69003d196b7SBharata B Rao } 69103d196b7SBharata B Rao 69203d196b7SBharata B Rao ret = fdt_setprop_cell(fdt, offset, "ibm,memory-preservation-time", 0x0); 69303d196b7SBharata B Rao if (ret < 0) { 69403d196b7SBharata B Rao goto out; 69503d196b7SBharata B Rao } 69603d196b7SBharata B Rao 69703d196b7SBharata B Rao /* ibm,dynamic-memory */ 69803d196b7SBharata B Rao int_buf[0] = cpu_to_be32(nr_lmbs); 69903d196b7SBharata B Rao cur_index++; 70003d196b7SBharata B Rao for (i = 0; i < nr_lmbs; i++) { 701d0e5a8f2SBharata B Rao uint64_t addr = i * lmb_size; 70203d196b7SBharata B Rao uint32_t *dynamic_memory = cur_index; 70303d196b7SBharata B Rao 704d0e5a8f2SBharata B Rao if (i >= hotplug_lmb_start) { 705d0e5a8f2SBharata B Rao sPAPRDRConnector *drc; 706d0e5a8f2SBharata B Rao 707fbf55397SDavid Gibson drc = spapr_drc_by_id(TYPE_SPAPR_DRC_LMB, i); 70803d196b7SBharata B Rao g_assert(drc); 70903d196b7SBharata B Rao 71003d196b7SBharata B Rao dynamic_memory[0] = cpu_to_be32(addr >> 32); 71103d196b7SBharata B Rao dynamic_memory[1] = cpu_to_be32(addr & 0xffffffff); 7120b55aa91SDavid Gibson dynamic_memory[2] = cpu_to_be32(spapr_drc_index(drc)); 71303d196b7SBharata B Rao dynamic_memory[3] = cpu_to_be32(0); /* reserved */ 71403d196b7SBharata B Rao dynamic_memory[4] = cpu_to_be32(numa_get_node(addr, NULL)); 715d0e5a8f2SBharata B Rao if (memory_region_present(get_system_memory(), addr)) { 71603d196b7SBharata B Rao dynamic_memory[5] = cpu_to_be32(SPAPR_LMB_FLAGS_ASSIGNED); 71703d196b7SBharata B Rao } else { 71803d196b7SBharata B Rao dynamic_memory[5] = cpu_to_be32(0); 71903d196b7SBharata B Rao } 720d0e5a8f2SBharata B Rao } else { 721d0e5a8f2SBharata B Rao /* 722d0e5a8f2SBharata B Rao * LMB information for RMA, boot time RAM and gap b/n RAM and 723d0e5a8f2SBharata B Rao * hotplug memory region -- all these are marked as reserved 724d0e5a8f2SBharata B Rao * and as having no valid DRC. 725d0e5a8f2SBharata B Rao */ 726d0e5a8f2SBharata B Rao dynamic_memory[0] = cpu_to_be32(addr >> 32); 727d0e5a8f2SBharata B Rao dynamic_memory[1] = cpu_to_be32(addr & 0xffffffff); 728d0e5a8f2SBharata B Rao dynamic_memory[2] = cpu_to_be32(0); 729d0e5a8f2SBharata B Rao dynamic_memory[3] = cpu_to_be32(0); /* reserved */ 730d0e5a8f2SBharata B Rao dynamic_memory[4] = cpu_to_be32(-1); 731d0e5a8f2SBharata B Rao dynamic_memory[5] = cpu_to_be32(SPAPR_LMB_FLAGS_RESERVED | 732d0e5a8f2SBharata B Rao SPAPR_LMB_FLAGS_DRC_INVALID); 733d0e5a8f2SBharata B Rao } 73403d196b7SBharata B Rao 73503d196b7SBharata B Rao cur_index += SPAPR_DR_LMB_LIST_ENTRY_SIZE; 73603d196b7SBharata B Rao } 73703d196b7SBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,dynamic-memory", int_buf, buf_len); 73803d196b7SBharata B Rao if (ret < 0) { 73903d196b7SBharata B Rao goto out; 74003d196b7SBharata B Rao } 74103d196b7SBharata B Rao 74203d196b7SBharata B Rao /* ibm,associativity-lookup-arrays */ 74303d196b7SBharata B Rao cur_index = int_buf; 7446663864eSBharata B Rao int_buf[0] = cpu_to_be32(nr_nodes); 74503d196b7SBharata B Rao int_buf[1] = cpu_to_be32(4); /* Number of entries per associativity list */ 74603d196b7SBharata B Rao cur_index += 2; 7476663864eSBharata B Rao for (i = 0; i < nr_nodes; i++) { 74803d196b7SBharata B Rao uint32_t associativity[] = { 74903d196b7SBharata B Rao cpu_to_be32(0x0), 75003d196b7SBharata B Rao cpu_to_be32(0x0), 75103d196b7SBharata B Rao cpu_to_be32(0x0), 75203d196b7SBharata B Rao cpu_to_be32(i) 75303d196b7SBharata B Rao }; 75403d196b7SBharata B Rao memcpy(cur_index, associativity, sizeof(associativity)); 75503d196b7SBharata B Rao cur_index += 4; 75603d196b7SBharata B Rao } 75703d196b7SBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,associativity-lookup-arrays", int_buf, 75803d196b7SBharata B Rao (cur_index - int_buf) * sizeof(uint32_t)); 75903d196b7SBharata B Rao out: 76003d196b7SBharata B Rao g_free(int_buf); 76103d196b7SBharata B Rao return ret; 76203d196b7SBharata B Rao } 76303d196b7SBharata B Rao 7646787d27bSMichael Roth static int spapr_dt_cas_updates(sPAPRMachineState *spapr, void *fdt, 7656787d27bSMichael Roth sPAPROptionVector *ov5_updates) 7666787d27bSMichael Roth { 7676787d27bSMichael Roth sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(spapr); 768417ece33SMichael Roth int ret = 0, offset; 7696787d27bSMichael Roth 7706787d27bSMichael Roth /* Generate ibm,dynamic-reconfiguration-memory node if required */ 7716787d27bSMichael Roth if (spapr_ovec_test(ov5_updates, OV5_DRCONF_MEMORY)) { 7726787d27bSMichael Roth g_assert(smc->dr_lmb_enabled); 7736787d27bSMichael Roth ret = spapr_populate_drconf_memory(spapr, fdt); 774417ece33SMichael Roth if (ret) { 775417ece33SMichael Roth goto out; 776417ece33SMichael Roth } 7776787d27bSMichael Roth } 7786787d27bSMichael Roth 779417ece33SMichael Roth offset = fdt_path_offset(fdt, "/chosen"); 780417ece33SMichael Roth if (offset < 0) { 781417ece33SMichael Roth offset = fdt_add_subnode(fdt, 0, "chosen"); 782417ece33SMichael Roth if (offset < 0) { 783417ece33SMichael Roth return offset; 784417ece33SMichael Roth } 785417ece33SMichael Roth } 786417ece33SMichael Roth ret = spapr_ovec_populate_dt(fdt, offset, spapr->ov5_cas, 787417ece33SMichael Roth "ibm,architecture-vec-5"); 788417ece33SMichael Roth 789417ece33SMichael Roth out: 7906787d27bSMichael Roth return ret; 7916787d27bSMichael Roth } 7926787d27bSMichael Roth 793*10f12e64SDaniel Henrique Barboza static bool spapr_hotplugged_dev_before_cas(void) 794*10f12e64SDaniel Henrique Barboza { 795*10f12e64SDaniel Henrique Barboza Object *drc_container, *obj; 796*10f12e64SDaniel Henrique Barboza ObjectProperty *prop; 797*10f12e64SDaniel Henrique Barboza ObjectPropertyIterator iter; 798*10f12e64SDaniel Henrique Barboza 799*10f12e64SDaniel Henrique Barboza drc_container = container_get(object_get_root(), "/dr-connector"); 800*10f12e64SDaniel Henrique Barboza object_property_iter_init(&iter, drc_container); 801*10f12e64SDaniel Henrique Barboza while ((prop = object_property_iter_next(&iter))) { 802*10f12e64SDaniel Henrique Barboza if (!strstart(prop->type, "link<", NULL)) { 803*10f12e64SDaniel Henrique Barboza continue; 804*10f12e64SDaniel Henrique Barboza } 805*10f12e64SDaniel Henrique Barboza obj = object_property_get_link(drc_container, prop->name, NULL); 806*10f12e64SDaniel Henrique Barboza if (spapr_drc_needed(obj)) { 807*10f12e64SDaniel Henrique Barboza return true; 808*10f12e64SDaniel Henrique Barboza } 809*10f12e64SDaniel Henrique Barboza } 810*10f12e64SDaniel Henrique Barboza return false; 811*10f12e64SDaniel Henrique Barboza } 812*10f12e64SDaniel Henrique Barboza 81303d196b7SBharata B Rao int spapr_h_cas_compose_response(sPAPRMachineState *spapr, 81403d196b7SBharata B Rao target_ulong addr, target_ulong size, 8156787d27bSMichael Roth sPAPROptionVector *ov5_updates) 81603d196b7SBharata B Rao { 81703d196b7SBharata B Rao void *fdt, *fdt_skel; 81803d196b7SBharata B Rao sPAPRDeviceTreeUpdateHeader hdr = { .version_id = 1 }; 81903d196b7SBharata B Rao 820*10f12e64SDaniel Henrique Barboza if (spapr_hotplugged_dev_before_cas()) { 821*10f12e64SDaniel Henrique Barboza return 1; 822*10f12e64SDaniel Henrique Barboza } 823*10f12e64SDaniel Henrique Barboza 82403d196b7SBharata B Rao size -= sizeof(hdr); 82503d196b7SBharata B Rao 826*10f12e64SDaniel Henrique Barboza /* Create skeleton */ 82703d196b7SBharata B Rao fdt_skel = g_malloc0(size); 82803d196b7SBharata B Rao _FDT((fdt_create(fdt_skel, size))); 82903d196b7SBharata B Rao _FDT((fdt_begin_node(fdt_skel, ""))); 83003d196b7SBharata B Rao _FDT((fdt_end_node(fdt_skel))); 83103d196b7SBharata B Rao _FDT((fdt_finish(fdt_skel))); 83203d196b7SBharata B Rao fdt = g_malloc0(size); 83303d196b7SBharata B Rao _FDT((fdt_open_into(fdt_skel, fdt, size))); 83403d196b7SBharata B Rao g_free(fdt_skel); 83503d196b7SBharata B Rao 83603d196b7SBharata B Rao /* Fixup cpu nodes */ 83703d196b7SBharata B Rao _FDT((spapr_fixup_cpu_dt(fdt, spapr))); 83803d196b7SBharata B Rao 8396787d27bSMichael Roth if (spapr_dt_cas_updates(spapr, fdt, ov5_updates)) { 8406787d27bSMichael Roth return -1; 84103d196b7SBharata B Rao } 84203d196b7SBharata B Rao 84303d196b7SBharata B Rao /* Pack resulting tree */ 84403d196b7SBharata B Rao _FDT((fdt_pack(fdt))); 84503d196b7SBharata B Rao 84603d196b7SBharata B Rao if (fdt_totalsize(fdt) + sizeof(hdr) > size) { 84703d196b7SBharata B Rao trace_spapr_cas_failed(size); 84803d196b7SBharata B Rao return -1; 84903d196b7SBharata B Rao } 85003d196b7SBharata B Rao 85103d196b7SBharata B Rao cpu_physical_memory_write(addr, &hdr, sizeof(hdr)); 85203d196b7SBharata B Rao cpu_physical_memory_write(addr + sizeof(hdr), fdt, fdt_totalsize(fdt)); 85303d196b7SBharata B Rao trace_spapr_cas_continue(fdt_totalsize(fdt) + sizeof(hdr)); 85403d196b7SBharata B Rao g_free(fdt); 85503d196b7SBharata B Rao 85603d196b7SBharata B Rao return 0; 85703d196b7SBharata B Rao } 85803d196b7SBharata B Rao 8593f5dabceSDavid Gibson static void spapr_dt_rtas(sPAPRMachineState *spapr, void *fdt) 8603f5dabceSDavid Gibson { 8613f5dabceSDavid Gibson int rtas; 8623f5dabceSDavid Gibson GString *hypertas = g_string_sized_new(256); 8633f5dabceSDavid Gibson GString *qemu_hypertas = g_string_sized_new(256); 8643f5dabceSDavid Gibson uint32_t refpoints[] = { cpu_to_be32(0x4), cpu_to_be32(0x4) }; 8653f5dabceSDavid Gibson uint64_t max_hotplug_addr = spapr->hotplug_memory.base + 8663f5dabceSDavid Gibson memory_region_size(&spapr->hotplug_memory.mr); 8673f5dabceSDavid Gibson uint32_t lrdr_capacity[] = { 8683f5dabceSDavid Gibson cpu_to_be32(max_hotplug_addr >> 32), 8693f5dabceSDavid Gibson cpu_to_be32(max_hotplug_addr & 0xffffffff), 8703f5dabceSDavid Gibson 0, cpu_to_be32(SPAPR_MEMORY_BLOCK_SIZE), 8713f5dabceSDavid Gibson cpu_to_be32(max_cpus / smp_threads), 8723f5dabceSDavid Gibson }; 8733f5dabceSDavid Gibson 8743f5dabceSDavid Gibson _FDT(rtas = fdt_add_subnode(fdt, 0, "rtas")); 8753f5dabceSDavid Gibson 8763f5dabceSDavid Gibson /* hypertas */ 8773f5dabceSDavid Gibson add_str(hypertas, "hcall-pft"); 8783f5dabceSDavid Gibson add_str(hypertas, "hcall-term"); 8793f5dabceSDavid Gibson add_str(hypertas, "hcall-dabr"); 8803f5dabceSDavid Gibson add_str(hypertas, "hcall-interrupt"); 8813f5dabceSDavid Gibson add_str(hypertas, "hcall-tce"); 8823f5dabceSDavid Gibson add_str(hypertas, "hcall-vio"); 8833f5dabceSDavid Gibson add_str(hypertas, "hcall-splpar"); 8843f5dabceSDavid Gibson add_str(hypertas, "hcall-bulk"); 8853f5dabceSDavid Gibson add_str(hypertas, "hcall-set-mode"); 8863f5dabceSDavid Gibson add_str(hypertas, "hcall-sprg0"); 8873f5dabceSDavid Gibson add_str(hypertas, "hcall-copy"); 8883f5dabceSDavid Gibson add_str(hypertas, "hcall-debug"); 8893f5dabceSDavid Gibson add_str(qemu_hypertas, "hcall-memop1"); 8903f5dabceSDavid Gibson 8913f5dabceSDavid Gibson if (!kvm_enabled() || kvmppc_spapr_use_multitce()) { 8923f5dabceSDavid Gibson add_str(hypertas, "hcall-multi-tce"); 8933f5dabceSDavid Gibson } 89430f4b05bSDavid Gibson 89530f4b05bSDavid Gibson if (spapr->resize_hpt != SPAPR_RESIZE_HPT_DISABLED) { 89630f4b05bSDavid Gibson add_str(hypertas, "hcall-hpt-resize"); 89730f4b05bSDavid Gibson } 89830f4b05bSDavid Gibson 8993f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,hypertas-functions", 9003f5dabceSDavid Gibson hypertas->str, hypertas->len)); 9013f5dabceSDavid Gibson g_string_free(hypertas, TRUE); 9023f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "qemu,hypertas-functions", 9033f5dabceSDavid Gibson qemu_hypertas->str, qemu_hypertas->len)); 9043f5dabceSDavid Gibson g_string_free(qemu_hypertas, TRUE); 9053f5dabceSDavid Gibson 9063f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,associativity-reference-points", 9073f5dabceSDavid Gibson refpoints, sizeof(refpoints))); 9083f5dabceSDavid Gibson 9093f5dabceSDavid Gibson _FDT(fdt_setprop_cell(fdt, rtas, "rtas-error-log-max", 9103f5dabceSDavid Gibson RTAS_ERROR_LOG_MAX)); 9113f5dabceSDavid Gibson _FDT(fdt_setprop_cell(fdt, rtas, "rtas-event-scan-rate", 9123f5dabceSDavid Gibson RTAS_EVENT_SCAN_RATE)); 9133f5dabceSDavid Gibson 9143f5dabceSDavid Gibson if (msi_nonbroken) { 9153f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,change-msix-capable", NULL, 0)); 9163f5dabceSDavid Gibson } 9173f5dabceSDavid Gibson 9183f5dabceSDavid Gibson /* 9193f5dabceSDavid Gibson * According to PAPR, rtas ibm,os-term does not guarantee a return 9203f5dabceSDavid Gibson * back to the guest cpu. 9213f5dabceSDavid Gibson * 9223f5dabceSDavid Gibson * While an additional ibm,extended-os-term property indicates 9233f5dabceSDavid Gibson * that rtas call return will always occur. Set this property. 9243f5dabceSDavid Gibson */ 9253f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,extended-os-term", NULL, 0)); 9263f5dabceSDavid Gibson 9273f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,lrdr-capacity", 9283f5dabceSDavid Gibson lrdr_capacity, sizeof(lrdr_capacity))); 9293f5dabceSDavid Gibson 9303f5dabceSDavid Gibson spapr_dt_rtas_tokens(fdt, rtas); 9313f5dabceSDavid Gibson } 9323f5dabceSDavid Gibson 9339fb4541fSSam Bobroff /* Prepare ibm,arch-vec-5-platform-support, which indicates the MMU features 9349fb4541fSSam Bobroff * that the guest may request and thus the valid values for bytes 24..26 of 9359fb4541fSSam Bobroff * option vector 5: */ 9369fb4541fSSam Bobroff static void spapr_dt_ov5_platform_support(void *fdt, int chosen) 9379fb4541fSSam Bobroff { 938545d6e2bSSuraj Jitindar Singh PowerPCCPU *first_ppc_cpu = POWERPC_CPU(first_cpu); 939545d6e2bSSuraj Jitindar Singh 940f2b14e3aSCédric Le Goater char val[2 * 4] = { 941f2b14e3aSCédric Le Goater 23, 0x00, /* Xive mode: 0 = legacy (as in ISA 2.7), 1 = Exploitation */ 9429fb4541fSSam Bobroff 24, 0x00, /* Hash/Radix, filled in below. */ 9439fb4541fSSam Bobroff 25, 0x00, /* Hash options: Segment Tables == no, GTSE == no. */ 9449fb4541fSSam Bobroff 26, 0x40, /* Radix options: GTSE == yes. */ 9459fb4541fSSam Bobroff }; 9469fb4541fSSam Bobroff 9479fb4541fSSam Bobroff if (kvm_enabled()) { 9489fb4541fSSam Bobroff if (kvmppc_has_cap_mmu_radix() && kvmppc_has_cap_mmu_hash_v3()) { 949f2b14e3aSCédric Le Goater val[3] = 0x80; /* OV5_MMU_BOTH */ 9509fb4541fSSam Bobroff } else if (kvmppc_has_cap_mmu_radix()) { 951f2b14e3aSCédric Le Goater val[3] = 0x40; /* OV5_MMU_RADIX_300 */ 9529fb4541fSSam Bobroff } else { 953f2b14e3aSCédric Le Goater val[3] = 0x00; /* Hash */ 9549fb4541fSSam Bobroff } 9559fb4541fSSam Bobroff } else { 956545d6e2bSSuraj Jitindar Singh if (first_ppc_cpu->env.mmu_model & POWERPC_MMU_V3) { 957545d6e2bSSuraj Jitindar Singh /* V3 MMU supports both hash and radix (with dynamic switching) */ 958f2b14e3aSCédric Le Goater val[3] = 0xC0; 959545d6e2bSSuraj Jitindar Singh } else { 960545d6e2bSSuraj Jitindar Singh /* Otherwise we can only do hash */ 961f2b14e3aSCédric Le Goater val[3] = 0x00; 9629fb4541fSSam Bobroff } 963545d6e2bSSuraj Jitindar Singh } 9649fb4541fSSam Bobroff _FDT(fdt_setprop(fdt, chosen, "ibm,arch-vec-5-platform-support", 9659fb4541fSSam Bobroff val, sizeof(val))); 9669fb4541fSSam Bobroff } 9679fb4541fSSam Bobroff 9687c866c6aSDavid Gibson static void spapr_dt_chosen(sPAPRMachineState *spapr, void *fdt) 9697c866c6aSDavid Gibson { 9707c866c6aSDavid Gibson MachineState *machine = MACHINE(spapr); 9717c866c6aSDavid Gibson int chosen; 9727c866c6aSDavid Gibson const char *boot_device = machine->boot_order; 9737c866c6aSDavid Gibson char *stdout_path = spapr_vio_stdout_path(spapr->vio_bus); 9747c866c6aSDavid Gibson size_t cb = 0; 9757c866c6aSDavid Gibson char *bootlist = get_boot_devices_list(&cb, true); 9767c866c6aSDavid Gibson 9777c866c6aSDavid Gibson _FDT(chosen = fdt_add_subnode(fdt, 0, "chosen")); 9787c866c6aSDavid Gibson 9797c866c6aSDavid Gibson _FDT(fdt_setprop_string(fdt, chosen, "bootargs", machine->kernel_cmdline)); 9807c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "linux,initrd-start", 9817c866c6aSDavid Gibson spapr->initrd_base)); 9827c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "linux,initrd-end", 9837c866c6aSDavid Gibson spapr->initrd_base + spapr->initrd_size)); 9847c866c6aSDavid Gibson 9857c866c6aSDavid Gibson if (spapr->kernel_size) { 9867c866c6aSDavid Gibson uint64_t kprop[2] = { cpu_to_be64(KERNEL_LOAD_ADDR), 9877c866c6aSDavid Gibson cpu_to_be64(spapr->kernel_size) }; 9887c866c6aSDavid Gibson 9897c866c6aSDavid Gibson _FDT(fdt_setprop(fdt, chosen, "qemu,boot-kernel", 9907c866c6aSDavid Gibson &kprop, sizeof(kprop))); 9917c866c6aSDavid Gibson if (spapr->kernel_le) { 9927c866c6aSDavid Gibson _FDT(fdt_setprop(fdt, chosen, "qemu,boot-kernel-le", NULL, 0)); 9937c866c6aSDavid Gibson } 9947c866c6aSDavid Gibson } 9957c866c6aSDavid Gibson if (boot_menu) { 9967c866c6aSDavid Gibson _FDT((fdt_setprop_cell(fdt, chosen, "qemu,boot-menu", boot_menu))); 9977c866c6aSDavid Gibson } 9987c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "qemu,graphic-width", graphic_width)); 9997c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "qemu,graphic-height", graphic_height)); 10007c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "qemu,graphic-depth", graphic_depth)); 10017c866c6aSDavid Gibson 10027c866c6aSDavid Gibson if (cb && bootlist) { 10037c866c6aSDavid Gibson int i; 10047c866c6aSDavid Gibson 10057c866c6aSDavid Gibson for (i = 0; i < cb; i++) { 10067c866c6aSDavid Gibson if (bootlist[i] == '\n') { 10077c866c6aSDavid Gibson bootlist[i] = ' '; 10087c866c6aSDavid Gibson } 10097c866c6aSDavid Gibson } 10107c866c6aSDavid Gibson _FDT(fdt_setprop_string(fdt, chosen, "qemu,boot-list", bootlist)); 10117c866c6aSDavid Gibson } 10127c866c6aSDavid Gibson 10137c866c6aSDavid Gibson if (boot_device && strlen(boot_device)) { 10147c866c6aSDavid Gibson _FDT(fdt_setprop_string(fdt, chosen, "qemu,boot-device", boot_device)); 10157c866c6aSDavid Gibson } 10167c866c6aSDavid Gibson 10177c866c6aSDavid Gibson if (!spapr->has_graphics && stdout_path) { 10187c866c6aSDavid Gibson _FDT(fdt_setprop_string(fdt, chosen, "linux,stdout-path", stdout_path)); 10197c866c6aSDavid Gibson } 10207c866c6aSDavid Gibson 10219fb4541fSSam Bobroff spapr_dt_ov5_platform_support(fdt, chosen); 10229fb4541fSSam Bobroff 10237c866c6aSDavid Gibson g_free(stdout_path); 10247c866c6aSDavid Gibson g_free(bootlist); 10257c866c6aSDavid Gibson } 10267c866c6aSDavid Gibson 1027fca5f2dcSDavid Gibson static void spapr_dt_hypervisor(sPAPRMachineState *spapr, void *fdt) 1028fca5f2dcSDavid Gibson { 1029fca5f2dcSDavid Gibson /* The /hypervisor node isn't in PAPR - this is a hack to allow PR 1030fca5f2dcSDavid Gibson * KVM to work under pHyp with some guest co-operation */ 1031fca5f2dcSDavid Gibson int hypervisor; 1032fca5f2dcSDavid Gibson uint8_t hypercall[16]; 1033fca5f2dcSDavid Gibson 1034fca5f2dcSDavid Gibson _FDT(hypervisor = fdt_add_subnode(fdt, 0, "hypervisor")); 1035fca5f2dcSDavid Gibson /* indicate KVM hypercall interface */ 1036fca5f2dcSDavid Gibson _FDT(fdt_setprop_string(fdt, hypervisor, "compatible", "linux,kvm")); 1037fca5f2dcSDavid Gibson if (kvmppc_has_cap_fixup_hcalls()) { 1038fca5f2dcSDavid Gibson /* 1039fca5f2dcSDavid Gibson * Older KVM versions with older guest kernels were broken 1040fca5f2dcSDavid Gibson * with the magic page, don't allow the guest to map it. 1041fca5f2dcSDavid Gibson */ 1042fca5f2dcSDavid Gibson if (!kvmppc_get_hypercall(first_cpu->env_ptr, hypercall, 1043fca5f2dcSDavid Gibson sizeof(hypercall))) { 1044fca5f2dcSDavid Gibson _FDT(fdt_setprop(fdt, hypervisor, "hcall-instructions", 1045fca5f2dcSDavid Gibson hypercall, sizeof(hypercall))); 1046fca5f2dcSDavid Gibson } 1047fca5f2dcSDavid Gibson } 1048fca5f2dcSDavid Gibson } 1049fca5f2dcSDavid Gibson 1050997b6cfcSDavid Gibson static void *spapr_build_fdt(sPAPRMachineState *spapr, 105153018216SPaolo Bonzini hwaddr rtas_addr, 105253018216SPaolo Bonzini hwaddr rtas_size) 105353018216SPaolo Bonzini { 10545b2128d2SAlexander Graf MachineState *machine = MACHINE(qdev_get_machine()); 10553c0c47e3SDavid Gibson MachineClass *mc = MACHINE_GET_CLASS(machine); 1056c20d332aSBharata B Rao sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(machine); 10577c866c6aSDavid Gibson int ret; 105853018216SPaolo Bonzini void *fdt; 105953018216SPaolo Bonzini sPAPRPHBState *phb; 1060398a0bd5SDavid Gibson char *buf; 106153018216SPaolo Bonzini 1062398a0bd5SDavid Gibson fdt = g_malloc0(FDT_MAX_SIZE); 1063398a0bd5SDavid Gibson _FDT((fdt_create_empty_tree(fdt, FDT_MAX_SIZE))); 106453018216SPaolo Bonzini 1065398a0bd5SDavid Gibson /* Root node */ 1066398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "device_type", "chrp")); 1067398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "model", "IBM pSeries (emulated by qemu)")); 1068398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "compatible", "qemu,pseries")); 1069398a0bd5SDavid Gibson 1070398a0bd5SDavid Gibson /* 1071398a0bd5SDavid Gibson * Add info to guest to indentify which host is it being run on 1072398a0bd5SDavid Gibson * and what is the uuid of the guest 1073398a0bd5SDavid Gibson */ 1074398a0bd5SDavid Gibson if (kvmppc_get_host_model(&buf)) { 1075398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "host-model", buf)); 1076398a0bd5SDavid Gibson g_free(buf); 1077398a0bd5SDavid Gibson } 1078398a0bd5SDavid Gibson if (kvmppc_get_host_serial(&buf)) { 1079398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "host-serial", buf)); 1080398a0bd5SDavid Gibson g_free(buf); 1081398a0bd5SDavid Gibson } 1082398a0bd5SDavid Gibson 1083398a0bd5SDavid Gibson buf = qemu_uuid_unparse_strdup(&qemu_uuid); 1084398a0bd5SDavid Gibson 1085398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "vm,uuid", buf)); 1086398a0bd5SDavid Gibson if (qemu_uuid_set) { 1087398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "system-id", buf)); 1088398a0bd5SDavid Gibson } 1089398a0bd5SDavid Gibson g_free(buf); 1090398a0bd5SDavid Gibson 1091398a0bd5SDavid Gibson if (qemu_get_vm_name()) { 1092398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "ibm,partition-name", 1093398a0bd5SDavid Gibson qemu_get_vm_name())); 1094398a0bd5SDavid Gibson } 1095398a0bd5SDavid Gibson 1096398a0bd5SDavid Gibson _FDT(fdt_setprop_cell(fdt, 0, "#address-cells", 2)); 1097398a0bd5SDavid Gibson _FDT(fdt_setprop_cell(fdt, 0, "#size-cells", 2)); 109853018216SPaolo Bonzini 1099fc7e0765SDavid Gibson /* /interrupt controller */ 1100fc7e0765SDavid Gibson spapr_dt_xics(xics_max_server_number(), fdt, PHANDLE_XICP); 1101fc7e0765SDavid Gibson 1102e8f986fcSBharata B Rao ret = spapr_populate_memory(spapr, fdt); 1103e8f986fcSBharata B Rao if (ret < 0) { 1104ce9863b7SCédric Le Goater error_report("couldn't setup memory nodes in fdt"); 1105e8f986fcSBharata B Rao exit(1); 110653018216SPaolo Bonzini } 110753018216SPaolo Bonzini 1108bf5a6696SDavid Gibson /* /vdevice */ 1109bf5a6696SDavid Gibson spapr_dt_vdevice(spapr->vio_bus, fdt); 111053018216SPaolo Bonzini 11114d9392beSThomas Huth if (object_resolve_path_type("", TYPE_SPAPR_RNG, NULL)) { 11124d9392beSThomas Huth ret = spapr_rng_populate_dt(fdt); 11134d9392beSThomas Huth if (ret < 0) { 1114ce9863b7SCédric Le Goater error_report("could not set up rng device in the fdt"); 11154d9392beSThomas Huth exit(1); 11164d9392beSThomas Huth } 11174d9392beSThomas Huth } 11184d9392beSThomas Huth 111953018216SPaolo Bonzini QLIST_FOREACH(phb, &spapr->phbs, list) { 112053018216SPaolo Bonzini ret = spapr_populate_pci_dt(phb, PHANDLE_XICP, fdt); 112153018216SPaolo Bonzini if (ret < 0) { 1122da34fed7SThomas Huth error_report("couldn't setup PCI devices in fdt"); 112353018216SPaolo Bonzini exit(1); 112453018216SPaolo Bonzini } 1125da34fed7SThomas Huth } 112653018216SPaolo Bonzini 11270da6f3feSBharata B Rao /* cpus */ 11280da6f3feSBharata B Rao spapr_populate_cpus_dt_node(fdt, spapr); 112953018216SPaolo Bonzini 1130c20d332aSBharata B Rao if (smc->dr_lmb_enabled) { 1131c20d332aSBharata B Rao _FDT(spapr_drc_populate_dt(fdt, 0, NULL, SPAPR_DR_CONNECTOR_TYPE_LMB)); 1132c20d332aSBharata B Rao } 1133c20d332aSBharata B Rao 1134c5514d0eSIgor Mammedov if (mc->has_hotpluggable_cpus) { 1135af81cf32SBharata B Rao int offset = fdt_path_offset(fdt, "/cpus"); 1136af81cf32SBharata B Rao ret = spapr_drc_populate_dt(fdt, offset, NULL, 1137af81cf32SBharata B Rao SPAPR_DR_CONNECTOR_TYPE_CPU); 1138af81cf32SBharata B Rao if (ret < 0) { 1139af81cf32SBharata B Rao error_report("Couldn't set up CPU DR device tree properties"); 1140af81cf32SBharata B Rao exit(1); 1141af81cf32SBharata B Rao } 1142af81cf32SBharata B Rao } 1143af81cf32SBharata B Rao 1144ffb1e275SDavid Gibson /* /event-sources */ 1145ffbb1705SMichael Roth spapr_dt_events(spapr, fdt); 1146ffb1e275SDavid Gibson 11473f5dabceSDavid Gibson /* /rtas */ 11483f5dabceSDavid Gibson spapr_dt_rtas(spapr, fdt); 11493f5dabceSDavid Gibson 11507c866c6aSDavid Gibson /* /chosen */ 11517c866c6aSDavid Gibson spapr_dt_chosen(spapr, fdt); 1152cf6e5223SDavid Gibson 1153fca5f2dcSDavid Gibson /* /hypervisor */ 1154fca5f2dcSDavid Gibson if (kvm_enabled()) { 1155fca5f2dcSDavid Gibson spapr_dt_hypervisor(spapr, fdt); 1156fca5f2dcSDavid Gibson } 1157fca5f2dcSDavid Gibson 1158cf6e5223SDavid Gibson /* Build memory reserve map */ 1159cf6e5223SDavid Gibson if (spapr->kernel_size) { 1160cf6e5223SDavid Gibson _FDT((fdt_add_mem_rsv(fdt, KERNEL_LOAD_ADDR, spapr->kernel_size))); 1161cf6e5223SDavid Gibson } 1162cf6e5223SDavid Gibson if (spapr->initrd_size) { 1163cf6e5223SDavid Gibson _FDT((fdt_add_mem_rsv(fdt, spapr->initrd_base, spapr->initrd_size))); 1164cf6e5223SDavid Gibson } 1165cf6e5223SDavid Gibson 11666787d27bSMichael Roth /* ibm,client-architecture-support updates */ 11676787d27bSMichael Roth ret = spapr_dt_cas_updates(spapr, fdt, spapr->ov5_cas); 11686787d27bSMichael Roth if (ret < 0) { 11696787d27bSMichael Roth error_report("couldn't setup CAS properties fdt"); 11706787d27bSMichael Roth exit(1); 11716787d27bSMichael Roth } 11726787d27bSMichael Roth 1173997b6cfcSDavid Gibson return fdt; 117453018216SPaolo Bonzini } 117553018216SPaolo Bonzini 117653018216SPaolo Bonzini static uint64_t translate_kernel_address(void *opaque, uint64_t addr) 117753018216SPaolo Bonzini { 117853018216SPaolo Bonzini return (addr & 0x0fffffff) + KERNEL_LOAD_ADDR; 117953018216SPaolo Bonzini } 118053018216SPaolo Bonzini 11811d1be34dSDavid Gibson static void emulate_spapr_hypercall(PPCVirtualHypervisor *vhyp, 11821d1be34dSDavid Gibson PowerPCCPU *cpu) 118353018216SPaolo Bonzini { 118453018216SPaolo Bonzini CPUPPCState *env = &cpu->env; 118553018216SPaolo Bonzini 11868d04fb55SJan Kiszka /* The TCG path should also be holding the BQL at this point */ 11878d04fb55SJan Kiszka g_assert(qemu_mutex_iothread_locked()); 11888d04fb55SJan Kiszka 118953018216SPaolo Bonzini if (msr_pr) { 119053018216SPaolo Bonzini hcall_dprintf("Hypercall made with MSR[PR]=1\n"); 119153018216SPaolo Bonzini env->gpr[3] = H_PRIVILEGE; 119253018216SPaolo Bonzini } else { 119353018216SPaolo Bonzini env->gpr[3] = spapr_hypercall(cpu, env->gpr[3], &env->gpr[4]); 119453018216SPaolo Bonzini } 119553018216SPaolo Bonzini } 119653018216SPaolo Bonzini 11979861bb3eSSuraj Jitindar Singh static uint64_t spapr_get_patbe(PPCVirtualHypervisor *vhyp) 11989861bb3eSSuraj Jitindar Singh { 11999861bb3eSSuraj Jitindar Singh sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 12009861bb3eSSuraj Jitindar Singh 12019861bb3eSSuraj Jitindar Singh return spapr->patb_entry; 12029861bb3eSSuraj Jitindar Singh } 12039861bb3eSSuraj Jitindar Singh 1204e6b8fd24SSamuel Mendoza-Jonas #define HPTE(_table, _i) (void *)(((uint64_t *)(_table)) + ((_i) * 2)) 1205e6b8fd24SSamuel Mendoza-Jonas #define HPTE_VALID(_hpte) (tswap64(*((uint64_t *)(_hpte))) & HPTE64_V_VALID) 1206e6b8fd24SSamuel Mendoza-Jonas #define HPTE_DIRTY(_hpte) (tswap64(*((uint64_t *)(_hpte))) & HPTE64_V_HPTE_DIRTY) 1207e6b8fd24SSamuel Mendoza-Jonas #define CLEAN_HPTE(_hpte) ((*(uint64_t *)(_hpte)) &= tswap64(~HPTE64_V_HPTE_DIRTY)) 1208e6b8fd24SSamuel Mendoza-Jonas #define DIRTY_HPTE(_hpte) ((*(uint64_t *)(_hpte)) |= tswap64(HPTE64_V_HPTE_DIRTY)) 1209e6b8fd24SSamuel Mendoza-Jonas 1210715c5407SDavid Gibson /* 1211715c5407SDavid Gibson * Get the fd to access the kernel htab, re-opening it if necessary 1212715c5407SDavid Gibson */ 1213715c5407SDavid Gibson static int get_htab_fd(sPAPRMachineState *spapr) 1214715c5407SDavid Gibson { 1215715c5407SDavid Gibson if (spapr->htab_fd >= 0) { 1216715c5407SDavid Gibson return spapr->htab_fd; 1217715c5407SDavid Gibson } 1218715c5407SDavid Gibson 1219715c5407SDavid Gibson spapr->htab_fd = kvmppc_get_htab_fd(false); 1220715c5407SDavid Gibson if (spapr->htab_fd < 0) { 1221715c5407SDavid Gibson error_report("Unable to open fd for reading hash table from KVM: %s", 1222715c5407SDavid Gibson strerror(errno)); 1223715c5407SDavid Gibson } 1224715c5407SDavid Gibson 1225715c5407SDavid Gibson return spapr->htab_fd; 1226715c5407SDavid Gibson } 1227715c5407SDavid Gibson 1228b4db5413SSuraj Jitindar Singh void close_htab_fd(sPAPRMachineState *spapr) 1229715c5407SDavid Gibson { 1230715c5407SDavid Gibson if (spapr->htab_fd >= 0) { 1231715c5407SDavid Gibson close(spapr->htab_fd); 1232715c5407SDavid Gibson } 1233715c5407SDavid Gibson spapr->htab_fd = -1; 1234715c5407SDavid Gibson } 1235715c5407SDavid Gibson 1236e57ca75cSDavid Gibson static hwaddr spapr_hpt_mask(PPCVirtualHypervisor *vhyp) 1237e57ca75cSDavid Gibson { 1238e57ca75cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 1239e57ca75cSDavid Gibson 1240e57ca75cSDavid Gibson return HTAB_SIZE(spapr) / HASH_PTEG_SIZE_64 - 1; 1241e57ca75cSDavid Gibson } 1242e57ca75cSDavid Gibson 1243e57ca75cSDavid Gibson static const ppc_hash_pte64_t *spapr_map_hptes(PPCVirtualHypervisor *vhyp, 1244e57ca75cSDavid Gibson hwaddr ptex, int n) 1245e57ca75cSDavid Gibson { 1246e57ca75cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 1247e57ca75cSDavid Gibson hwaddr pte_offset = ptex * HASH_PTE_SIZE_64; 1248e57ca75cSDavid Gibson 1249e57ca75cSDavid Gibson if (!spapr->htab) { 1250e57ca75cSDavid Gibson /* 1251e57ca75cSDavid Gibson * HTAB is controlled by KVM. Fetch into temporary buffer 1252e57ca75cSDavid Gibson */ 1253e57ca75cSDavid Gibson ppc_hash_pte64_t *hptes = g_malloc(n * HASH_PTE_SIZE_64); 1254e57ca75cSDavid Gibson kvmppc_read_hptes(hptes, ptex, n); 1255e57ca75cSDavid Gibson return hptes; 1256e57ca75cSDavid Gibson } 1257e57ca75cSDavid Gibson 1258e57ca75cSDavid Gibson /* 1259e57ca75cSDavid Gibson * HTAB is controlled by QEMU. Just point to the internally 1260e57ca75cSDavid Gibson * accessible PTEG. 1261e57ca75cSDavid Gibson */ 1262e57ca75cSDavid Gibson return (const ppc_hash_pte64_t *)(spapr->htab + pte_offset); 1263e57ca75cSDavid Gibson } 1264e57ca75cSDavid Gibson 1265e57ca75cSDavid Gibson static void spapr_unmap_hptes(PPCVirtualHypervisor *vhyp, 1266e57ca75cSDavid Gibson const ppc_hash_pte64_t *hptes, 1267e57ca75cSDavid Gibson hwaddr ptex, int n) 1268e57ca75cSDavid Gibson { 1269e57ca75cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 1270e57ca75cSDavid Gibson 1271e57ca75cSDavid Gibson if (!spapr->htab) { 1272e57ca75cSDavid Gibson g_free((void *)hptes); 1273e57ca75cSDavid Gibson } 1274e57ca75cSDavid Gibson 1275e57ca75cSDavid Gibson /* Nothing to do for qemu managed HPT */ 1276e57ca75cSDavid Gibson } 1277e57ca75cSDavid Gibson 1278e57ca75cSDavid Gibson static void spapr_store_hpte(PPCVirtualHypervisor *vhyp, hwaddr ptex, 1279e57ca75cSDavid Gibson uint64_t pte0, uint64_t pte1) 1280e57ca75cSDavid Gibson { 1281e57ca75cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 1282e57ca75cSDavid Gibson hwaddr offset = ptex * HASH_PTE_SIZE_64; 1283e57ca75cSDavid Gibson 1284e57ca75cSDavid Gibson if (!spapr->htab) { 1285e57ca75cSDavid Gibson kvmppc_write_hpte(ptex, pte0, pte1); 1286e57ca75cSDavid Gibson } else { 1287e57ca75cSDavid Gibson stq_p(spapr->htab + offset, pte0); 1288e57ca75cSDavid Gibson stq_p(spapr->htab + offset + HASH_PTE_SIZE_64 / 2, pte1); 1289e57ca75cSDavid Gibson } 1290e57ca75cSDavid Gibson } 1291e57ca75cSDavid Gibson 12920b0b8310SDavid Gibson int spapr_hpt_shift_for_ramsize(uint64_t ramsize) 12938dfe8e7fSDavid Gibson { 12948dfe8e7fSDavid Gibson int shift; 12958dfe8e7fSDavid Gibson 12968dfe8e7fSDavid Gibson /* We aim for a hash table of size 1/128 the size of RAM (rounded 12978dfe8e7fSDavid Gibson * up). The PAPR recommendation is actually 1/64 of RAM size, but 12988dfe8e7fSDavid Gibson * that's much more than is needed for Linux guests */ 12998dfe8e7fSDavid Gibson shift = ctz64(pow2ceil(ramsize)) - 7; 13008dfe8e7fSDavid Gibson shift = MAX(shift, 18); /* Minimum architected size */ 13018dfe8e7fSDavid Gibson shift = MIN(shift, 46); /* Maximum architected size */ 13028dfe8e7fSDavid Gibson return shift; 13038dfe8e7fSDavid Gibson } 13048dfe8e7fSDavid Gibson 130506ec79e8SBharata B Rao void spapr_free_hpt(sPAPRMachineState *spapr) 130606ec79e8SBharata B Rao { 130706ec79e8SBharata B Rao g_free(spapr->htab); 130806ec79e8SBharata B Rao spapr->htab = NULL; 130906ec79e8SBharata B Rao spapr->htab_shift = 0; 131006ec79e8SBharata B Rao close_htab_fd(spapr); 131106ec79e8SBharata B Rao } 131206ec79e8SBharata B Rao 13132772cf6bSDavid Gibson void spapr_reallocate_hpt(sPAPRMachineState *spapr, int shift, 1314c5f54f3eSDavid Gibson Error **errp) 131553018216SPaolo Bonzini { 1316c5f54f3eSDavid Gibson long rc; 131753018216SPaolo Bonzini 1318c5f54f3eSDavid Gibson /* Clean up any HPT info from a previous boot */ 131906ec79e8SBharata B Rao spapr_free_hpt(spapr); 132053018216SPaolo Bonzini 1321c5f54f3eSDavid Gibson rc = kvmppc_reset_htab(shift); 1322c5f54f3eSDavid Gibson if (rc < 0) { 1323c5f54f3eSDavid Gibson /* kernel-side HPT needed, but couldn't allocate one */ 1324c5f54f3eSDavid Gibson error_setg_errno(errp, errno, 1325c5f54f3eSDavid Gibson "Failed to allocate KVM HPT of order %d (try smaller maxmem?)", 1326c5f54f3eSDavid Gibson shift); 1327c5f54f3eSDavid Gibson /* This is almost certainly fatal, but if the caller really 1328c5f54f3eSDavid Gibson * wants to carry on with shift == 0, it's welcome to try */ 1329c5f54f3eSDavid Gibson } else if (rc > 0) { 1330c5f54f3eSDavid Gibson /* kernel-side HPT allocated */ 1331c5f54f3eSDavid Gibson if (rc != shift) { 1332c5f54f3eSDavid Gibson error_setg(errp, 1333c5f54f3eSDavid Gibson "Requested order %d HPT, but kernel allocated order %ld (try smaller maxmem?)", 1334c5f54f3eSDavid Gibson shift, rc); 13357735fedaSBharata B Rao } 13367735fedaSBharata B Rao 133753018216SPaolo Bonzini spapr->htab_shift = shift; 1338c18ad9a5SDavid Gibson spapr->htab = NULL; 1339b817772aSBharata B Rao } else { 1340c5f54f3eSDavid Gibson /* kernel-side HPT not needed, allocate in userspace instead */ 1341c5f54f3eSDavid Gibson size_t size = 1ULL << shift; 1342c5f54f3eSDavid Gibson int i; 134301a57972SSamuel Mendoza-Jonas 1344c5f54f3eSDavid Gibson spapr->htab = qemu_memalign(size, size); 1345c5f54f3eSDavid Gibson if (!spapr->htab) { 1346c5f54f3eSDavid Gibson error_setg_errno(errp, errno, 1347c5f54f3eSDavid Gibson "Could not allocate HPT of order %d", shift); 1348c5f54f3eSDavid Gibson return; 1349b817772aSBharata B Rao } 1350b817772aSBharata B Rao 1351c5f54f3eSDavid Gibson memset(spapr->htab, 0, size); 1352c5f54f3eSDavid Gibson spapr->htab_shift = shift; 1353b817772aSBharata B Rao 1354c5f54f3eSDavid Gibson for (i = 0; i < size / HASH_PTE_SIZE_64; i++) { 1355c5f54f3eSDavid Gibson DIRTY_HPTE(HPTE(spapr->htab, i)); 13567735fedaSBharata B Rao } 135753018216SPaolo Bonzini } 135853018216SPaolo Bonzini } 135953018216SPaolo Bonzini 1360b4db5413SSuraj Jitindar Singh void spapr_setup_hpt_and_vrma(sPAPRMachineState *spapr) 1361b4db5413SSuraj Jitindar Singh { 13622772cf6bSDavid Gibson int hpt_shift; 13632772cf6bSDavid Gibson 13642772cf6bSDavid Gibson if ((spapr->resize_hpt == SPAPR_RESIZE_HPT_DISABLED) 13652772cf6bSDavid Gibson || (spapr->cas_reboot 13662772cf6bSDavid Gibson && !spapr_ovec_test(spapr->ov5_cas, OV5_HPT_RESIZE))) { 13672772cf6bSDavid Gibson hpt_shift = spapr_hpt_shift_for_ramsize(MACHINE(spapr)->maxram_size); 13682772cf6bSDavid Gibson } else { 13692772cf6bSDavid Gibson hpt_shift = spapr_hpt_shift_for_ramsize(MACHINE(spapr)->ram_size); 13702772cf6bSDavid Gibson } 13712772cf6bSDavid Gibson spapr_reallocate_hpt(spapr, hpt_shift, &error_fatal); 13722772cf6bSDavid Gibson 1373b4db5413SSuraj Jitindar Singh if (spapr->vrma_adjust) { 1374b4db5413SSuraj Jitindar Singh spapr->rma_size = kvmppc_rma_size(spapr_node0_size(), 1375b4db5413SSuraj Jitindar Singh spapr->htab_shift); 1376b4db5413SSuraj Jitindar Singh } 1377b4db5413SSuraj Jitindar Singh /* We're setting up a hash table, so that means we're not radix */ 1378b4db5413SSuraj Jitindar Singh spapr->patb_entry = 0; 1379b4db5413SSuraj Jitindar Singh } 1380b4db5413SSuraj Jitindar Singh 13814f01a637SDavid Gibson static void find_unknown_sysbus_device(SysBusDevice *sbdev, void *opaque) 13829e3f9733SAlexander Graf { 13839e3f9733SAlexander Graf bool matched = false; 13849e3f9733SAlexander Graf 13859e3f9733SAlexander Graf if (object_dynamic_cast(OBJECT(sbdev), TYPE_SPAPR_PCI_HOST_BRIDGE)) { 13869e3f9733SAlexander Graf matched = true; 13879e3f9733SAlexander Graf } 13889e3f9733SAlexander Graf 13899e3f9733SAlexander Graf if (!matched) { 13909e3f9733SAlexander Graf error_report("Device %s is not supported by this machine yet.", 13919e3f9733SAlexander Graf qdev_fw_name(DEVICE(sbdev))); 13929e3f9733SAlexander Graf exit(1); 13939e3f9733SAlexander Graf } 13949e3f9733SAlexander Graf } 13959e3f9733SAlexander Graf 139653018216SPaolo Bonzini static void ppc_spapr_reset(void) 139753018216SPaolo Bonzini { 1398c5f54f3eSDavid Gibson MachineState *machine = MACHINE(qdev_get_machine()); 1399c5f54f3eSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(machine); 1400182735efSAndreas Färber PowerPCCPU *first_ppc_cpu; 1401b7d1f77aSBenjamin Herrenschmidt uint32_t rtas_limit; 1402cae172abSDavid Gibson hwaddr rtas_addr, fdt_addr; 1403997b6cfcSDavid Gibson void *fdt; 1404997b6cfcSDavid Gibson int rc; 1405259186a7SAndreas Färber 14069e3f9733SAlexander Graf /* Check for unknown sysbus devices */ 14079e3f9733SAlexander Graf foreach_dynamic_sysbus_device(find_unknown_sysbus_device, NULL); 14089e3f9733SAlexander Graf 1409b4db5413SSuraj Jitindar Singh if (kvm_enabled() && kvmppc_has_cap_mmu_radix()) { 1410b4db5413SSuraj Jitindar Singh /* If using KVM with radix mode available, VCPUs can be started 1411b4db5413SSuraj Jitindar Singh * without a HPT because KVM will start them in radix mode. 1412b4db5413SSuraj Jitindar Singh * Set the GR bit in PATB so that we know there is no HPT. */ 1413b4db5413SSuraj Jitindar Singh spapr->patb_entry = PATBE1_GR; 1414b4db5413SSuraj Jitindar Singh } else { 1415b4db5413SSuraj Jitindar Singh spapr_setup_hpt_and_vrma(spapr); 1416c5f54f3eSDavid Gibson } 141753018216SPaolo Bonzini 141853018216SPaolo Bonzini qemu_devices_reset(); 141956258174SDaniel Henrique Barboza spapr_clear_pending_events(spapr); 142053018216SPaolo Bonzini 1421b7d1f77aSBenjamin Herrenschmidt /* 1422b7d1f77aSBenjamin Herrenschmidt * We place the device tree and RTAS just below either the top of the RMA, 1423b7d1f77aSBenjamin Herrenschmidt * or just below 2GB, whichever is lowere, so that it can be 1424b7d1f77aSBenjamin Herrenschmidt * processed with 32-bit real mode code if necessary 1425b7d1f77aSBenjamin Herrenschmidt */ 1426b7d1f77aSBenjamin Herrenschmidt rtas_limit = MIN(spapr->rma_size, RTAS_MAX_ADDR); 1427cae172abSDavid Gibson rtas_addr = rtas_limit - RTAS_MAX_SIZE; 1428cae172abSDavid Gibson fdt_addr = rtas_addr - FDT_MAX_SIZE; 1429b7d1f77aSBenjamin Herrenschmidt 14306787d27bSMichael Roth /* if this reset wasn't generated by CAS, we should reset our 14316787d27bSMichael Roth * negotiated options and start from scratch */ 14326787d27bSMichael Roth if (!spapr->cas_reboot) { 14336787d27bSMichael Roth spapr_ovec_cleanup(spapr->ov5_cas); 14346787d27bSMichael Roth spapr->ov5_cas = spapr_ovec_new(); 143566d5c492SDavid Gibson 143666d5c492SDavid Gibson ppc_set_compat_all(spapr->max_compat_pvr, &error_fatal); 14376787d27bSMichael Roth } 14386787d27bSMichael Roth 1439cae172abSDavid Gibson fdt = spapr_build_fdt(spapr, rtas_addr, spapr->rtas_size); 144053018216SPaolo Bonzini 14412cac78c1SDavid Gibson spapr_load_rtas(spapr, fdt, rtas_addr); 1442b7d1f77aSBenjamin Herrenschmidt 1443997b6cfcSDavid Gibson rc = fdt_pack(fdt); 1444997b6cfcSDavid Gibson 1445997b6cfcSDavid Gibson /* Should only fail if we've built a corrupted tree */ 1446997b6cfcSDavid Gibson assert(rc == 0); 1447997b6cfcSDavid Gibson 1448997b6cfcSDavid Gibson if (fdt_totalsize(fdt) > FDT_MAX_SIZE) { 1449997b6cfcSDavid Gibson error_report("FDT too big ! 0x%x bytes (max is 0x%x)", 1450997b6cfcSDavid Gibson fdt_totalsize(fdt), FDT_MAX_SIZE); 1451997b6cfcSDavid Gibson exit(1); 1452997b6cfcSDavid Gibson } 1453997b6cfcSDavid Gibson 1454997b6cfcSDavid Gibson /* Load the fdt */ 1455997b6cfcSDavid Gibson qemu_fdt_dumpdtb(fdt, fdt_totalsize(fdt)); 1456cae172abSDavid Gibson cpu_physical_memory_write(fdt_addr, fdt, fdt_totalsize(fdt)); 1457997b6cfcSDavid Gibson g_free(fdt); 1458997b6cfcSDavid Gibson 145953018216SPaolo Bonzini /* Set up the entry state */ 1460182735efSAndreas Färber first_ppc_cpu = POWERPC_CPU(first_cpu); 1461cae172abSDavid Gibson first_ppc_cpu->env.gpr[3] = fdt_addr; 1462182735efSAndreas Färber first_ppc_cpu->env.gpr[5] = 0; 1463182735efSAndreas Färber first_cpu->halted = 0; 14641b718907SDavid Gibson first_ppc_cpu->env.nip = SPAPR_ENTRY_POINT; 146553018216SPaolo Bonzini 14666787d27bSMichael Roth spapr->cas_reboot = false; 146753018216SPaolo Bonzini } 146853018216SPaolo Bonzini 146928e02042SDavid Gibson static void spapr_create_nvram(sPAPRMachineState *spapr) 147053018216SPaolo Bonzini { 14712ff3de68SMarkus Armbruster DeviceState *dev = qdev_create(&spapr->vio_bus->bus, "spapr-nvram"); 14723978b863SPaolo Bonzini DriveInfo *dinfo = drive_get(IF_PFLASH, 0, 0); 147353018216SPaolo Bonzini 14743978b863SPaolo Bonzini if (dinfo) { 14756231a6daSMarkus Armbruster qdev_prop_set_drive(dev, "drive", blk_by_legacy_dinfo(dinfo), 14766231a6daSMarkus Armbruster &error_fatal); 147753018216SPaolo Bonzini } 147853018216SPaolo Bonzini 147953018216SPaolo Bonzini qdev_init_nofail(dev); 148053018216SPaolo Bonzini 148153018216SPaolo Bonzini spapr->nvram = (struct sPAPRNVRAM *)dev; 148253018216SPaolo Bonzini } 148353018216SPaolo Bonzini 148428e02042SDavid Gibson static void spapr_rtc_create(sPAPRMachineState *spapr) 148528df36a1SDavid Gibson { 1486147ff807SCédric Le Goater object_initialize(&spapr->rtc, sizeof(spapr->rtc), TYPE_SPAPR_RTC); 1487147ff807SCédric Le Goater object_property_add_child(OBJECT(spapr), "rtc", OBJECT(&spapr->rtc), 1488147ff807SCédric Le Goater &error_fatal); 1489147ff807SCédric Le Goater object_property_set_bool(OBJECT(&spapr->rtc), true, "realized", 1490147ff807SCédric Le Goater &error_fatal); 1491147ff807SCédric Le Goater object_property_add_alias(OBJECT(spapr), "rtc-time", OBJECT(&spapr->rtc), 1492147ff807SCédric Le Goater "date", &error_fatal); 149328df36a1SDavid Gibson } 149428df36a1SDavid Gibson 149553018216SPaolo Bonzini /* Returns whether we want to use VGA or not */ 149614c6a894SDavid Gibson static bool spapr_vga_init(PCIBus *pci_bus, Error **errp) 149753018216SPaolo Bonzini { 149853018216SPaolo Bonzini switch (vga_interface_type) { 149953018216SPaolo Bonzini case VGA_NONE: 15007effdaa3SMark Wu return false; 15017effdaa3SMark Wu case VGA_DEVICE: 15027effdaa3SMark Wu return true; 150353018216SPaolo Bonzini case VGA_STD: 1504b798c190SBenjamin Herrenschmidt case VGA_VIRTIO: 150553018216SPaolo Bonzini return pci_vga_init(pci_bus) != NULL; 150653018216SPaolo Bonzini default: 150714c6a894SDavid Gibson error_setg(errp, 150814c6a894SDavid Gibson "Unsupported VGA mode, only -vga std or -vga virtio is supported"); 150914c6a894SDavid Gibson return false; 151053018216SPaolo Bonzini } 151153018216SPaolo Bonzini } 151253018216SPaolo Bonzini 1513880ae7deSDavid Gibson static int spapr_post_load(void *opaque, int version_id) 1514880ae7deSDavid Gibson { 151528e02042SDavid Gibson sPAPRMachineState *spapr = (sPAPRMachineState *)opaque; 1516880ae7deSDavid Gibson int err = 0; 1517880ae7deSDavid Gibson 1518a7ff1212SCédric Le Goater if (!object_dynamic_cast(OBJECT(spapr->ics), TYPE_ICS_KVM)) { 15195bc8d26dSCédric Le Goater CPUState *cs; 15205bc8d26dSCédric Le Goater CPU_FOREACH(cs) { 15215bc8d26dSCédric Le Goater PowerPCCPU *cpu = POWERPC_CPU(cs); 15225bc8d26dSCédric Le Goater icp_resend(ICP(cpu->intc)); 1523a7ff1212SCédric Le Goater } 1524a7ff1212SCédric Le Goater } 1525a7ff1212SCédric Le Goater 1526631b22eaSStefan Weil /* In earlier versions, there was no separate qdev for the PAPR 1527880ae7deSDavid Gibson * RTC, so the RTC offset was stored directly in sPAPREnvironment. 1528880ae7deSDavid Gibson * So when migrating from those versions, poke the incoming offset 1529880ae7deSDavid Gibson * value into the RTC device */ 1530880ae7deSDavid Gibson if (version_id < 3) { 1531147ff807SCédric Le Goater err = spapr_rtc_import_offset(&spapr->rtc, spapr->rtc_offset); 1532880ae7deSDavid Gibson } 1533880ae7deSDavid Gibson 1534d39c90f5SBharata B Rao if (spapr->patb_entry) { 1535d39c90f5SBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(first_cpu); 1536d39c90f5SBharata B Rao bool radix = !!(spapr->patb_entry & PATBE1_GR); 1537d39c90f5SBharata B Rao bool gtse = !!(cpu->env.spr[SPR_LPCR] & LPCR_GTSE); 1538d39c90f5SBharata B Rao 1539d39c90f5SBharata B Rao err = kvmppc_configure_v3_mmu(cpu, radix, gtse, spapr->patb_entry); 1540d39c90f5SBharata B Rao if (err) { 1541d39c90f5SBharata B Rao error_report("Process table config unsupported by the host"); 1542d39c90f5SBharata B Rao return -EINVAL; 1543d39c90f5SBharata B Rao } 1544d39c90f5SBharata B Rao } 1545d39c90f5SBharata B Rao 1546880ae7deSDavid Gibson return err; 1547880ae7deSDavid Gibson } 1548880ae7deSDavid Gibson 1549880ae7deSDavid Gibson static bool version_before_3(void *opaque, int version_id) 1550880ae7deSDavid Gibson { 1551880ae7deSDavid Gibson return version_id < 3; 1552880ae7deSDavid Gibson } 1553880ae7deSDavid Gibson 1554fd38804bSDaniel Henrique Barboza static bool spapr_pending_events_needed(void *opaque) 1555fd38804bSDaniel Henrique Barboza { 1556fd38804bSDaniel Henrique Barboza sPAPRMachineState *spapr = (sPAPRMachineState *)opaque; 1557fd38804bSDaniel Henrique Barboza return !QTAILQ_EMPTY(&spapr->pending_events); 1558fd38804bSDaniel Henrique Barboza } 1559fd38804bSDaniel Henrique Barboza 1560fd38804bSDaniel Henrique Barboza static const VMStateDescription vmstate_spapr_event_entry = { 1561fd38804bSDaniel Henrique Barboza .name = "spapr_event_log_entry", 1562fd38804bSDaniel Henrique Barboza .version_id = 1, 1563fd38804bSDaniel Henrique Barboza .minimum_version_id = 1, 1564fd38804bSDaniel Henrique Barboza .fields = (VMStateField[]) { 15655341258eSDavid Gibson VMSTATE_UINT32(summary, sPAPREventLogEntry), 15665341258eSDavid Gibson VMSTATE_UINT32(extended_length, sPAPREventLogEntry), 1567fd38804bSDaniel Henrique Barboza VMSTATE_VBUFFER_ALLOC_UINT32(extended_log, sPAPREventLogEntry, 0, 15685341258eSDavid Gibson NULL, extended_length), 1569fd38804bSDaniel Henrique Barboza VMSTATE_END_OF_LIST() 1570fd38804bSDaniel Henrique Barboza }, 1571fd38804bSDaniel Henrique Barboza }; 1572fd38804bSDaniel Henrique Barboza 1573fd38804bSDaniel Henrique Barboza static const VMStateDescription vmstate_spapr_pending_events = { 1574fd38804bSDaniel Henrique Barboza .name = "spapr_pending_events", 1575fd38804bSDaniel Henrique Barboza .version_id = 1, 1576fd38804bSDaniel Henrique Barboza .minimum_version_id = 1, 1577fd38804bSDaniel Henrique Barboza .needed = spapr_pending_events_needed, 1578fd38804bSDaniel Henrique Barboza .fields = (VMStateField[]) { 1579fd38804bSDaniel Henrique Barboza VMSTATE_QTAILQ_V(pending_events, sPAPRMachineState, 1, 1580fd38804bSDaniel Henrique Barboza vmstate_spapr_event_entry, sPAPREventLogEntry, next), 1581fd38804bSDaniel Henrique Barboza VMSTATE_END_OF_LIST() 1582fd38804bSDaniel Henrique Barboza }, 1583fd38804bSDaniel Henrique Barboza }; 1584fd38804bSDaniel Henrique Barboza 158562ef3760SMichael Roth static bool spapr_ov5_cas_needed(void *opaque) 158662ef3760SMichael Roth { 158762ef3760SMichael Roth sPAPRMachineState *spapr = opaque; 158862ef3760SMichael Roth sPAPROptionVector *ov5_mask = spapr_ovec_new(); 158962ef3760SMichael Roth sPAPROptionVector *ov5_legacy = spapr_ovec_new(); 159062ef3760SMichael Roth sPAPROptionVector *ov5_removed = spapr_ovec_new(); 159162ef3760SMichael Roth bool cas_needed; 159262ef3760SMichael Roth 159362ef3760SMichael Roth /* Prior to the introduction of sPAPROptionVector, we had two option 159462ef3760SMichael Roth * vectors we dealt with: OV5_FORM1_AFFINITY, and OV5_DRCONF_MEMORY. 159562ef3760SMichael Roth * Both of these options encode machine topology into the device-tree 159662ef3760SMichael Roth * in such a way that the now-booted OS should still be able to interact 159762ef3760SMichael Roth * appropriately with QEMU regardless of what options were actually 159862ef3760SMichael Roth * negotiatied on the source side. 159962ef3760SMichael Roth * 160062ef3760SMichael Roth * As such, we can avoid migrating the CAS-negotiated options if these 160162ef3760SMichael Roth * are the only options available on the current machine/platform. 160262ef3760SMichael Roth * Since these are the only options available for pseries-2.7 and 160362ef3760SMichael Roth * earlier, this allows us to maintain old->new/new->old migration 160462ef3760SMichael Roth * compatibility. 160562ef3760SMichael Roth * 160662ef3760SMichael Roth * For QEMU 2.8+, there are additional CAS-negotiatable options available 160762ef3760SMichael Roth * via default pseries-2.8 machines and explicit command-line parameters. 160862ef3760SMichael Roth * Some of these options, like OV5_HP_EVT, *do* require QEMU to be aware 160962ef3760SMichael Roth * of the actual CAS-negotiated values to continue working properly. For 161062ef3760SMichael Roth * example, availability of memory unplug depends on knowing whether 161162ef3760SMichael Roth * OV5_HP_EVT was negotiated via CAS. 161262ef3760SMichael Roth * 161362ef3760SMichael Roth * Thus, for any cases where the set of available CAS-negotiatable 161462ef3760SMichael Roth * options extends beyond OV5_FORM1_AFFINITY and OV5_DRCONF_MEMORY, we 161562ef3760SMichael Roth * include the CAS-negotiated options in the migration stream. 161662ef3760SMichael Roth */ 161762ef3760SMichael Roth spapr_ovec_set(ov5_mask, OV5_FORM1_AFFINITY); 161862ef3760SMichael Roth spapr_ovec_set(ov5_mask, OV5_DRCONF_MEMORY); 161962ef3760SMichael Roth 162062ef3760SMichael Roth /* spapr_ovec_diff returns true if bits were removed. we avoid using 162162ef3760SMichael Roth * the mask itself since in the future it's possible "legacy" bits may be 162262ef3760SMichael Roth * removed via machine options, which could generate a false positive 162362ef3760SMichael Roth * that breaks migration. 162462ef3760SMichael Roth */ 162562ef3760SMichael Roth spapr_ovec_intersect(ov5_legacy, spapr->ov5, ov5_mask); 162662ef3760SMichael Roth cas_needed = spapr_ovec_diff(ov5_removed, spapr->ov5, ov5_legacy); 162762ef3760SMichael Roth 162862ef3760SMichael Roth spapr_ovec_cleanup(ov5_mask); 162962ef3760SMichael Roth spapr_ovec_cleanup(ov5_legacy); 163062ef3760SMichael Roth spapr_ovec_cleanup(ov5_removed); 163162ef3760SMichael Roth 163262ef3760SMichael Roth return cas_needed; 163362ef3760SMichael Roth } 163462ef3760SMichael Roth 163562ef3760SMichael Roth static const VMStateDescription vmstate_spapr_ov5_cas = { 163662ef3760SMichael Roth .name = "spapr_option_vector_ov5_cas", 163762ef3760SMichael Roth .version_id = 1, 163862ef3760SMichael Roth .minimum_version_id = 1, 163962ef3760SMichael Roth .needed = spapr_ov5_cas_needed, 164062ef3760SMichael Roth .fields = (VMStateField[]) { 164162ef3760SMichael Roth VMSTATE_STRUCT_POINTER_V(ov5_cas, sPAPRMachineState, 1, 164262ef3760SMichael Roth vmstate_spapr_ovec, sPAPROptionVector), 164362ef3760SMichael Roth VMSTATE_END_OF_LIST() 164462ef3760SMichael Roth }, 164562ef3760SMichael Roth }; 164662ef3760SMichael Roth 16479861bb3eSSuraj Jitindar Singh static bool spapr_patb_entry_needed(void *opaque) 16489861bb3eSSuraj Jitindar Singh { 16499861bb3eSSuraj Jitindar Singh sPAPRMachineState *spapr = opaque; 16509861bb3eSSuraj Jitindar Singh 16519861bb3eSSuraj Jitindar Singh return !!spapr->patb_entry; 16529861bb3eSSuraj Jitindar Singh } 16539861bb3eSSuraj Jitindar Singh 16549861bb3eSSuraj Jitindar Singh static const VMStateDescription vmstate_spapr_patb_entry = { 16559861bb3eSSuraj Jitindar Singh .name = "spapr_patb_entry", 16569861bb3eSSuraj Jitindar Singh .version_id = 1, 16579861bb3eSSuraj Jitindar Singh .minimum_version_id = 1, 16589861bb3eSSuraj Jitindar Singh .needed = spapr_patb_entry_needed, 16599861bb3eSSuraj Jitindar Singh .fields = (VMStateField[]) { 16609861bb3eSSuraj Jitindar Singh VMSTATE_UINT64(patb_entry, sPAPRMachineState), 16619861bb3eSSuraj Jitindar Singh VMSTATE_END_OF_LIST() 16629861bb3eSSuraj Jitindar Singh }, 16639861bb3eSSuraj Jitindar Singh }; 16649861bb3eSSuraj Jitindar Singh 16654be21d56SDavid Gibson static const VMStateDescription vmstate_spapr = { 16664be21d56SDavid Gibson .name = "spapr", 1667880ae7deSDavid Gibson .version_id = 3, 16684be21d56SDavid Gibson .minimum_version_id = 1, 1669880ae7deSDavid Gibson .post_load = spapr_post_load, 16704be21d56SDavid Gibson .fields = (VMStateField[]) { 1671880ae7deSDavid Gibson /* used to be @next_irq */ 1672880ae7deSDavid Gibson VMSTATE_UNUSED_BUFFER(version_before_3, 0, 4), 16734be21d56SDavid Gibson 16744be21d56SDavid Gibson /* RTC offset */ 167528e02042SDavid Gibson VMSTATE_UINT64_TEST(rtc_offset, sPAPRMachineState, version_before_3), 1676880ae7deSDavid Gibson 167728e02042SDavid Gibson VMSTATE_PPC_TIMEBASE_V(tb, sPAPRMachineState, 2), 16784be21d56SDavid Gibson VMSTATE_END_OF_LIST() 16794be21d56SDavid Gibson }, 168062ef3760SMichael Roth .subsections = (const VMStateDescription*[]) { 168162ef3760SMichael Roth &vmstate_spapr_ov5_cas, 16829861bb3eSSuraj Jitindar Singh &vmstate_spapr_patb_entry, 1683fd38804bSDaniel Henrique Barboza &vmstate_spapr_pending_events, 168462ef3760SMichael Roth NULL 168562ef3760SMichael Roth } 16864be21d56SDavid Gibson }; 16874be21d56SDavid Gibson 16884be21d56SDavid Gibson static int htab_save_setup(QEMUFile *f, void *opaque) 16894be21d56SDavid Gibson { 169028e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 16914be21d56SDavid Gibson 16924be21d56SDavid Gibson /* "Iteration" header */ 16933a384297SBharata B Rao if (!spapr->htab_shift) { 16943a384297SBharata B Rao qemu_put_be32(f, -1); 16953a384297SBharata B Rao } else { 16964be21d56SDavid Gibson qemu_put_be32(f, spapr->htab_shift); 16973a384297SBharata B Rao } 16984be21d56SDavid Gibson 1699e68cb8b4SAlexey Kardashevskiy if (spapr->htab) { 1700e68cb8b4SAlexey Kardashevskiy spapr->htab_save_index = 0; 1701e68cb8b4SAlexey Kardashevskiy spapr->htab_first_pass = true; 1702e68cb8b4SAlexey Kardashevskiy } else { 17033a384297SBharata B Rao if (spapr->htab_shift) { 1704e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 17054be21d56SDavid Gibson } 17063a384297SBharata B Rao } 17074be21d56SDavid Gibson 1708e68cb8b4SAlexey Kardashevskiy 1709e68cb8b4SAlexey Kardashevskiy return 0; 1710e68cb8b4SAlexey Kardashevskiy } 17114be21d56SDavid Gibson 171228e02042SDavid Gibson static void htab_save_first_pass(QEMUFile *f, sPAPRMachineState *spapr, 17134be21d56SDavid Gibson int64_t max_ns) 17144be21d56SDavid Gibson { 1715378bc217SDavid Gibson bool has_timeout = max_ns != -1; 17164be21d56SDavid Gibson int htabslots = HTAB_SIZE(spapr) / HASH_PTE_SIZE_64; 17174be21d56SDavid Gibson int index = spapr->htab_save_index; 1718bc72ad67SAlex Bligh int64_t starttime = qemu_clock_get_ns(QEMU_CLOCK_REALTIME); 17194be21d56SDavid Gibson 17204be21d56SDavid Gibson assert(spapr->htab_first_pass); 17214be21d56SDavid Gibson 17224be21d56SDavid Gibson do { 17234be21d56SDavid Gibson int chunkstart; 17244be21d56SDavid Gibson 17254be21d56SDavid Gibson /* Consume invalid HPTEs */ 17264be21d56SDavid Gibson while ((index < htabslots) 17274be21d56SDavid Gibson && !HPTE_VALID(HPTE(spapr->htab, index))) { 17284be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 172924ec2863SMarc-André Lureau index++; 17304be21d56SDavid Gibson } 17314be21d56SDavid Gibson 17324be21d56SDavid Gibson /* Consume valid HPTEs */ 17334be21d56SDavid Gibson chunkstart = index; 1734338c25b6SSamuel Mendoza-Jonas while ((index < htabslots) && (index - chunkstart < USHRT_MAX) 17354be21d56SDavid Gibson && HPTE_VALID(HPTE(spapr->htab, index))) { 17364be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 173724ec2863SMarc-André Lureau index++; 17384be21d56SDavid Gibson } 17394be21d56SDavid Gibson 17404be21d56SDavid Gibson if (index > chunkstart) { 17414be21d56SDavid Gibson int n_valid = index - chunkstart; 17424be21d56SDavid Gibson 17434be21d56SDavid Gibson qemu_put_be32(f, chunkstart); 17444be21d56SDavid Gibson qemu_put_be16(f, n_valid); 17454be21d56SDavid Gibson qemu_put_be16(f, 0); 17464be21d56SDavid Gibson qemu_put_buffer(f, HPTE(spapr->htab, chunkstart), 17474be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_valid); 17484be21d56SDavid Gibson 1749378bc217SDavid Gibson if (has_timeout && 1750378bc217SDavid Gibson (qemu_clock_get_ns(QEMU_CLOCK_REALTIME) - starttime) > max_ns) { 17514be21d56SDavid Gibson break; 17524be21d56SDavid Gibson } 17534be21d56SDavid Gibson } 17544be21d56SDavid Gibson } while ((index < htabslots) && !qemu_file_rate_limit(f)); 17554be21d56SDavid Gibson 17564be21d56SDavid Gibson if (index >= htabslots) { 17574be21d56SDavid Gibson assert(index == htabslots); 17584be21d56SDavid Gibson index = 0; 17594be21d56SDavid Gibson spapr->htab_first_pass = false; 17604be21d56SDavid Gibson } 17614be21d56SDavid Gibson spapr->htab_save_index = index; 17624be21d56SDavid Gibson } 17634be21d56SDavid Gibson 176428e02042SDavid Gibson static int htab_save_later_pass(QEMUFile *f, sPAPRMachineState *spapr, 17654be21d56SDavid Gibson int64_t max_ns) 17664be21d56SDavid Gibson { 17674be21d56SDavid Gibson bool final = max_ns < 0; 17684be21d56SDavid Gibson int htabslots = HTAB_SIZE(spapr) / HASH_PTE_SIZE_64; 17694be21d56SDavid Gibson int examined = 0, sent = 0; 17704be21d56SDavid Gibson int index = spapr->htab_save_index; 1771bc72ad67SAlex Bligh int64_t starttime = qemu_clock_get_ns(QEMU_CLOCK_REALTIME); 17724be21d56SDavid Gibson 17734be21d56SDavid Gibson assert(!spapr->htab_first_pass); 17744be21d56SDavid Gibson 17754be21d56SDavid Gibson do { 17764be21d56SDavid Gibson int chunkstart, invalidstart; 17774be21d56SDavid Gibson 17784be21d56SDavid Gibson /* Consume non-dirty HPTEs */ 17794be21d56SDavid Gibson while ((index < htabslots) 17804be21d56SDavid Gibson && !HPTE_DIRTY(HPTE(spapr->htab, index))) { 17814be21d56SDavid Gibson index++; 17824be21d56SDavid Gibson examined++; 17834be21d56SDavid Gibson } 17844be21d56SDavid Gibson 17854be21d56SDavid Gibson chunkstart = index; 17864be21d56SDavid Gibson /* Consume valid dirty HPTEs */ 1787338c25b6SSamuel Mendoza-Jonas while ((index < htabslots) && (index - chunkstart < USHRT_MAX) 17884be21d56SDavid Gibson && HPTE_DIRTY(HPTE(spapr->htab, index)) 17894be21d56SDavid Gibson && HPTE_VALID(HPTE(spapr->htab, index))) { 17904be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 17914be21d56SDavid Gibson index++; 17924be21d56SDavid Gibson examined++; 17934be21d56SDavid Gibson } 17944be21d56SDavid Gibson 17954be21d56SDavid Gibson invalidstart = index; 17964be21d56SDavid Gibson /* Consume invalid dirty HPTEs */ 1797338c25b6SSamuel Mendoza-Jonas while ((index < htabslots) && (index - invalidstart < USHRT_MAX) 17984be21d56SDavid Gibson && HPTE_DIRTY(HPTE(spapr->htab, index)) 17994be21d56SDavid Gibson && !HPTE_VALID(HPTE(spapr->htab, index))) { 18004be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 18014be21d56SDavid Gibson index++; 18024be21d56SDavid Gibson examined++; 18034be21d56SDavid Gibson } 18044be21d56SDavid Gibson 18054be21d56SDavid Gibson if (index > chunkstart) { 18064be21d56SDavid Gibson int n_valid = invalidstart - chunkstart; 18074be21d56SDavid Gibson int n_invalid = index - invalidstart; 18084be21d56SDavid Gibson 18094be21d56SDavid Gibson qemu_put_be32(f, chunkstart); 18104be21d56SDavid Gibson qemu_put_be16(f, n_valid); 18114be21d56SDavid Gibson qemu_put_be16(f, n_invalid); 18124be21d56SDavid Gibson qemu_put_buffer(f, HPTE(spapr->htab, chunkstart), 18134be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_valid); 18144be21d56SDavid Gibson sent += index - chunkstart; 18154be21d56SDavid Gibson 1816bc72ad67SAlex Bligh if (!final && (qemu_clock_get_ns(QEMU_CLOCK_REALTIME) - starttime) > max_ns) { 18174be21d56SDavid Gibson break; 18184be21d56SDavid Gibson } 18194be21d56SDavid Gibson } 18204be21d56SDavid Gibson 18214be21d56SDavid Gibson if (examined >= htabslots) { 18224be21d56SDavid Gibson break; 18234be21d56SDavid Gibson } 18244be21d56SDavid Gibson 18254be21d56SDavid Gibson if (index >= htabslots) { 18264be21d56SDavid Gibson assert(index == htabslots); 18274be21d56SDavid Gibson index = 0; 18284be21d56SDavid Gibson } 18294be21d56SDavid Gibson } while ((examined < htabslots) && (!qemu_file_rate_limit(f) || final)); 18304be21d56SDavid Gibson 18314be21d56SDavid Gibson if (index >= htabslots) { 18324be21d56SDavid Gibson assert(index == htabslots); 18334be21d56SDavid Gibson index = 0; 18344be21d56SDavid Gibson } 18354be21d56SDavid Gibson 18364be21d56SDavid Gibson spapr->htab_save_index = index; 18374be21d56SDavid Gibson 1838e68cb8b4SAlexey Kardashevskiy return (examined >= htabslots) && (sent == 0) ? 1 : 0; 18394be21d56SDavid Gibson } 18404be21d56SDavid Gibson 1841e68cb8b4SAlexey Kardashevskiy #define MAX_ITERATION_NS 5000000 /* 5 ms */ 1842e68cb8b4SAlexey Kardashevskiy #define MAX_KVM_BUF_SIZE 2048 1843e68cb8b4SAlexey Kardashevskiy 18444be21d56SDavid Gibson static int htab_save_iterate(QEMUFile *f, void *opaque) 18454be21d56SDavid Gibson { 184628e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 1847715c5407SDavid Gibson int fd; 1848e68cb8b4SAlexey Kardashevskiy int rc = 0; 18494be21d56SDavid Gibson 18504be21d56SDavid Gibson /* Iteration header */ 18513a384297SBharata B Rao if (!spapr->htab_shift) { 18523a384297SBharata B Rao qemu_put_be32(f, -1); 1853e8cd4247SLaurent Vivier return 1; 18543a384297SBharata B Rao } else { 18554be21d56SDavid Gibson qemu_put_be32(f, 0); 18563a384297SBharata B Rao } 18574be21d56SDavid Gibson 1858e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1859e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 1860e68cb8b4SAlexey Kardashevskiy 1861715c5407SDavid Gibson fd = get_htab_fd(spapr); 1862715c5407SDavid Gibson if (fd < 0) { 1863715c5407SDavid Gibson return fd; 186401a57972SSamuel Mendoza-Jonas } 186501a57972SSamuel Mendoza-Jonas 1866715c5407SDavid Gibson rc = kvmppc_save_htab(f, fd, MAX_KVM_BUF_SIZE, MAX_ITERATION_NS); 1867e68cb8b4SAlexey Kardashevskiy if (rc < 0) { 1868e68cb8b4SAlexey Kardashevskiy return rc; 1869e68cb8b4SAlexey Kardashevskiy } 1870e68cb8b4SAlexey Kardashevskiy } else if (spapr->htab_first_pass) { 18714be21d56SDavid Gibson htab_save_first_pass(f, spapr, MAX_ITERATION_NS); 18724be21d56SDavid Gibson } else { 1873e68cb8b4SAlexey Kardashevskiy rc = htab_save_later_pass(f, spapr, MAX_ITERATION_NS); 18744be21d56SDavid Gibson } 18754be21d56SDavid Gibson 18764be21d56SDavid Gibson /* End marker */ 18774be21d56SDavid Gibson qemu_put_be32(f, 0); 18784be21d56SDavid Gibson qemu_put_be16(f, 0); 18794be21d56SDavid Gibson qemu_put_be16(f, 0); 18804be21d56SDavid Gibson 1881e68cb8b4SAlexey Kardashevskiy return rc; 18824be21d56SDavid Gibson } 18834be21d56SDavid Gibson 18844be21d56SDavid Gibson static int htab_save_complete(QEMUFile *f, void *opaque) 18854be21d56SDavid Gibson { 188628e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 1887715c5407SDavid Gibson int fd; 18884be21d56SDavid Gibson 18894be21d56SDavid Gibson /* Iteration header */ 18903a384297SBharata B Rao if (!spapr->htab_shift) { 18913a384297SBharata B Rao qemu_put_be32(f, -1); 18923a384297SBharata B Rao return 0; 18933a384297SBharata B Rao } else { 18944be21d56SDavid Gibson qemu_put_be32(f, 0); 18953a384297SBharata B Rao } 18964be21d56SDavid Gibson 1897e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1898e68cb8b4SAlexey Kardashevskiy int rc; 1899e68cb8b4SAlexey Kardashevskiy 1900e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 1901e68cb8b4SAlexey Kardashevskiy 1902715c5407SDavid Gibson fd = get_htab_fd(spapr); 1903715c5407SDavid Gibson if (fd < 0) { 1904715c5407SDavid Gibson return fd; 190501a57972SSamuel Mendoza-Jonas } 190601a57972SSamuel Mendoza-Jonas 1907715c5407SDavid Gibson rc = kvmppc_save_htab(f, fd, MAX_KVM_BUF_SIZE, -1); 1908e68cb8b4SAlexey Kardashevskiy if (rc < 0) { 1909e68cb8b4SAlexey Kardashevskiy return rc; 1910e68cb8b4SAlexey Kardashevskiy } 1911e68cb8b4SAlexey Kardashevskiy } else { 1912378bc217SDavid Gibson if (spapr->htab_first_pass) { 1913378bc217SDavid Gibson htab_save_first_pass(f, spapr, -1); 1914378bc217SDavid Gibson } 19154be21d56SDavid Gibson htab_save_later_pass(f, spapr, -1); 1916e68cb8b4SAlexey Kardashevskiy } 19174be21d56SDavid Gibson 19184be21d56SDavid Gibson /* End marker */ 19194be21d56SDavid Gibson qemu_put_be32(f, 0); 19204be21d56SDavid Gibson qemu_put_be16(f, 0); 19214be21d56SDavid Gibson qemu_put_be16(f, 0); 19224be21d56SDavid Gibson 19234be21d56SDavid Gibson return 0; 19244be21d56SDavid Gibson } 19254be21d56SDavid Gibson 19264be21d56SDavid Gibson static int htab_load(QEMUFile *f, void *opaque, int version_id) 19274be21d56SDavid Gibson { 192828e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 19294be21d56SDavid Gibson uint32_t section_hdr; 1930e68cb8b4SAlexey Kardashevskiy int fd = -1; 19314be21d56SDavid Gibson 19324be21d56SDavid Gibson if (version_id < 1 || version_id > 1) { 193398a5d100SDavid Gibson error_report("htab_load() bad version"); 19344be21d56SDavid Gibson return -EINVAL; 19354be21d56SDavid Gibson } 19364be21d56SDavid Gibson 19374be21d56SDavid Gibson section_hdr = qemu_get_be32(f); 19384be21d56SDavid Gibson 19393a384297SBharata B Rao if (section_hdr == -1) { 19403a384297SBharata B Rao spapr_free_hpt(spapr); 19413a384297SBharata B Rao return 0; 19423a384297SBharata B Rao } 19433a384297SBharata B Rao 19444be21d56SDavid Gibson if (section_hdr) { 19459897e462SGreg Kurz Error *local_err = NULL; 1946c5f54f3eSDavid Gibson 1947c5f54f3eSDavid Gibson /* First section gives the htab size */ 1948c5f54f3eSDavid Gibson spapr_reallocate_hpt(spapr, section_hdr, &local_err); 1949c5f54f3eSDavid Gibson if (local_err) { 1950c5f54f3eSDavid Gibson error_report_err(local_err); 19514be21d56SDavid Gibson return -EINVAL; 19524be21d56SDavid Gibson } 19534be21d56SDavid Gibson return 0; 19544be21d56SDavid Gibson } 19554be21d56SDavid Gibson 1956e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1957e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 1958e68cb8b4SAlexey Kardashevskiy 1959e68cb8b4SAlexey Kardashevskiy fd = kvmppc_get_htab_fd(true); 1960e68cb8b4SAlexey Kardashevskiy if (fd < 0) { 196198a5d100SDavid Gibson error_report("Unable to open fd to restore KVM hash table: %s", 1962e68cb8b4SAlexey Kardashevskiy strerror(errno)); 1963e68cb8b4SAlexey Kardashevskiy } 1964e68cb8b4SAlexey Kardashevskiy } 1965e68cb8b4SAlexey Kardashevskiy 19664be21d56SDavid Gibson while (true) { 19674be21d56SDavid Gibson uint32_t index; 19684be21d56SDavid Gibson uint16_t n_valid, n_invalid; 19694be21d56SDavid Gibson 19704be21d56SDavid Gibson index = qemu_get_be32(f); 19714be21d56SDavid Gibson n_valid = qemu_get_be16(f); 19724be21d56SDavid Gibson n_invalid = qemu_get_be16(f); 19734be21d56SDavid Gibson 19744be21d56SDavid Gibson if ((index == 0) && (n_valid == 0) && (n_invalid == 0)) { 19754be21d56SDavid Gibson /* End of Stream */ 19764be21d56SDavid Gibson break; 19774be21d56SDavid Gibson } 19784be21d56SDavid Gibson 1979e68cb8b4SAlexey Kardashevskiy if ((index + n_valid + n_invalid) > 19804be21d56SDavid Gibson (HTAB_SIZE(spapr) / HASH_PTE_SIZE_64)) { 19814be21d56SDavid Gibson /* Bad index in stream */ 198298a5d100SDavid Gibson error_report( 198398a5d100SDavid Gibson "htab_load() bad index %d (%hd+%hd entries) in htab stream (htab_shift=%d)", 198498a5d100SDavid Gibson index, n_valid, n_invalid, spapr->htab_shift); 19854be21d56SDavid Gibson return -EINVAL; 19864be21d56SDavid Gibson } 19874be21d56SDavid Gibson 1988e68cb8b4SAlexey Kardashevskiy if (spapr->htab) { 19894be21d56SDavid Gibson if (n_valid) { 19904be21d56SDavid Gibson qemu_get_buffer(f, HPTE(spapr->htab, index), 19914be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_valid); 19924be21d56SDavid Gibson } 19934be21d56SDavid Gibson if (n_invalid) { 19944be21d56SDavid Gibson memset(HPTE(spapr->htab, index + n_valid), 0, 19954be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_invalid); 19964be21d56SDavid Gibson } 1997e68cb8b4SAlexey Kardashevskiy } else { 1998e68cb8b4SAlexey Kardashevskiy int rc; 1999e68cb8b4SAlexey Kardashevskiy 2000e68cb8b4SAlexey Kardashevskiy assert(fd >= 0); 2001e68cb8b4SAlexey Kardashevskiy 2002e68cb8b4SAlexey Kardashevskiy rc = kvmppc_load_htab_chunk(f, fd, index, n_valid, n_invalid); 2003e68cb8b4SAlexey Kardashevskiy if (rc < 0) { 2004e68cb8b4SAlexey Kardashevskiy return rc; 2005e68cb8b4SAlexey Kardashevskiy } 2006e68cb8b4SAlexey Kardashevskiy } 2007e68cb8b4SAlexey Kardashevskiy } 2008e68cb8b4SAlexey Kardashevskiy 2009e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 2010e68cb8b4SAlexey Kardashevskiy assert(fd >= 0); 2011e68cb8b4SAlexey Kardashevskiy close(fd); 20124be21d56SDavid Gibson } 20134be21d56SDavid Gibson 20144be21d56SDavid Gibson return 0; 20154be21d56SDavid Gibson } 20164be21d56SDavid Gibson 201770f794fcSJuan Quintela static void htab_save_cleanup(void *opaque) 2018c573fc03SThomas Huth { 2019c573fc03SThomas Huth sPAPRMachineState *spapr = opaque; 2020c573fc03SThomas Huth 2021c573fc03SThomas Huth close_htab_fd(spapr); 2022c573fc03SThomas Huth } 2023c573fc03SThomas Huth 20244be21d56SDavid Gibson static SaveVMHandlers savevm_htab_handlers = { 20259907e842SJuan Quintela .save_setup = htab_save_setup, 20264be21d56SDavid Gibson .save_live_iterate = htab_save_iterate, 2027a3e06c3dSDr. David Alan Gilbert .save_live_complete_precopy = htab_save_complete, 202870f794fcSJuan Quintela .save_cleanup = htab_save_cleanup, 20294be21d56SDavid Gibson .load_state = htab_load, 20304be21d56SDavid Gibson }; 20314be21d56SDavid Gibson 20325b2128d2SAlexander Graf static void spapr_boot_set(void *opaque, const char *boot_device, 20335b2128d2SAlexander Graf Error **errp) 20345b2128d2SAlexander Graf { 20355b2128d2SAlexander Graf MachineState *machine = MACHINE(qdev_get_machine()); 20365b2128d2SAlexander Graf machine->boot_order = g_strdup(boot_device); 20375b2128d2SAlexander Graf } 20385b2128d2SAlexander Graf 2039224245bfSDavid Gibson static void spapr_create_lmb_dr_connectors(sPAPRMachineState *spapr) 2040224245bfSDavid Gibson { 2041224245bfSDavid Gibson MachineState *machine = MACHINE(spapr); 2042224245bfSDavid Gibson uint64_t lmb_size = SPAPR_MEMORY_BLOCK_SIZE; 2043e8f986fcSBharata B Rao uint32_t nr_lmbs = (machine->maxram_size - machine->ram_size)/lmb_size; 2044224245bfSDavid Gibson int i; 2045224245bfSDavid Gibson 2046224245bfSDavid Gibson for (i = 0; i < nr_lmbs; i++) { 2047224245bfSDavid Gibson uint64_t addr; 2048224245bfSDavid Gibson 2049e8f986fcSBharata B Rao addr = i * lmb_size + spapr->hotplug_memory.base; 20506caf3ac6SDavid Gibson spapr_dr_connector_new(OBJECT(spapr), TYPE_SPAPR_DRC_LMB, 2051224245bfSDavid Gibson addr / lmb_size); 2052224245bfSDavid Gibson } 2053224245bfSDavid Gibson } 2054224245bfSDavid Gibson 2055224245bfSDavid Gibson /* 2056224245bfSDavid Gibson * If RAM size, maxmem size and individual node mem sizes aren't aligned 2057224245bfSDavid Gibson * to SPAPR_MEMORY_BLOCK_SIZE(256MB), then refuse to start the guest 2058224245bfSDavid Gibson * since we can't support such unaligned sizes with DRCONF_MEMORY. 2059224245bfSDavid Gibson */ 20607c150d6fSDavid Gibson static void spapr_validate_node_memory(MachineState *machine, Error **errp) 2061224245bfSDavid Gibson { 2062224245bfSDavid Gibson int i; 2063224245bfSDavid Gibson 20647c150d6fSDavid Gibson if (machine->ram_size % SPAPR_MEMORY_BLOCK_SIZE) { 20657c150d6fSDavid Gibson error_setg(errp, "Memory size 0x" RAM_ADDR_FMT 20667c150d6fSDavid Gibson " is not aligned to %llu MiB", 20677c150d6fSDavid Gibson machine->ram_size, 2068224245bfSDavid Gibson SPAPR_MEMORY_BLOCK_SIZE / M_BYTE); 20697c150d6fSDavid Gibson return; 20707c150d6fSDavid Gibson } 20717c150d6fSDavid Gibson 20727c150d6fSDavid Gibson if (machine->maxram_size % SPAPR_MEMORY_BLOCK_SIZE) { 20737c150d6fSDavid Gibson error_setg(errp, "Maximum memory size 0x" RAM_ADDR_FMT 20747c150d6fSDavid Gibson " is not aligned to %llu MiB", 20757c150d6fSDavid Gibson machine->ram_size, 20767c150d6fSDavid Gibson SPAPR_MEMORY_BLOCK_SIZE / M_BYTE); 20777c150d6fSDavid Gibson return; 2078224245bfSDavid Gibson } 2079224245bfSDavid Gibson 2080224245bfSDavid Gibson for (i = 0; i < nb_numa_nodes; i++) { 2081224245bfSDavid Gibson if (numa_info[i].node_mem % SPAPR_MEMORY_BLOCK_SIZE) { 20827c150d6fSDavid Gibson error_setg(errp, 20837c150d6fSDavid Gibson "Node %d memory size 0x%" PRIx64 20847c150d6fSDavid Gibson " is not aligned to %llu MiB", 20857c150d6fSDavid Gibson i, numa_info[i].node_mem, 2086224245bfSDavid Gibson SPAPR_MEMORY_BLOCK_SIZE / M_BYTE); 20877c150d6fSDavid Gibson return; 2088224245bfSDavid Gibson } 2089224245bfSDavid Gibson } 2090224245bfSDavid Gibson } 2091224245bfSDavid Gibson 2092535455fdSIgor Mammedov /* find cpu slot in machine->possible_cpus by core_id */ 2093535455fdSIgor Mammedov static CPUArchId *spapr_find_cpu_slot(MachineState *ms, uint32_t id, int *idx) 2094535455fdSIgor Mammedov { 2095535455fdSIgor Mammedov int index = id / smp_threads; 2096535455fdSIgor Mammedov 2097535455fdSIgor Mammedov if (index >= ms->possible_cpus->len) { 2098535455fdSIgor Mammedov return NULL; 2099535455fdSIgor Mammedov } 2100535455fdSIgor Mammedov if (idx) { 2101535455fdSIgor Mammedov *idx = index; 2102535455fdSIgor Mammedov } 2103535455fdSIgor Mammedov return &ms->possible_cpus->cpus[index]; 2104535455fdSIgor Mammedov } 2105535455fdSIgor Mammedov 21060c86d0fdSDavid Gibson static void spapr_init_cpus(sPAPRMachineState *spapr) 21070c86d0fdSDavid Gibson { 21080c86d0fdSDavid Gibson MachineState *machine = MACHINE(spapr); 21090c86d0fdSDavid Gibson MachineClass *mc = MACHINE_GET_CLASS(machine); 21100c86d0fdSDavid Gibson char *type = spapr_get_cpu_core_type(machine->cpu_model); 21110c86d0fdSDavid Gibson int smt = kvmppc_smt_threads(); 2112535455fdSIgor Mammedov const CPUArchIdList *possible_cpus; 2113535455fdSIgor Mammedov int boot_cores_nr = smp_cpus / smp_threads; 21140c86d0fdSDavid Gibson int i; 21150c86d0fdSDavid Gibson 21160c86d0fdSDavid Gibson if (!type) { 21170c86d0fdSDavid Gibson error_report("Unable to find sPAPR CPU Core definition"); 21180c86d0fdSDavid Gibson exit(1); 21190c86d0fdSDavid Gibson } 21200c86d0fdSDavid Gibson 2121535455fdSIgor Mammedov possible_cpus = mc->possible_cpu_arch_ids(machine); 2122c5514d0eSIgor Mammedov if (mc->has_hotpluggable_cpus) { 21230c86d0fdSDavid Gibson if (smp_cpus % smp_threads) { 21240c86d0fdSDavid Gibson error_report("smp_cpus (%u) must be multiple of threads (%u)", 21250c86d0fdSDavid Gibson smp_cpus, smp_threads); 21260c86d0fdSDavid Gibson exit(1); 21270c86d0fdSDavid Gibson } 21280c86d0fdSDavid Gibson if (max_cpus % smp_threads) { 21290c86d0fdSDavid Gibson error_report("max_cpus (%u) must be multiple of threads (%u)", 21300c86d0fdSDavid Gibson max_cpus, smp_threads); 21310c86d0fdSDavid Gibson exit(1); 21320c86d0fdSDavid Gibson } 21330c86d0fdSDavid Gibson } else { 21340c86d0fdSDavid Gibson if (max_cpus != smp_cpus) { 21350c86d0fdSDavid Gibson error_report("This machine version does not support CPU hotplug"); 21360c86d0fdSDavid Gibson exit(1); 21370c86d0fdSDavid Gibson } 2138535455fdSIgor Mammedov boot_cores_nr = possible_cpus->len; 21390c86d0fdSDavid Gibson } 21400c86d0fdSDavid Gibson 2141535455fdSIgor Mammedov for (i = 0; i < possible_cpus->len; i++) { 21420c86d0fdSDavid Gibson int core_id = i * smp_threads; 21430c86d0fdSDavid Gibson 2144c5514d0eSIgor Mammedov if (mc->has_hotpluggable_cpus) { 21452d335818SDavid Gibson spapr_dr_connector_new(OBJECT(spapr), TYPE_SPAPR_DRC_CPU, 21460c86d0fdSDavid Gibson (core_id / smp_threads) * smt); 21470c86d0fdSDavid Gibson } 21480c86d0fdSDavid Gibson 2149535455fdSIgor Mammedov if (i < boot_cores_nr) { 21500c86d0fdSDavid Gibson Object *core = object_new(type); 21510c86d0fdSDavid Gibson int nr_threads = smp_threads; 21520c86d0fdSDavid Gibson 21530c86d0fdSDavid Gibson /* Handle the partially filled core for older machine types */ 21540c86d0fdSDavid Gibson if ((i + 1) * smp_threads >= smp_cpus) { 21550c86d0fdSDavid Gibson nr_threads = smp_cpus - i * smp_threads; 21560c86d0fdSDavid Gibson } 21570c86d0fdSDavid Gibson 21580c86d0fdSDavid Gibson object_property_set_int(core, nr_threads, "nr-threads", 21590c86d0fdSDavid Gibson &error_fatal); 21600c86d0fdSDavid Gibson object_property_set_int(core, core_id, CPU_CORE_PROP_CORE_ID, 21610c86d0fdSDavid Gibson &error_fatal); 21620c86d0fdSDavid Gibson object_property_set_bool(core, true, "realized", &error_fatal); 21630c86d0fdSDavid Gibson } 21640c86d0fdSDavid Gibson } 21650c86d0fdSDavid Gibson g_free(type); 21660c86d0fdSDavid Gibson } 21670c86d0fdSDavid Gibson 216853018216SPaolo Bonzini /* pSeries LPAR / sPAPR hardware init */ 21693ef96221SMarcel Apfelbaum static void ppc_spapr_init(MachineState *machine) 217053018216SPaolo Bonzini { 217128e02042SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(machine); 2172224245bfSDavid Gibson sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(machine); 21733ef96221SMarcel Apfelbaum const char *kernel_filename = machine->kernel_filename; 21743ef96221SMarcel Apfelbaum const char *initrd_filename = machine->initrd_filename; 217553018216SPaolo Bonzini PCIHostState *phb; 217653018216SPaolo Bonzini int i; 217753018216SPaolo Bonzini MemoryRegion *sysmem = get_system_memory(); 217853018216SPaolo Bonzini MemoryRegion *ram = g_new(MemoryRegion, 1); 2179658fa66bSAlexey Kardashevskiy MemoryRegion *rma_region; 2180658fa66bSAlexey Kardashevskiy void *rma = NULL; 218153018216SPaolo Bonzini hwaddr rma_alloc_size; 2182b082d65aSAlexey Kardashevskiy hwaddr node0_size = spapr_node0_size(); 2183b7d1f77aSBenjamin Herrenschmidt long load_limit, fw_size; 218453018216SPaolo Bonzini char *filename; 218530f4b05bSDavid Gibson Error *resize_hpt_err = NULL; 218653018216SPaolo Bonzini 2187226419d6SMichael S. Tsirkin msi_nonbroken = true; 218853018216SPaolo Bonzini 218953018216SPaolo Bonzini QLIST_INIT(&spapr->phbs); 21900cffce56SDavid Gibson QTAILQ_INIT(&spapr->pending_dimm_unplugs); 219153018216SPaolo Bonzini 219230f4b05bSDavid Gibson /* Check HPT resizing availability */ 219330f4b05bSDavid Gibson kvmppc_check_papr_resize_hpt(&resize_hpt_err); 219430f4b05bSDavid Gibson if (spapr->resize_hpt == SPAPR_RESIZE_HPT_DEFAULT) { 219530f4b05bSDavid Gibson /* 219630f4b05bSDavid Gibson * If the user explicitly requested a mode we should either 219730f4b05bSDavid Gibson * supply it, or fail completely (which we do below). But if 219830f4b05bSDavid Gibson * it's not set explicitly, we reset our mode to something 219930f4b05bSDavid Gibson * that works 220030f4b05bSDavid Gibson */ 220130f4b05bSDavid Gibson if (resize_hpt_err) { 220230f4b05bSDavid Gibson spapr->resize_hpt = SPAPR_RESIZE_HPT_DISABLED; 220330f4b05bSDavid Gibson error_free(resize_hpt_err); 220430f4b05bSDavid Gibson resize_hpt_err = NULL; 220530f4b05bSDavid Gibson } else { 220630f4b05bSDavid Gibson spapr->resize_hpt = smc->resize_hpt_default; 220730f4b05bSDavid Gibson } 220830f4b05bSDavid Gibson } 220930f4b05bSDavid Gibson 221030f4b05bSDavid Gibson assert(spapr->resize_hpt != SPAPR_RESIZE_HPT_DEFAULT); 221130f4b05bSDavid Gibson 221230f4b05bSDavid Gibson if ((spapr->resize_hpt != SPAPR_RESIZE_HPT_DISABLED) && resize_hpt_err) { 221330f4b05bSDavid Gibson /* 221430f4b05bSDavid Gibson * User requested HPT resize, but this host can't supply it. Bail out 221530f4b05bSDavid Gibson */ 221630f4b05bSDavid Gibson error_report_err(resize_hpt_err); 221730f4b05bSDavid Gibson exit(1); 221830f4b05bSDavid Gibson } 221930f4b05bSDavid Gibson 222053018216SPaolo Bonzini /* Allocate RMA if necessary */ 2221658fa66bSAlexey Kardashevskiy rma_alloc_size = kvmppc_alloc_rma(&rma); 222253018216SPaolo Bonzini 222353018216SPaolo Bonzini if (rma_alloc_size == -1) { 2224730fce59SThomas Huth error_report("Unable to create RMA"); 222553018216SPaolo Bonzini exit(1); 222653018216SPaolo Bonzini } 222753018216SPaolo Bonzini 2228c4177479SAlexey Kardashevskiy if (rma_alloc_size && (rma_alloc_size < node0_size)) { 222953018216SPaolo Bonzini spapr->rma_size = rma_alloc_size; 223053018216SPaolo Bonzini } else { 2231c4177479SAlexey Kardashevskiy spapr->rma_size = node0_size; 223253018216SPaolo Bonzini 223353018216SPaolo Bonzini /* With KVM, we don't actually know whether KVM supports an 223453018216SPaolo Bonzini * unbounded RMA (PR KVM) or is limited by the hash table size 223553018216SPaolo Bonzini * (HV KVM using VRMA), so we always assume the latter 223653018216SPaolo Bonzini * 223753018216SPaolo Bonzini * In that case, we also limit the initial allocations for RTAS 223853018216SPaolo Bonzini * etc... to 256M since we have no way to know what the VRMA size 223953018216SPaolo Bonzini * is going to be as it depends on the size of the hash table 224053018216SPaolo Bonzini * isn't determined yet. 224153018216SPaolo Bonzini */ 224253018216SPaolo Bonzini if (kvm_enabled()) { 224353018216SPaolo Bonzini spapr->vrma_adjust = 1; 224453018216SPaolo Bonzini spapr->rma_size = MIN(spapr->rma_size, 0x10000000); 224553018216SPaolo Bonzini } 2246912acdf4SBenjamin Herrenschmidt 2247912acdf4SBenjamin Herrenschmidt /* Actually we don't support unbounded RMA anymore since we 2248912acdf4SBenjamin Herrenschmidt * added proper emulation of HV mode. The max we can get is 2249912acdf4SBenjamin Herrenschmidt * 16G which also happens to be what we configure for PAPR 2250912acdf4SBenjamin Herrenschmidt * mode so make sure we don't do anything bigger than that 2251912acdf4SBenjamin Herrenschmidt */ 2252912acdf4SBenjamin Herrenschmidt spapr->rma_size = MIN(spapr->rma_size, 0x400000000ull); 225353018216SPaolo Bonzini } 225453018216SPaolo Bonzini 2255c4177479SAlexey Kardashevskiy if (spapr->rma_size > node0_size) { 2256d54e4d76SDavid Gibson error_report("Numa node 0 has to span the RMA (%#08"HWADDR_PRIx")", 2257c4177479SAlexey Kardashevskiy spapr->rma_size); 2258c4177479SAlexey Kardashevskiy exit(1); 2259c4177479SAlexey Kardashevskiy } 2260c4177479SAlexey Kardashevskiy 2261b7d1f77aSBenjamin Herrenschmidt /* Setup a load limit for the ramdisk leaving room for SLOF and FDT */ 2262b7d1f77aSBenjamin Herrenschmidt load_limit = MIN(spapr->rma_size, RTAS_MAX_ADDR) - FW_OVERHEAD; 226353018216SPaolo Bonzini 22647b565160SDavid Gibson /* Set up Interrupt Controller before we create the VCPUs */ 226571cd4dacSCédric Le Goater xics_system_init(machine, XICS_IRQS_SPAPR, &error_fatal); 22667b565160SDavid Gibson 2267facdb8b6SMichael Roth /* Set up containers for ibm,client-set-architecture negotiated options */ 2268facdb8b6SMichael Roth spapr->ov5 = spapr_ovec_new(); 2269facdb8b6SMichael Roth spapr->ov5_cas = spapr_ovec_new(); 2270facdb8b6SMichael Roth 2271224245bfSDavid Gibson if (smc->dr_lmb_enabled) { 2272facdb8b6SMichael Roth spapr_ovec_set(spapr->ov5, OV5_DRCONF_MEMORY); 22737c150d6fSDavid Gibson spapr_validate_node_memory(machine, &error_fatal); 2274224245bfSDavid Gibson } 2275224245bfSDavid Gibson 2276417ece33SMichael Roth spapr_ovec_set(spapr->ov5, OV5_FORM1_AFFINITY); 2277545d6e2bSSuraj Jitindar Singh if (!kvm_enabled() || kvmppc_has_cap_mmu_radix()) { 2278545d6e2bSSuraj Jitindar Singh /* KVM and TCG always allow GTSE with radix... */ 22799fb4541fSSam Bobroff spapr_ovec_set(spapr->ov5, OV5_MMU_RADIX_GTSE); 22809fb4541fSSam Bobroff } 22819fb4541fSSam Bobroff /* ... but not with hash (currently). */ 2282417ece33SMichael Roth 2283ffbb1705SMichael Roth /* advertise support for dedicated HP event source to guests */ 2284ffbb1705SMichael Roth if (spapr->use_hotplug_event_source) { 2285ffbb1705SMichael Roth spapr_ovec_set(spapr->ov5, OV5_HP_EVT); 2286ffbb1705SMichael Roth } 2287ffbb1705SMichael Roth 22882772cf6bSDavid Gibson /* advertise support for HPT resizing */ 22892772cf6bSDavid Gibson if (spapr->resize_hpt != SPAPR_RESIZE_HPT_DISABLED) { 22902772cf6bSDavid Gibson spapr_ovec_set(spapr->ov5, OV5_HPT_RESIZE); 22912772cf6bSDavid Gibson } 22922772cf6bSDavid Gibson 229353018216SPaolo Bonzini /* init CPUs */ 229419fb2c36SBharata B Rao if (machine->cpu_model == NULL) { 22953daa4a9fSThomas Huth machine->cpu_model = kvm_enabled() ? "host" : smc->tcg_default_cpu; 229653018216SPaolo Bonzini } 229794a94e4cSBharata B Rao 22987843c0d6SDavid Gibson spapr_cpu_parse_features(spapr); 2299e703d2f7SGreg Kurz 23000c86d0fdSDavid Gibson spapr_init_cpus(spapr); 230153018216SPaolo Bonzini 2302026bfd89SDavid Gibson if (kvm_enabled()) { 2303026bfd89SDavid Gibson /* Enable H_LOGICAL_CI_* so SLOF can talk to in-kernel devices */ 2304026bfd89SDavid Gibson kvmppc_enable_logical_ci_hcalls(); 2305ef9971ddSAlexey Kardashevskiy kvmppc_enable_set_mode_hcall(); 23065145ad4fSNathan Whitehorn 23075145ad4fSNathan Whitehorn /* H_CLEAR_MOD/_REF are mandatory in PAPR, but off by default */ 23085145ad4fSNathan Whitehorn kvmppc_enable_clear_ref_mod_hcalls(); 2309026bfd89SDavid Gibson } 2310026bfd89SDavid Gibson 231153018216SPaolo Bonzini /* allocate RAM */ 2312f92f5da1SAlexey Kardashevskiy memory_region_allocate_system_memory(ram, NULL, "ppc_spapr.ram", 2313fb164994SDavid Gibson machine->ram_size); 2314f92f5da1SAlexey Kardashevskiy memory_region_add_subregion(sysmem, 0, ram); 231553018216SPaolo Bonzini 2316658fa66bSAlexey Kardashevskiy if (rma_alloc_size && rma) { 2317658fa66bSAlexey Kardashevskiy rma_region = g_new(MemoryRegion, 1); 2318658fa66bSAlexey Kardashevskiy memory_region_init_ram_ptr(rma_region, NULL, "ppc_spapr.rma", 2319658fa66bSAlexey Kardashevskiy rma_alloc_size, rma); 2320658fa66bSAlexey Kardashevskiy vmstate_register_ram_global(rma_region); 2321658fa66bSAlexey Kardashevskiy memory_region_add_subregion(sysmem, 0, rma_region); 2322658fa66bSAlexey Kardashevskiy } 2323658fa66bSAlexey Kardashevskiy 23244a1c9cf0SBharata B Rao /* initialize hotplug memory address space */ 23254a1c9cf0SBharata B Rao if (machine->ram_size < machine->maxram_size) { 23264a1c9cf0SBharata B Rao ram_addr_t hotplug_mem_size = machine->maxram_size - machine->ram_size; 232771c9a3ddSBharata B Rao /* 232871c9a3ddSBharata B Rao * Limit the number of hotpluggable memory slots to half the number 232971c9a3ddSBharata B Rao * slots that KVM supports, leaving the other half for PCI and other 233071c9a3ddSBharata B Rao * devices. However ensure that number of slots doesn't drop below 32. 233171c9a3ddSBharata B Rao */ 233271c9a3ddSBharata B Rao int max_memslots = kvm_enabled() ? kvm_get_max_memslots() / 2 : 233371c9a3ddSBharata B Rao SPAPR_MAX_RAM_SLOTS; 23344a1c9cf0SBharata B Rao 233571c9a3ddSBharata B Rao if (max_memslots < SPAPR_MAX_RAM_SLOTS) { 233671c9a3ddSBharata B Rao max_memslots = SPAPR_MAX_RAM_SLOTS; 233771c9a3ddSBharata B Rao } 233871c9a3ddSBharata B Rao if (machine->ram_slots > max_memslots) { 2339d54e4d76SDavid Gibson error_report("Specified number of memory slots %" 2340d54e4d76SDavid Gibson PRIu64" exceeds max supported %d", 234171c9a3ddSBharata B Rao machine->ram_slots, max_memslots); 2342d54e4d76SDavid Gibson exit(1); 23434a1c9cf0SBharata B Rao } 23444a1c9cf0SBharata B Rao 23454a1c9cf0SBharata B Rao spapr->hotplug_memory.base = ROUND_UP(machine->ram_size, 23464a1c9cf0SBharata B Rao SPAPR_HOTPLUG_MEM_ALIGN); 23474a1c9cf0SBharata B Rao memory_region_init(&spapr->hotplug_memory.mr, OBJECT(spapr), 23484a1c9cf0SBharata B Rao "hotplug-memory", hotplug_mem_size); 23494a1c9cf0SBharata B Rao memory_region_add_subregion(sysmem, spapr->hotplug_memory.base, 23504a1c9cf0SBharata B Rao &spapr->hotplug_memory.mr); 23514a1c9cf0SBharata B Rao } 23524a1c9cf0SBharata B Rao 2353224245bfSDavid Gibson if (smc->dr_lmb_enabled) { 2354224245bfSDavid Gibson spapr_create_lmb_dr_connectors(spapr); 2355224245bfSDavid Gibson } 2356224245bfSDavid Gibson 235753018216SPaolo Bonzini filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, "spapr-rtas.bin"); 23584c56440dSStefan Weil if (!filename) { 2359730fce59SThomas Huth error_report("Could not find LPAR rtas '%s'", "spapr-rtas.bin"); 23604c56440dSStefan Weil exit(1); 23614c56440dSStefan Weil } 2362b7d1f77aSBenjamin Herrenschmidt spapr->rtas_size = get_image_size(filename); 23638afc22a2SZhou Jie if (spapr->rtas_size < 0) { 23648afc22a2SZhou Jie error_report("Could not get size of LPAR rtas '%s'", filename); 23658afc22a2SZhou Jie exit(1); 23668afc22a2SZhou Jie } 2367b7d1f77aSBenjamin Herrenschmidt spapr->rtas_blob = g_malloc(spapr->rtas_size); 2368b7d1f77aSBenjamin Herrenschmidt if (load_image_size(filename, spapr->rtas_blob, spapr->rtas_size) < 0) { 2369730fce59SThomas Huth error_report("Could not load LPAR rtas '%s'", filename); 237053018216SPaolo Bonzini exit(1); 237153018216SPaolo Bonzini } 237253018216SPaolo Bonzini if (spapr->rtas_size > RTAS_MAX_SIZE) { 2373730fce59SThomas Huth error_report("RTAS too big ! 0x%zx bytes (max is 0x%x)", 23742f285bddSPeter Maydell (size_t)spapr->rtas_size, RTAS_MAX_SIZE); 237553018216SPaolo Bonzini exit(1); 237653018216SPaolo Bonzini } 237753018216SPaolo Bonzini g_free(filename); 237853018216SPaolo Bonzini 2379ffbb1705SMichael Roth /* Set up RTAS event infrastructure */ 238053018216SPaolo Bonzini spapr_events_init(spapr); 238153018216SPaolo Bonzini 238212f42174SDavid Gibson /* Set up the RTC RTAS interfaces */ 238328df36a1SDavid Gibson spapr_rtc_create(spapr); 238412f42174SDavid Gibson 238553018216SPaolo Bonzini /* Set up VIO bus */ 238653018216SPaolo Bonzini spapr->vio_bus = spapr_vio_bus_init(); 238753018216SPaolo Bonzini 238853018216SPaolo Bonzini for (i = 0; i < MAX_SERIAL_PORTS; i++) { 238953018216SPaolo Bonzini if (serial_hds[i]) { 239053018216SPaolo Bonzini spapr_vty_create(spapr->vio_bus, serial_hds[i]); 239153018216SPaolo Bonzini } 239253018216SPaolo Bonzini } 239353018216SPaolo Bonzini 239453018216SPaolo Bonzini /* We always have at least the nvram device on VIO */ 239553018216SPaolo Bonzini spapr_create_nvram(spapr); 239653018216SPaolo Bonzini 239753018216SPaolo Bonzini /* Set up PCI */ 239853018216SPaolo Bonzini spapr_pci_rtas_init(); 239953018216SPaolo Bonzini 240089dfd6e1SDavid Gibson phb = spapr_create_phb(spapr, 0); 240153018216SPaolo Bonzini 240253018216SPaolo Bonzini for (i = 0; i < nb_nics; i++) { 240353018216SPaolo Bonzini NICInfo *nd = &nd_table[i]; 240453018216SPaolo Bonzini 240553018216SPaolo Bonzini if (!nd->model) { 240653018216SPaolo Bonzini nd->model = g_strdup("ibmveth"); 240753018216SPaolo Bonzini } 240853018216SPaolo Bonzini 240953018216SPaolo Bonzini if (strcmp(nd->model, "ibmveth") == 0) { 241053018216SPaolo Bonzini spapr_vlan_create(spapr->vio_bus, nd); 241153018216SPaolo Bonzini } else { 241229b358f9SDavid Gibson pci_nic_init_nofail(&nd_table[i], phb->bus, nd->model, NULL); 241353018216SPaolo Bonzini } 241453018216SPaolo Bonzini } 241553018216SPaolo Bonzini 241653018216SPaolo Bonzini for (i = 0; i <= drive_get_max_bus(IF_SCSI); i++) { 241753018216SPaolo Bonzini spapr_vscsi_create(spapr->vio_bus); 241853018216SPaolo Bonzini } 241953018216SPaolo Bonzini 242053018216SPaolo Bonzini /* Graphics */ 242114c6a894SDavid Gibson if (spapr_vga_init(phb->bus, &error_fatal)) { 242253018216SPaolo Bonzini spapr->has_graphics = true; 2423c6e76503SPaolo Bonzini machine->usb |= defaults_enabled() && !machine->usb_disabled; 242453018216SPaolo Bonzini } 242553018216SPaolo Bonzini 24264ee9ced9SMarcel Apfelbaum if (machine->usb) { 242757040d45SThomas Huth if (smc->use_ohci_by_default) { 242853018216SPaolo Bonzini pci_create_simple(phb->bus, -1, "pci-ohci"); 242957040d45SThomas Huth } else { 243057040d45SThomas Huth pci_create_simple(phb->bus, -1, "nec-usb-xhci"); 243157040d45SThomas Huth } 2432c86580b8SMarkus Armbruster 243353018216SPaolo Bonzini if (spapr->has_graphics) { 2434c86580b8SMarkus Armbruster USBBus *usb_bus = usb_bus_find(-1); 2435c86580b8SMarkus Armbruster 2436c86580b8SMarkus Armbruster usb_create_simple(usb_bus, "usb-kbd"); 2437c86580b8SMarkus Armbruster usb_create_simple(usb_bus, "usb-mouse"); 243853018216SPaolo Bonzini } 243953018216SPaolo Bonzini } 244053018216SPaolo Bonzini 244153018216SPaolo Bonzini if (spapr->rma_size < (MIN_RMA_SLOF << 20)) { 2442d54e4d76SDavid Gibson error_report( 2443d54e4d76SDavid Gibson "pSeries SLOF firmware requires >= %ldM guest RMA (Real Mode Area memory)", 2444d54e4d76SDavid Gibson MIN_RMA_SLOF); 244553018216SPaolo Bonzini exit(1); 244653018216SPaolo Bonzini } 244753018216SPaolo Bonzini 244853018216SPaolo Bonzini if (kernel_filename) { 244953018216SPaolo Bonzini uint64_t lowaddr = 0; 245053018216SPaolo Bonzini 2451a19f7fb0SDavid Gibson spapr->kernel_size = load_elf(kernel_filename, translate_kernel_address, 2452a19f7fb0SDavid Gibson NULL, NULL, &lowaddr, NULL, 1, 2453a19f7fb0SDavid Gibson PPC_ELF_MACHINE, 0, 0); 2454a19f7fb0SDavid Gibson if (spapr->kernel_size == ELF_LOAD_WRONG_ENDIAN) { 2455a19f7fb0SDavid Gibson spapr->kernel_size = load_elf(kernel_filename, 2456a19f7fb0SDavid Gibson translate_kernel_address, NULL, NULL, 2457a19f7fb0SDavid Gibson &lowaddr, NULL, 0, PPC_ELF_MACHINE, 24587ef295eaSPeter Crosthwaite 0, 0); 2459a19f7fb0SDavid Gibson spapr->kernel_le = spapr->kernel_size > 0; 246016457e7fSBenjamin Herrenschmidt } 2461a19f7fb0SDavid Gibson if (spapr->kernel_size < 0) { 2462a19f7fb0SDavid Gibson error_report("error loading %s: %s", kernel_filename, 2463a19f7fb0SDavid Gibson load_elf_strerror(spapr->kernel_size)); 246453018216SPaolo Bonzini exit(1); 246553018216SPaolo Bonzini } 246653018216SPaolo Bonzini 246753018216SPaolo Bonzini /* load initrd */ 246853018216SPaolo Bonzini if (initrd_filename) { 246953018216SPaolo Bonzini /* Try to locate the initrd in the gap between the kernel 247053018216SPaolo Bonzini * and the firmware. Add a bit of space just in case 247153018216SPaolo Bonzini */ 2472a19f7fb0SDavid Gibson spapr->initrd_base = (KERNEL_LOAD_ADDR + spapr->kernel_size 2473a19f7fb0SDavid Gibson + 0x1ffff) & ~0xffff; 2474a19f7fb0SDavid Gibson spapr->initrd_size = load_image_targphys(initrd_filename, 2475a19f7fb0SDavid Gibson spapr->initrd_base, 2476a19f7fb0SDavid Gibson load_limit 2477a19f7fb0SDavid Gibson - spapr->initrd_base); 2478a19f7fb0SDavid Gibson if (spapr->initrd_size < 0) { 2479d54e4d76SDavid Gibson error_report("could not load initial ram disk '%s'", 248053018216SPaolo Bonzini initrd_filename); 248153018216SPaolo Bonzini exit(1); 248253018216SPaolo Bonzini } 248353018216SPaolo Bonzini } 248453018216SPaolo Bonzini } 248553018216SPaolo Bonzini 24868e7ea787SAndreas Färber if (bios_name == NULL) { 24878e7ea787SAndreas Färber bios_name = FW_FILE_NAME; 24888e7ea787SAndreas Färber } 24898e7ea787SAndreas Färber filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name); 24904c56440dSStefan Weil if (!filename) { 249168fea5a0SThomas Huth error_report("Could not find LPAR firmware '%s'", bios_name); 24924c56440dSStefan Weil exit(1); 24934c56440dSStefan Weil } 249453018216SPaolo Bonzini fw_size = load_image_targphys(filename, 0, FW_MAX_SIZE); 249568fea5a0SThomas Huth if (fw_size <= 0) { 249668fea5a0SThomas Huth error_report("Could not load LPAR firmware '%s'", filename); 249753018216SPaolo Bonzini exit(1); 249853018216SPaolo Bonzini } 249953018216SPaolo Bonzini g_free(filename); 250053018216SPaolo Bonzini 250128e02042SDavid Gibson /* FIXME: Should register things through the MachineState's qdev 250228e02042SDavid Gibson * interface, this is a legacy from the sPAPREnvironment structure 250328e02042SDavid Gibson * which predated MachineState but had a similar function */ 25044be21d56SDavid Gibson vmstate_register(NULL, 0, &vmstate_spapr, spapr); 25054be21d56SDavid Gibson register_savevm_live(NULL, "spapr/htab", -1, 1, 25064be21d56SDavid Gibson &savevm_htab_handlers, spapr); 25074be21d56SDavid Gibson 25085b2128d2SAlexander Graf qemu_register_boot_set(spapr_boot_set, spapr); 250942043e4fSLaurent Vivier 251042043e4fSLaurent Vivier if (kvm_enabled()) { 25113dc410aeSAlexey Kardashevskiy /* to stop and start vmclock */ 251242043e4fSLaurent Vivier qemu_add_vm_change_state_handler(cpu_ppc_clock_vm_state_change, 251342043e4fSLaurent Vivier &spapr->tb); 25143dc410aeSAlexey Kardashevskiy 25153dc410aeSAlexey Kardashevskiy kvmppc_spapr_enable_inkernel_multitce(); 251642043e4fSLaurent Vivier } 251753018216SPaolo Bonzini } 251853018216SPaolo Bonzini 2519135a129aSAneesh Kumar K.V static int spapr_kvm_type(const char *vm_type) 2520135a129aSAneesh Kumar K.V { 2521135a129aSAneesh Kumar K.V if (!vm_type) { 2522135a129aSAneesh Kumar K.V return 0; 2523135a129aSAneesh Kumar K.V } 2524135a129aSAneesh Kumar K.V 2525135a129aSAneesh Kumar K.V if (!strcmp(vm_type, "HV")) { 2526135a129aSAneesh Kumar K.V return 1; 2527135a129aSAneesh Kumar K.V } 2528135a129aSAneesh Kumar K.V 2529135a129aSAneesh Kumar K.V if (!strcmp(vm_type, "PR")) { 2530135a129aSAneesh Kumar K.V return 2; 2531135a129aSAneesh Kumar K.V } 2532135a129aSAneesh Kumar K.V 2533135a129aSAneesh Kumar K.V error_report("Unknown kvm-type specified '%s'", vm_type); 2534135a129aSAneesh Kumar K.V exit(1); 2535135a129aSAneesh Kumar K.V } 2536135a129aSAneesh Kumar K.V 253771461b0fSAlexey Kardashevskiy /* 2538627b84f4SGonglei * Implementation of an interface to adjust firmware path 253971461b0fSAlexey Kardashevskiy * for the bootindex property handling. 254071461b0fSAlexey Kardashevskiy */ 254171461b0fSAlexey Kardashevskiy static char *spapr_get_fw_dev_path(FWPathProvider *p, BusState *bus, 254271461b0fSAlexey Kardashevskiy DeviceState *dev) 254371461b0fSAlexey Kardashevskiy { 254471461b0fSAlexey Kardashevskiy #define CAST(type, obj, name) \ 254571461b0fSAlexey Kardashevskiy ((type *)object_dynamic_cast(OBJECT(obj), (name))) 254671461b0fSAlexey Kardashevskiy SCSIDevice *d = CAST(SCSIDevice, dev, TYPE_SCSI_DEVICE); 254771461b0fSAlexey Kardashevskiy sPAPRPHBState *phb = CAST(sPAPRPHBState, dev, TYPE_SPAPR_PCI_HOST_BRIDGE); 2548c4e13492SFelipe Franciosi VHostSCSICommon *vsc = CAST(VHostSCSICommon, dev, TYPE_VHOST_SCSI_COMMON); 254971461b0fSAlexey Kardashevskiy 255071461b0fSAlexey Kardashevskiy if (d) { 255171461b0fSAlexey Kardashevskiy void *spapr = CAST(void, bus->parent, "spapr-vscsi"); 255271461b0fSAlexey Kardashevskiy VirtIOSCSI *virtio = CAST(VirtIOSCSI, bus->parent, TYPE_VIRTIO_SCSI); 255371461b0fSAlexey Kardashevskiy USBDevice *usb = CAST(USBDevice, bus->parent, TYPE_USB_DEVICE); 255471461b0fSAlexey Kardashevskiy 255571461b0fSAlexey Kardashevskiy if (spapr) { 255671461b0fSAlexey Kardashevskiy /* 255771461b0fSAlexey Kardashevskiy * Replace "channel@0/disk@0,0" with "disk@8000000000000000": 255871461b0fSAlexey Kardashevskiy * We use SRP luns of the form 8000 | (bus << 8) | (id << 5) | lun 255971461b0fSAlexey Kardashevskiy * in the top 16 bits of the 64-bit LUN 256071461b0fSAlexey Kardashevskiy */ 256171461b0fSAlexey Kardashevskiy unsigned id = 0x8000 | (d->id << 8) | d->lun; 256271461b0fSAlexey Kardashevskiy return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev), 256371461b0fSAlexey Kardashevskiy (uint64_t)id << 48); 256471461b0fSAlexey Kardashevskiy } else if (virtio) { 256571461b0fSAlexey Kardashevskiy /* 256671461b0fSAlexey Kardashevskiy * We use SRP luns of the form 01000000 | (target << 8) | lun 256771461b0fSAlexey Kardashevskiy * in the top 32 bits of the 64-bit LUN 256871461b0fSAlexey Kardashevskiy * Note: the quote above is from SLOF and it is wrong, 256971461b0fSAlexey Kardashevskiy * the actual binding is: 257071461b0fSAlexey Kardashevskiy * swap 0100 or 10 << or 20 << ( target lun-id -- srplun ) 257171461b0fSAlexey Kardashevskiy */ 257271461b0fSAlexey Kardashevskiy unsigned id = 0x1000000 | (d->id << 16) | d->lun; 257371461b0fSAlexey Kardashevskiy return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev), 257471461b0fSAlexey Kardashevskiy (uint64_t)id << 32); 257571461b0fSAlexey Kardashevskiy } else if (usb) { 257671461b0fSAlexey Kardashevskiy /* 257771461b0fSAlexey Kardashevskiy * We use SRP luns of the form 01000000 | (usb-port << 16) | lun 257871461b0fSAlexey Kardashevskiy * in the top 32 bits of the 64-bit LUN 257971461b0fSAlexey Kardashevskiy */ 258071461b0fSAlexey Kardashevskiy unsigned usb_port = atoi(usb->port->path); 258171461b0fSAlexey Kardashevskiy unsigned id = 0x1000000 | (usb_port << 16) | d->lun; 258271461b0fSAlexey Kardashevskiy return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev), 258371461b0fSAlexey Kardashevskiy (uint64_t)id << 32); 258471461b0fSAlexey Kardashevskiy } 258571461b0fSAlexey Kardashevskiy } 258671461b0fSAlexey Kardashevskiy 2587b99260ebSThomas Huth /* 2588b99260ebSThomas Huth * SLOF probes the USB devices, and if it recognizes that the device is a 2589b99260ebSThomas Huth * storage device, it changes its name to "storage" instead of "usb-host", 2590b99260ebSThomas Huth * and additionally adds a child node for the SCSI LUN, so the correct 2591b99260ebSThomas Huth * boot path in SLOF is something like .../storage@1/disk@xxx" instead. 2592b99260ebSThomas Huth */ 2593b99260ebSThomas Huth if (strcmp("usb-host", qdev_fw_name(dev)) == 0) { 2594b99260ebSThomas Huth USBDevice *usbdev = CAST(USBDevice, dev, TYPE_USB_DEVICE); 2595b99260ebSThomas Huth if (usb_host_dev_is_scsi_storage(usbdev)) { 2596b99260ebSThomas Huth return g_strdup_printf("storage@%s/disk", usbdev->port->path); 2597b99260ebSThomas Huth } 2598b99260ebSThomas Huth } 2599b99260ebSThomas Huth 260071461b0fSAlexey Kardashevskiy if (phb) { 260171461b0fSAlexey Kardashevskiy /* Replace "pci" with "pci@800000020000000" */ 260271461b0fSAlexey Kardashevskiy return g_strdup_printf("pci@%"PRIX64, phb->buid); 260371461b0fSAlexey Kardashevskiy } 260471461b0fSAlexey Kardashevskiy 2605c4e13492SFelipe Franciosi if (vsc) { 2606c4e13492SFelipe Franciosi /* Same logic as virtio above */ 2607c4e13492SFelipe Franciosi unsigned id = 0x1000000 | (vsc->target << 16) | vsc->lun; 2608c4e13492SFelipe Franciosi return g_strdup_printf("disk@%"PRIX64, (uint64_t)id << 32); 2609c4e13492SFelipe Franciosi } 2610c4e13492SFelipe Franciosi 26114871dd4cSThomas Huth if (g_str_equal("pci-bridge", qdev_fw_name(dev))) { 26124871dd4cSThomas Huth /* SLOF uses "pci" instead of "pci-bridge" for PCI bridges */ 26134871dd4cSThomas Huth PCIDevice *pcidev = CAST(PCIDevice, dev, TYPE_PCI_DEVICE); 26144871dd4cSThomas Huth return g_strdup_printf("pci@%x", PCI_SLOT(pcidev->devfn)); 26154871dd4cSThomas Huth } 26164871dd4cSThomas Huth 261771461b0fSAlexey Kardashevskiy return NULL; 261871461b0fSAlexey Kardashevskiy } 261971461b0fSAlexey Kardashevskiy 262023825581SEduardo Habkost static char *spapr_get_kvm_type(Object *obj, Error **errp) 262123825581SEduardo Habkost { 262228e02042SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 262323825581SEduardo Habkost 262428e02042SDavid Gibson return g_strdup(spapr->kvm_type); 262523825581SEduardo Habkost } 262623825581SEduardo Habkost 262723825581SEduardo Habkost static void spapr_set_kvm_type(Object *obj, const char *value, Error **errp) 262823825581SEduardo Habkost { 262928e02042SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 263023825581SEduardo Habkost 263128e02042SDavid Gibson g_free(spapr->kvm_type); 263228e02042SDavid Gibson spapr->kvm_type = g_strdup(value); 263323825581SEduardo Habkost } 263423825581SEduardo Habkost 2635f6229214SMichael Roth static bool spapr_get_modern_hotplug_events(Object *obj, Error **errp) 2636f6229214SMichael Roth { 2637f6229214SMichael Roth sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 2638f6229214SMichael Roth 2639f6229214SMichael Roth return spapr->use_hotplug_event_source; 2640f6229214SMichael Roth } 2641f6229214SMichael Roth 2642f6229214SMichael Roth static void spapr_set_modern_hotplug_events(Object *obj, bool value, 2643f6229214SMichael Roth Error **errp) 2644f6229214SMichael Roth { 2645f6229214SMichael Roth sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 2646f6229214SMichael Roth 2647f6229214SMichael Roth spapr->use_hotplug_event_source = value; 2648f6229214SMichael Roth } 2649f6229214SMichael Roth 265030f4b05bSDavid Gibson static char *spapr_get_resize_hpt(Object *obj, Error **errp) 265130f4b05bSDavid Gibson { 265230f4b05bSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 265330f4b05bSDavid Gibson 265430f4b05bSDavid Gibson switch (spapr->resize_hpt) { 265530f4b05bSDavid Gibson case SPAPR_RESIZE_HPT_DEFAULT: 265630f4b05bSDavid Gibson return g_strdup("default"); 265730f4b05bSDavid Gibson case SPAPR_RESIZE_HPT_DISABLED: 265830f4b05bSDavid Gibson return g_strdup("disabled"); 265930f4b05bSDavid Gibson case SPAPR_RESIZE_HPT_ENABLED: 266030f4b05bSDavid Gibson return g_strdup("enabled"); 266130f4b05bSDavid Gibson case SPAPR_RESIZE_HPT_REQUIRED: 266230f4b05bSDavid Gibson return g_strdup("required"); 266330f4b05bSDavid Gibson } 266430f4b05bSDavid Gibson g_assert_not_reached(); 266530f4b05bSDavid Gibson } 266630f4b05bSDavid Gibson 266730f4b05bSDavid Gibson static void spapr_set_resize_hpt(Object *obj, const char *value, Error **errp) 266830f4b05bSDavid Gibson { 266930f4b05bSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 267030f4b05bSDavid Gibson 267130f4b05bSDavid Gibson if (strcmp(value, "default") == 0) { 267230f4b05bSDavid Gibson spapr->resize_hpt = SPAPR_RESIZE_HPT_DEFAULT; 267330f4b05bSDavid Gibson } else if (strcmp(value, "disabled") == 0) { 267430f4b05bSDavid Gibson spapr->resize_hpt = SPAPR_RESIZE_HPT_DISABLED; 267530f4b05bSDavid Gibson } else if (strcmp(value, "enabled") == 0) { 267630f4b05bSDavid Gibson spapr->resize_hpt = SPAPR_RESIZE_HPT_ENABLED; 267730f4b05bSDavid Gibson } else if (strcmp(value, "required") == 0) { 267830f4b05bSDavid Gibson spapr->resize_hpt = SPAPR_RESIZE_HPT_REQUIRED; 267930f4b05bSDavid Gibson } else { 268030f4b05bSDavid Gibson error_setg(errp, "Bad value for \"resize-hpt\" property"); 268130f4b05bSDavid Gibson } 268230f4b05bSDavid Gibson } 268330f4b05bSDavid Gibson 268423825581SEduardo Habkost static void spapr_machine_initfn(Object *obj) 268523825581SEduardo Habkost { 2686715c5407SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 2687715c5407SDavid Gibson 2688715c5407SDavid Gibson spapr->htab_fd = -1; 2689f6229214SMichael Roth spapr->use_hotplug_event_source = true; 269023825581SEduardo Habkost object_property_add_str(obj, "kvm-type", 269123825581SEduardo Habkost spapr_get_kvm_type, spapr_set_kvm_type, NULL); 269249d2e648SMarcel Apfelbaum object_property_set_description(obj, "kvm-type", 269349d2e648SMarcel Apfelbaum "Specifies the KVM virtualization mode (HV, PR)", 269449d2e648SMarcel Apfelbaum NULL); 2695f6229214SMichael Roth object_property_add_bool(obj, "modern-hotplug-events", 2696f6229214SMichael Roth spapr_get_modern_hotplug_events, 2697f6229214SMichael Roth spapr_set_modern_hotplug_events, 2698f6229214SMichael Roth NULL); 2699f6229214SMichael Roth object_property_set_description(obj, "modern-hotplug-events", 2700f6229214SMichael Roth "Use dedicated hotplug event mechanism in" 2701f6229214SMichael Roth " place of standard EPOW events when possible" 2702f6229214SMichael Roth " (required for memory hot-unplug support)", 2703f6229214SMichael Roth NULL); 27047843c0d6SDavid Gibson 27057843c0d6SDavid Gibson ppc_compat_add_property(obj, "max-cpu-compat", &spapr->max_compat_pvr, 27067843c0d6SDavid Gibson "Maximum permitted CPU compatibility mode", 27077843c0d6SDavid Gibson &error_fatal); 270830f4b05bSDavid Gibson 270930f4b05bSDavid Gibson object_property_add_str(obj, "resize-hpt", 271030f4b05bSDavid Gibson spapr_get_resize_hpt, spapr_set_resize_hpt, NULL); 271130f4b05bSDavid Gibson object_property_set_description(obj, "resize-hpt", 271230f4b05bSDavid Gibson "Resizing of the Hash Page Table (enabled, disabled, required)", 271330f4b05bSDavid Gibson NULL); 271423825581SEduardo Habkost } 271523825581SEduardo Habkost 271687bbdd9cSDavid Gibson static void spapr_machine_finalizefn(Object *obj) 271787bbdd9cSDavid Gibson { 271887bbdd9cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 271987bbdd9cSDavid Gibson 272087bbdd9cSDavid Gibson g_free(spapr->kvm_type); 272187bbdd9cSDavid Gibson } 272287bbdd9cSDavid Gibson 27231c7ad77eSNicholas Piggin void spapr_do_system_reset_on_cpu(CPUState *cs, run_on_cpu_data arg) 272434316482SAlexey Kardashevskiy { 272534316482SAlexey Kardashevskiy cpu_synchronize_state(cs); 272634316482SAlexey Kardashevskiy ppc_cpu_do_system_reset(cs); 272734316482SAlexey Kardashevskiy } 272834316482SAlexey Kardashevskiy 272934316482SAlexey Kardashevskiy static void spapr_nmi(NMIState *n, int cpu_index, Error **errp) 273034316482SAlexey Kardashevskiy { 273134316482SAlexey Kardashevskiy CPUState *cs; 273234316482SAlexey Kardashevskiy 273334316482SAlexey Kardashevskiy CPU_FOREACH(cs) { 27341c7ad77eSNicholas Piggin async_run_on_cpu(cs, spapr_do_system_reset_on_cpu, RUN_ON_CPU_NULL); 273534316482SAlexey Kardashevskiy } 273634316482SAlexey Kardashevskiy } 273734316482SAlexey Kardashevskiy 273879b78a6bSMichael Roth static void spapr_add_lmbs(DeviceState *dev, uint64_t addr_start, uint64_t size, 273979b78a6bSMichael Roth uint32_t node, bool dedicated_hp_event_source, 274079b78a6bSMichael Roth Error **errp) 2741c20d332aSBharata B Rao { 2742c20d332aSBharata B Rao sPAPRDRConnector *drc; 2743c20d332aSBharata B Rao uint32_t nr_lmbs = size/SPAPR_MEMORY_BLOCK_SIZE; 2744c20d332aSBharata B Rao int i, fdt_offset, fdt_size; 2745c20d332aSBharata B Rao void *fdt; 274679b78a6bSMichael Roth uint64_t addr = addr_start; 274794fd9cbaSLaurent Vivier bool hotplugged = spapr_drc_hotplugged(dev); 2748160bb678SGreg Kurz Error *local_err = NULL; 2749c20d332aSBharata B Rao 2750c20d332aSBharata B Rao for (i = 0; i < nr_lmbs; i++) { 2751fbf55397SDavid Gibson drc = spapr_drc_by_id(TYPE_SPAPR_DRC_LMB, 2752c20d332aSBharata B Rao addr / SPAPR_MEMORY_BLOCK_SIZE); 2753c20d332aSBharata B Rao g_assert(drc); 2754c20d332aSBharata B Rao 2755c20d332aSBharata B Rao fdt = create_device_tree(&fdt_size); 2756c20d332aSBharata B Rao fdt_offset = spapr_populate_memory_node(fdt, node, addr, 2757c20d332aSBharata B Rao SPAPR_MEMORY_BLOCK_SIZE); 2758c20d332aSBharata B Rao 2759160bb678SGreg Kurz spapr_drc_attach(drc, dev, fdt, fdt_offset, &local_err); 2760160bb678SGreg Kurz if (local_err) { 2761160bb678SGreg Kurz while (addr > addr_start) { 2762160bb678SGreg Kurz addr -= SPAPR_MEMORY_BLOCK_SIZE; 2763160bb678SGreg Kurz drc = spapr_drc_by_id(TYPE_SPAPR_DRC_LMB, 2764160bb678SGreg Kurz addr / SPAPR_MEMORY_BLOCK_SIZE); 2765a8dc47fdSDavid Gibson spapr_drc_detach(drc); 2766160bb678SGreg Kurz } 2767160bb678SGreg Kurz g_free(fdt); 2768160bb678SGreg Kurz error_propagate(errp, local_err); 2769160bb678SGreg Kurz return; 2770160bb678SGreg Kurz } 277194fd9cbaSLaurent Vivier if (!hotplugged) { 277294fd9cbaSLaurent Vivier spapr_drc_reset(drc); 277394fd9cbaSLaurent Vivier } 2774c20d332aSBharata B Rao addr += SPAPR_MEMORY_BLOCK_SIZE; 2775c20d332aSBharata B Rao } 27765dd5238cSJianjun Duan /* send hotplug notification to the 27775dd5238cSJianjun Duan * guest only in case of hotplugged memory 27785dd5238cSJianjun Duan */ 277994fd9cbaSLaurent Vivier if (hotplugged) { 278079b78a6bSMichael Roth if (dedicated_hp_event_source) { 2781fbf55397SDavid Gibson drc = spapr_drc_by_id(TYPE_SPAPR_DRC_LMB, 278279b78a6bSMichael Roth addr_start / SPAPR_MEMORY_BLOCK_SIZE); 278379b78a6bSMichael Roth spapr_hotplug_req_add_by_count_indexed(SPAPR_DR_CONNECTOR_TYPE_LMB, 278479b78a6bSMichael Roth nr_lmbs, 27850b55aa91SDavid Gibson spapr_drc_index(drc)); 278679b78a6bSMichael Roth } else { 278779b78a6bSMichael Roth spapr_hotplug_req_add_by_count(SPAPR_DR_CONNECTOR_TYPE_LMB, 278879b78a6bSMichael Roth nr_lmbs); 278979b78a6bSMichael Roth } 2790c20d332aSBharata B Rao } 27915dd5238cSJianjun Duan } 2792c20d332aSBharata B Rao 2793c20d332aSBharata B Rao static void spapr_memory_plug(HotplugHandler *hotplug_dev, DeviceState *dev, 2794c20d332aSBharata B Rao uint32_t node, Error **errp) 2795c20d332aSBharata B Rao { 2796c20d332aSBharata B Rao Error *local_err = NULL; 2797c20d332aSBharata B Rao sPAPRMachineState *ms = SPAPR_MACHINE(hotplug_dev); 2798c20d332aSBharata B Rao PCDIMMDevice *dimm = PC_DIMM(dev); 2799c20d332aSBharata B Rao PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); 280004790978SThomas Huth MemoryRegion *mr; 280104790978SThomas Huth uint64_t align, size, addr; 280204790978SThomas Huth 280304790978SThomas Huth mr = ddc->get_memory_region(dimm, &local_err); 280404790978SThomas Huth if (local_err) { 280504790978SThomas Huth goto out; 280604790978SThomas Huth } 280704790978SThomas Huth align = memory_region_get_alignment(mr); 280804790978SThomas Huth size = memory_region_size(mr); 2809df587133SThomas Huth 2810d6a9b0b8SMichael S. Tsirkin pc_dimm_memory_plug(dev, &ms->hotplug_memory, mr, align, &local_err); 2811c20d332aSBharata B Rao if (local_err) { 2812c20d332aSBharata B Rao goto out; 2813c20d332aSBharata B Rao } 2814c20d332aSBharata B Rao 28159ed442b8SMarc-André Lureau addr = object_property_get_uint(OBJECT(dimm), 28169ed442b8SMarc-André Lureau PC_DIMM_ADDR_PROP, &local_err); 2817c20d332aSBharata B Rao if (local_err) { 2818160bb678SGreg Kurz goto out_unplug; 2819c20d332aSBharata B Rao } 2820c20d332aSBharata B Rao 282179b78a6bSMichael Roth spapr_add_lmbs(dev, addr, size, node, 282279b78a6bSMichael Roth spapr_ovec_test(ms->ov5_cas, OV5_HP_EVT), 2823160bb678SGreg Kurz &local_err); 2824160bb678SGreg Kurz if (local_err) { 2825160bb678SGreg Kurz goto out_unplug; 2826160bb678SGreg Kurz } 2827c20d332aSBharata B Rao 2828160bb678SGreg Kurz return; 2829160bb678SGreg Kurz 2830160bb678SGreg Kurz out_unplug: 2831160bb678SGreg Kurz pc_dimm_memory_unplug(dev, &ms->hotplug_memory, mr); 2832c20d332aSBharata B Rao out: 2833c20d332aSBharata B Rao error_propagate(errp, local_err); 2834c20d332aSBharata B Rao } 2835c20d332aSBharata B Rao 2836c871bc70SLaurent Vivier static void spapr_memory_pre_plug(HotplugHandler *hotplug_dev, DeviceState *dev, 2837c871bc70SLaurent Vivier Error **errp) 2838c871bc70SLaurent Vivier { 2839c871bc70SLaurent Vivier PCDIMMDevice *dimm = PC_DIMM(dev); 2840c871bc70SLaurent Vivier PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); 284104790978SThomas Huth MemoryRegion *mr; 284204790978SThomas Huth uint64_t size; 2843c871bc70SLaurent Vivier char *mem_dev; 2844c871bc70SLaurent Vivier 284504790978SThomas Huth mr = ddc->get_memory_region(dimm, errp); 284604790978SThomas Huth if (!mr) { 284704790978SThomas Huth return; 284804790978SThomas Huth } 284904790978SThomas Huth size = memory_region_size(mr); 285004790978SThomas Huth 2851c871bc70SLaurent Vivier if (size % SPAPR_MEMORY_BLOCK_SIZE) { 2852c871bc70SLaurent Vivier error_setg(errp, "Hotplugged memory size must be a multiple of " 2853c871bc70SLaurent Vivier "%lld MB", SPAPR_MEMORY_BLOCK_SIZE / M_BYTE); 2854c871bc70SLaurent Vivier return; 2855c871bc70SLaurent Vivier } 2856c871bc70SLaurent Vivier 2857c871bc70SLaurent Vivier mem_dev = object_property_get_str(OBJECT(dimm), PC_DIMM_MEMDEV_PROP, NULL); 2858c871bc70SLaurent Vivier if (mem_dev && !kvmppc_is_mem_backend_page_size_ok(mem_dev)) { 2859c871bc70SLaurent Vivier error_setg(errp, "Memory backend has bad page size. " 2860c871bc70SLaurent Vivier "Use 'memory-backend-file' with correct mem-path."); 28618a9e0e7bSGreg Kurz goto out; 2862c871bc70SLaurent Vivier } 28638a9e0e7bSGreg Kurz 28648a9e0e7bSGreg Kurz out: 28658a9e0e7bSGreg Kurz g_free(mem_dev); 2866c871bc70SLaurent Vivier } 2867c871bc70SLaurent Vivier 28680cffce56SDavid Gibson struct sPAPRDIMMState { 28690cffce56SDavid Gibson PCDIMMDevice *dimm; 2870cf632463SBharata B Rao uint32_t nr_lmbs; 28710cffce56SDavid Gibson QTAILQ_ENTRY(sPAPRDIMMState) next; 28720cffce56SDavid Gibson }; 28730cffce56SDavid Gibson 28740cffce56SDavid Gibson static sPAPRDIMMState *spapr_pending_dimm_unplugs_find(sPAPRMachineState *s, 28750cffce56SDavid Gibson PCDIMMDevice *dimm) 28760cffce56SDavid Gibson { 28770cffce56SDavid Gibson sPAPRDIMMState *dimm_state = NULL; 28780cffce56SDavid Gibson 28790cffce56SDavid Gibson QTAILQ_FOREACH(dimm_state, &s->pending_dimm_unplugs, next) { 28800cffce56SDavid Gibson if (dimm_state->dimm == dimm) { 28810cffce56SDavid Gibson break; 28820cffce56SDavid Gibson } 28830cffce56SDavid Gibson } 28840cffce56SDavid Gibson return dimm_state; 28850cffce56SDavid Gibson } 28860cffce56SDavid Gibson 28878d5981c4SBharata B Rao static sPAPRDIMMState *spapr_pending_dimm_unplugs_add(sPAPRMachineState *spapr, 28888d5981c4SBharata B Rao uint32_t nr_lmbs, 28898d5981c4SBharata B Rao PCDIMMDevice *dimm) 28900cffce56SDavid Gibson { 28918d5981c4SBharata B Rao sPAPRDIMMState *ds = NULL; 28928d5981c4SBharata B Rao 28938d5981c4SBharata B Rao /* 28948d5981c4SBharata B Rao * If this request is for a DIMM whose removal had failed earlier 28958d5981c4SBharata B Rao * (due to guest's refusal to remove the LMBs), we would have this 28968d5981c4SBharata B Rao * dimm already in the pending_dimm_unplugs list. In that 28978d5981c4SBharata B Rao * case don't add again. 28988d5981c4SBharata B Rao */ 28998d5981c4SBharata B Rao ds = spapr_pending_dimm_unplugs_find(spapr, dimm); 29008d5981c4SBharata B Rao if (!ds) { 29018d5981c4SBharata B Rao ds = g_malloc0(sizeof(sPAPRDIMMState)); 29028d5981c4SBharata B Rao ds->nr_lmbs = nr_lmbs; 29038d5981c4SBharata B Rao ds->dimm = dimm; 29048d5981c4SBharata B Rao QTAILQ_INSERT_HEAD(&spapr->pending_dimm_unplugs, ds, next); 29058d5981c4SBharata B Rao } 29068d5981c4SBharata B Rao return ds; 29070cffce56SDavid Gibson } 29080cffce56SDavid Gibson 29090cffce56SDavid Gibson static void spapr_pending_dimm_unplugs_remove(sPAPRMachineState *spapr, 29100cffce56SDavid Gibson sPAPRDIMMState *dimm_state) 29110cffce56SDavid Gibson { 29120cffce56SDavid Gibson QTAILQ_REMOVE(&spapr->pending_dimm_unplugs, dimm_state, next); 29130cffce56SDavid Gibson g_free(dimm_state); 29140cffce56SDavid Gibson } 2915cf632463SBharata B Rao 291616ee9980SDaniel Henrique Barboza static sPAPRDIMMState *spapr_recover_pending_dimm_state(sPAPRMachineState *ms, 291716ee9980SDaniel Henrique Barboza PCDIMMDevice *dimm) 291816ee9980SDaniel Henrique Barboza { 291916ee9980SDaniel Henrique Barboza sPAPRDRConnector *drc; 292016ee9980SDaniel Henrique Barboza PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); 292104790978SThomas Huth MemoryRegion *mr = ddc->get_memory_region(dimm, &error_abort); 292216ee9980SDaniel Henrique Barboza uint64_t size = memory_region_size(mr); 292316ee9980SDaniel Henrique Barboza uint32_t nr_lmbs = size / SPAPR_MEMORY_BLOCK_SIZE; 292416ee9980SDaniel Henrique Barboza uint32_t avail_lmbs = 0; 292516ee9980SDaniel Henrique Barboza uint64_t addr_start, addr; 292616ee9980SDaniel Henrique Barboza int i; 292716ee9980SDaniel Henrique Barboza 292816ee9980SDaniel Henrique Barboza addr_start = object_property_get_int(OBJECT(dimm), PC_DIMM_ADDR_PROP, 292916ee9980SDaniel Henrique Barboza &error_abort); 293016ee9980SDaniel Henrique Barboza 293116ee9980SDaniel Henrique Barboza addr = addr_start; 293216ee9980SDaniel Henrique Barboza for (i = 0; i < nr_lmbs; i++) { 2933fbf55397SDavid Gibson drc = spapr_drc_by_id(TYPE_SPAPR_DRC_LMB, 293416ee9980SDaniel Henrique Barboza addr / SPAPR_MEMORY_BLOCK_SIZE); 293516ee9980SDaniel Henrique Barboza g_assert(drc); 2936454b580aSDavid Gibson if (drc->dev) { 293716ee9980SDaniel Henrique Barboza avail_lmbs++; 293816ee9980SDaniel Henrique Barboza } 293916ee9980SDaniel Henrique Barboza addr += SPAPR_MEMORY_BLOCK_SIZE; 294016ee9980SDaniel Henrique Barboza } 294116ee9980SDaniel Henrique Barboza 29428d5981c4SBharata B Rao return spapr_pending_dimm_unplugs_add(ms, avail_lmbs, dimm); 294316ee9980SDaniel Henrique Barboza } 294416ee9980SDaniel Henrique Barboza 294531834723SDaniel Henrique Barboza /* Callback to be called during DRC release. */ 294631834723SDaniel Henrique Barboza void spapr_lmb_release(DeviceState *dev) 2947cf632463SBharata B Rao { 2948765d1bddSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(qdev_get_hotplug_handler(dev)); 2949765d1bddSDavid Gibson PCDIMMDevice *dimm = PC_DIMM(dev); 2950765d1bddSDavid Gibson PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); 295104790978SThomas Huth MemoryRegion *mr = ddc->get_memory_region(dimm, &error_abort); 29520cffce56SDavid Gibson sPAPRDIMMState *ds = spapr_pending_dimm_unplugs_find(spapr, PC_DIMM(dev)); 2953cf632463SBharata B Rao 295416ee9980SDaniel Henrique Barboza /* This information will get lost if a migration occurs 295516ee9980SDaniel Henrique Barboza * during the unplug process. In this case recover it. */ 295616ee9980SDaniel Henrique Barboza if (ds == NULL) { 295716ee9980SDaniel Henrique Barboza ds = spapr_recover_pending_dimm_state(spapr, PC_DIMM(dev)); 29588d5981c4SBharata B Rao g_assert(ds); 2959454b580aSDavid Gibson /* The DRC being examined by the caller at least must be counted */ 2960454b580aSDavid Gibson g_assert(ds->nr_lmbs); 296116ee9980SDaniel Henrique Barboza } 2962454b580aSDavid Gibson 2963454b580aSDavid Gibson if (--ds->nr_lmbs) { 2964cf632463SBharata B Rao return; 2965cf632463SBharata B Rao } 2966cf632463SBharata B Rao 29670cffce56SDavid Gibson spapr_pending_dimm_unplugs_remove(spapr, ds); 2968cf632463SBharata B Rao 2969cf632463SBharata B Rao /* 2970cf632463SBharata B Rao * Now that all the LMBs have been removed by the guest, call the 2971cf632463SBharata B Rao * pc-dimm unplug handler to cleanup up the pc-dimm device. 2972cf632463SBharata B Rao */ 2973765d1bddSDavid Gibson pc_dimm_memory_unplug(dev, &spapr->hotplug_memory, mr); 2974cf632463SBharata B Rao object_unparent(OBJECT(dev)); 2975cf632463SBharata B Rao } 2976cf632463SBharata B Rao 2977cf632463SBharata B Rao static void spapr_memory_unplug_request(HotplugHandler *hotplug_dev, 2978cf632463SBharata B Rao DeviceState *dev, Error **errp) 2979cf632463SBharata B Rao { 29800cffce56SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(hotplug_dev); 2981cf632463SBharata B Rao Error *local_err = NULL; 2982cf632463SBharata B Rao PCDIMMDevice *dimm = PC_DIMM(dev); 2983cf632463SBharata B Rao PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); 298404790978SThomas Huth MemoryRegion *mr; 298504790978SThomas Huth uint32_t nr_lmbs; 298604790978SThomas Huth uint64_t size, addr_start, addr; 29870cffce56SDavid Gibson int i; 29880cffce56SDavid Gibson sPAPRDRConnector *drc; 298904790978SThomas Huth 299004790978SThomas Huth mr = ddc->get_memory_region(dimm, &local_err); 299104790978SThomas Huth if (local_err) { 299204790978SThomas Huth goto out; 299304790978SThomas Huth } 299404790978SThomas Huth size = memory_region_size(mr); 299504790978SThomas Huth nr_lmbs = size / SPAPR_MEMORY_BLOCK_SIZE; 299604790978SThomas Huth 29979ed442b8SMarc-André Lureau addr_start = object_property_get_uint(OBJECT(dimm), PC_DIMM_ADDR_PROP, 29980cffce56SDavid Gibson &local_err); 2999cf632463SBharata B Rao if (local_err) { 3000cf632463SBharata B Rao goto out; 3001cf632463SBharata B Rao } 3002cf632463SBharata B Rao 30038d5981c4SBharata B Rao spapr_pending_dimm_unplugs_add(spapr, nr_lmbs, dimm); 30040cffce56SDavid Gibson 30050cffce56SDavid Gibson addr = addr_start; 30060cffce56SDavid Gibson for (i = 0; i < nr_lmbs; i++) { 3007fbf55397SDavid Gibson drc = spapr_drc_by_id(TYPE_SPAPR_DRC_LMB, 30080cffce56SDavid Gibson addr / SPAPR_MEMORY_BLOCK_SIZE); 30090cffce56SDavid Gibson g_assert(drc); 30100cffce56SDavid Gibson 3011a8dc47fdSDavid Gibson spapr_drc_detach(drc); 30120cffce56SDavid Gibson addr += SPAPR_MEMORY_BLOCK_SIZE; 30130cffce56SDavid Gibson } 30140cffce56SDavid Gibson 3015fbf55397SDavid Gibson drc = spapr_drc_by_id(TYPE_SPAPR_DRC_LMB, 30160cffce56SDavid Gibson addr_start / SPAPR_MEMORY_BLOCK_SIZE); 30170cffce56SDavid Gibson spapr_hotplug_req_remove_by_count_indexed(SPAPR_DR_CONNECTOR_TYPE_LMB, 30180b55aa91SDavid Gibson nr_lmbs, spapr_drc_index(drc)); 3019cf632463SBharata B Rao out: 3020cf632463SBharata B Rao error_propagate(errp, local_err); 3021cf632463SBharata B Rao } 3022cf632463SBharata B Rao 302304d0ffbdSGreg Kurz static void *spapr_populate_hotplug_cpu_dt(CPUState *cs, int *fdt_offset, 3024af81cf32SBharata B Rao sPAPRMachineState *spapr) 3025af81cf32SBharata B Rao { 3026af81cf32SBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(cs); 3027af81cf32SBharata B Rao DeviceClass *dc = DEVICE_GET_CLASS(cs); 3028af81cf32SBharata B Rao int id = ppc_get_vcpu_dt_id(cpu); 3029af81cf32SBharata B Rao void *fdt; 3030af81cf32SBharata B Rao int offset, fdt_size; 3031af81cf32SBharata B Rao char *nodename; 3032af81cf32SBharata B Rao 3033af81cf32SBharata B Rao fdt = create_device_tree(&fdt_size); 3034af81cf32SBharata B Rao nodename = g_strdup_printf("%s@%x", dc->fw_name, id); 3035af81cf32SBharata B Rao offset = fdt_add_subnode(fdt, 0, nodename); 3036af81cf32SBharata B Rao 3037af81cf32SBharata B Rao spapr_populate_cpu_dt(cs, fdt, offset, spapr); 3038af81cf32SBharata B Rao g_free(nodename); 3039af81cf32SBharata B Rao 3040af81cf32SBharata B Rao *fdt_offset = offset; 3041af81cf32SBharata B Rao return fdt; 3042af81cf32SBharata B Rao } 3043af81cf32SBharata B Rao 3044765d1bddSDavid Gibson /* Callback to be called during DRC release. */ 3045765d1bddSDavid Gibson void spapr_core_release(DeviceState *dev) 3046ff9006ddSIgor Mammedov { 3047765d1bddSDavid Gibson MachineState *ms = MACHINE(qdev_get_hotplug_handler(dev)); 304846f7afa3SGreg Kurz sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(ms); 3049ff9006ddSIgor Mammedov CPUCore *cc = CPU_CORE(dev); 3050535455fdSIgor Mammedov CPUArchId *core_slot = spapr_find_cpu_slot(ms, cc->core_id, NULL); 3051ff9006ddSIgor Mammedov 305246f7afa3SGreg Kurz if (smc->pre_2_10_has_unused_icps) { 305346f7afa3SGreg Kurz sPAPRCPUCore *sc = SPAPR_CPU_CORE(OBJECT(dev)); 305446f7afa3SGreg Kurz sPAPRCPUCoreClass *scc = SPAPR_CPU_CORE_GET_CLASS(OBJECT(cc)); 305546f7afa3SGreg Kurz const char *typename = object_class_get_name(scc->cpu_class); 305646f7afa3SGreg Kurz size_t size = object_type_get_instance_size(typename); 305746f7afa3SGreg Kurz int i; 305846f7afa3SGreg Kurz 305946f7afa3SGreg Kurz for (i = 0; i < cc->nr_threads; i++) { 306046f7afa3SGreg Kurz CPUState *cs = CPU(sc->threads + i * size); 306146f7afa3SGreg Kurz 306246f7afa3SGreg Kurz pre_2_10_vmstate_register_dummy_icp(cs->cpu_index); 306346f7afa3SGreg Kurz } 306446f7afa3SGreg Kurz } 306546f7afa3SGreg Kurz 306607572c06SGreg Kurz assert(core_slot); 3067535455fdSIgor Mammedov core_slot->cpu = NULL; 3068ff9006ddSIgor Mammedov object_unparent(OBJECT(dev)); 3069ff9006ddSIgor Mammedov } 3070ff9006ddSIgor Mammedov 3071115debf2SIgor Mammedov static 3072115debf2SIgor Mammedov void spapr_core_unplug_request(HotplugHandler *hotplug_dev, DeviceState *dev, 3073ff9006ddSIgor Mammedov Error **errp) 3074ff9006ddSIgor Mammedov { 3075535455fdSIgor Mammedov int index; 3076535455fdSIgor Mammedov sPAPRDRConnector *drc; 3077535455fdSIgor Mammedov CPUCore *cc = CPU_CORE(dev); 3078535455fdSIgor Mammedov int smt = kvmppc_smt_threads(); 3079ff9006ddSIgor Mammedov 3080535455fdSIgor Mammedov if (!spapr_find_cpu_slot(MACHINE(hotplug_dev), cc->core_id, &index)) { 3081535455fdSIgor Mammedov error_setg(errp, "Unable to find CPU core with core-id: %d", 3082535455fdSIgor Mammedov cc->core_id); 3083535455fdSIgor Mammedov return; 3084535455fdSIgor Mammedov } 3085ff9006ddSIgor Mammedov if (index == 0) { 3086ff9006ddSIgor Mammedov error_setg(errp, "Boot CPU core may not be unplugged"); 3087ff9006ddSIgor Mammedov return; 3088ff9006ddSIgor Mammedov } 3089ff9006ddSIgor Mammedov 3090fbf55397SDavid Gibson drc = spapr_drc_by_id(TYPE_SPAPR_DRC_CPU, index * smt); 3091ff9006ddSIgor Mammedov g_assert(drc); 3092ff9006ddSIgor Mammedov 3093a8dc47fdSDavid Gibson spapr_drc_detach(drc); 3094ff9006ddSIgor Mammedov 3095ff9006ddSIgor Mammedov spapr_hotplug_req_remove_by_index(drc); 3096ff9006ddSIgor Mammedov } 3097ff9006ddSIgor Mammedov 3098ff9006ddSIgor Mammedov static void spapr_core_plug(HotplugHandler *hotplug_dev, DeviceState *dev, 3099ff9006ddSIgor Mammedov Error **errp) 3100ff9006ddSIgor Mammedov { 3101ff9006ddSIgor Mammedov sPAPRMachineState *spapr = SPAPR_MACHINE(OBJECT(hotplug_dev)); 3102ff9006ddSIgor Mammedov MachineClass *mc = MACHINE_GET_CLASS(spapr); 310346f7afa3SGreg Kurz sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); 3104ff9006ddSIgor Mammedov sPAPRCPUCore *core = SPAPR_CPU_CORE(OBJECT(dev)); 3105ff9006ddSIgor Mammedov CPUCore *cc = CPU_CORE(dev); 3106ff9006ddSIgor Mammedov CPUState *cs = CPU(core->threads); 3107ff9006ddSIgor Mammedov sPAPRDRConnector *drc; 3108ff9006ddSIgor Mammedov Error *local_err = NULL; 3109ff9006ddSIgor Mammedov int smt = kvmppc_smt_threads(); 3110535455fdSIgor Mammedov CPUArchId *core_slot; 3111535455fdSIgor Mammedov int index; 311294fd9cbaSLaurent Vivier bool hotplugged = spapr_drc_hotplugged(dev); 3113ff9006ddSIgor Mammedov 3114535455fdSIgor Mammedov core_slot = spapr_find_cpu_slot(MACHINE(hotplug_dev), cc->core_id, &index); 3115535455fdSIgor Mammedov if (!core_slot) { 3116535455fdSIgor Mammedov error_setg(errp, "Unable to find CPU core with core-id: %d", 3117535455fdSIgor Mammedov cc->core_id); 3118535455fdSIgor Mammedov return; 3119535455fdSIgor Mammedov } 3120fbf55397SDavid Gibson drc = spapr_drc_by_id(TYPE_SPAPR_DRC_CPU, index * smt); 3121ff9006ddSIgor Mammedov 3122c5514d0eSIgor Mammedov g_assert(drc || !mc->has_hotpluggable_cpus); 3123ff9006ddSIgor Mammedov 3124e49c63d5SGreg Kurz if (drc) { 3125e49c63d5SGreg Kurz void *fdt; 3126e49c63d5SGreg Kurz int fdt_offset; 3127e49c63d5SGreg Kurz 3128ff9006ddSIgor Mammedov fdt = spapr_populate_hotplug_cpu_dt(cs, &fdt_offset, spapr); 3129ff9006ddSIgor Mammedov 31305c1da812SDavid Gibson spapr_drc_attach(drc, dev, fdt, fdt_offset, &local_err); 3131ff9006ddSIgor Mammedov if (local_err) { 3132ff9006ddSIgor Mammedov g_free(fdt); 3133ff9006ddSIgor Mammedov error_propagate(errp, local_err); 3134ff9006ddSIgor Mammedov return; 3135ff9006ddSIgor Mammedov } 3136ff9006ddSIgor Mammedov 313794fd9cbaSLaurent Vivier if (hotplugged) { 3138ff9006ddSIgor Mammedov /* 313994fd9cbaSLaurent Vivier * Send hotplug notification interrupt to the guest only 314094fd9cbaSLaurent Vivier * in case of hotplugged CPUs. 3141ff9006ddSIgor Mammedov */ 3142ff9006ddSIgor Mammedov spapr_hotplug_req_add_by_index(drc); 314394fd9cbaSLaurent Vivier } else { 314494fd9cbaSLaurent Vivier spapr_drc_reset(drc); 3145ff9006ddSIgor Mammedov } 314694fd9cbaSLaurent Vivier } 314794fd9cbaSLaurent Vivier 3148535455fdSIgor Mammedov core_slot->cpu = OBJECT(dev); 314946f7afa3SGreg Kurz 315046f7afa3SGreg Kurz if (smc->pre_2_10_has_unused_icps) { 315146f7afa3SGreg Kurz sPAPRCPUCoreClass *scc = SPAPR_CPU_CORE_GET_CLASS(OBJECT(cc)); 315246f7afa3SGreg Kurz const char *typename = object_class_get_name(scc->cpu_class); 315346f7afa3SGreg Kurz size_t size = object_type_get_instance_size(typename); 315446f7afa3SGreg Kurz int i; 315546f7afa3SGreg Kurz 315646f7afa3SGreg Kurz for (i = 0; i < cc->nr_threads; i++) { 315746f7afa3SGreg Kurz sPAPRCPUCore *sc = SPAPR_CPU_CORE(dev); 315846f7afa3SGreg Kurz void *obj = sc->threads + i * size; 315946f7afa3SGreg Kurz 316046f7afa3SGreg Kurz cs = CPU(obj); 316146f7afa3SGreg Kurz pre_2_10_vmstate_unregister_dummy_icp(cs->cpu_index); 316246f7afa3SGreg Kurz } 316346f7afa3SGreg Kurz } 3164ff9006ddSIgor Mammedov } 3165ff9006ddSIgor Mammedov 3166ff9006ddSIgor Mammedov static void spapr_core_pre_plug(HotplugHandler *hotplug_dev, DeviceState *dev, 3167ff9006ddSIgor Mammedov Error **errp) 3168ff9006ddSIgor Mammedov { 3169ff9006ddSIgor Mammedov MachineState *machine = MACHINE(OBJECT(hotplug_dev)); 3170ff9006ddSIgor Mammedov MachineClass *mc = MACHINE_GET_CLASS(hotplug_dev); 3171ff9006ddSIgor Mammedov Error *local_err = NULL; 3172ff9006ddSIgor Mammedov CPUCore *cc = CPU_CORE(dev); 3173ff9006ddSIgor Mammedov char *base_core_type = spapr_get_cpu_core_type(machine->cpu_model); 3174ff9006ddSIgor Mammedov const char *type = object_get_typename(OBJECT(dev)); 3175535455fdSIgor Mammedov CPUArchId *core_slot; 3176535455fdSIgor Mammedov int index; 3177ff9006ddSIgor Mammedov 3178c5514d0eSIgor Mammedov if (dev->hotplugged && !mc->has_hotpluggable_cpus) { 3179ff9006ddSIgor Mammedov error_setg(&local_err, "CPU hotplug not supported for this machine"); 3180ff9006ddSIgor Mammedov goto out; 3181ff9006ddSIgor Mammedov } 3182ff9006ddSIgor Mammedov 3183ff9006ddSIgor Mammedov if (strcmp(base_core_type, type)) { 3184ff9006ddSIgor Mammedov error_setg(&local_err, "CPU core type should be %s", base_core_type); 3185ff9006ddSIgor Mammedov goto out; 3186ff9006ddSIgor Mammedov } 3187ff9006ddSIgor Mammedov 3188ff9006ddSIgor Mammedov if (cc->core_id % smp_threads) { 3189ff9006ddSIgor Mammedov error_setg(&local_err, "invalid core id %d", cc->core_id); 3190ff9006ddSIgor Mammedov goto out; 3191ff9006ddSIgor Mammedov } 3192ff9006ddSIgor Mammedov 3193459264efSDavid Gibson /* 3194459264efSDavid Gibson * In general we should have homogeneous threads-per-core, but old 3195459264efSDavid Gibson * (pre hotplug support) machine types allow the last core to have 3196459264efSDavid Gibson * reduced threads as a compatibility hack for when we allowed 3197459264efSDavid Gibson * total vcpus not a multiple of threads-per-core. 3198459264efSDavid Gibson */ 3199459264efSDavid Gibson if (mc->has_hotpluggable_cpus && (cc->nr_threads != smp_threads)) { 3200df8658deSGreg Kurz error_setg(&local_err, "invalid nr-threads %d, must be %d", 32018149e299SDavid Gibson cc->nr_threads, smp_threads); 3202df8658deSGreg Kurz goto out; 32038149e299SDavid Gibson } 32048149e299SDavid Gibson 3205535455fdSIgor Mammedov core_slot = spapr_find_cpu_slot(MACHINE(hotplug_dev), cc->core_id, &index); 3206535455fdSIgor Mammedov if (!core_slot) { 3207ff9006ddSIgor Mammedov error_setg(&local_err, "core id %d out of range", cc->core_id); 3208ff9006ddSIgor Mammedov goto out; 3209ff9006ddSIgor Mammedov } 3210ff9006ddSIgor Mammedov 3211535455fdSIgor Mammedov if (core_slot->cpu) { 3212ff9006ddSIgor Mammedov error_setg(&local_err, "core %d already populated", cc->core_id); 3213ff9006ddSIgor Mammedov goto out; 3214ff9006ddSIgor Mammedov } 3215ff9006ddSIgor Mammedov 3216a0ceb640SIgor Mammedov numa_cpu_pre_plug(core_slot, dev, &local_err); 32170b8497f0SIgor Mammedov 3218ff9006ddSIgor Mammedov out: 3219ff9006ddSIgor Mammedov g_free(base_core_type); 3220ff9006ddSIgor Mammedov error_propagate(errp, local_err); 3221ff9006ddSIgor Mammedov } 3222ff9006ddSIgor Mammedov 3223c20d332aSBharata B Rao static void spapr_machine_device_plug(HotplugHandler *hotplug_dev, 3224c20d332aSBharata B Rao DeviceState *dev, Error **errp) 3225c20d332aSBharata B Rao { 3226c20d332aSBharata B Rao sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(qdev_get_machine()); 3227c20d332aSBharata B Rao 3228c20d332aSBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { 3229b556854bSBharata B Rao int node; 3230c20d332aSBharata B Rao 3231c20d332aSBharata B Rao if (!smc->dr_lmb_enabled) { 3232c20d332aSBharata B Rao error_setg(errp, "Memory hotplug not supported for this machine"); 3233c20d332aSBharata B Rao return; 3234c20d332aSBharata B Rao } 32359ed442b8SMarc-André Lureau node = object_property_get_uint(OBJECT(dev), PC_DIMM_NODE_PROP, errp); 3236c20d332aSBharata B Rao if (*errp) { 3237c20d332aSBharata B Rao return; 3238c20d332aSBharata B Rao } 32391a5512bbSGonglei if (node < 0 || node >= MAX_NODES) { 32401a5512bbSGonglei error_setg(errp, "Invaild node %d", node); 32411a5512bbSGonglei return; 32421a5512bbSGonglei } 3243c20d332aSBharata B Rao 3244b556854bSBharata B Rao /* 3245b556854bSBharata B Rao * Currently PowerPC kernel doesn't allow hot-adding memory to 3246b556854bSBharata B Rao * memory-less node, but instead will silently add the memory 3247b556854bSBharata B Rao * to the first node that has some memory. This causes two 3248b556854bSBharata B Rao * unexpected behaviours for the user. 3249b556854bSBharata B Rao * 3250b556854bSBharata B Rao * - Memory gets hotplugged to a different node than what the user 3251b556854bSBharata B Rao * specified. 3252b556854bSBharata B Rao * - Since pc-dimm subsystem in QEMU still thinks that memory belongs 3253b556854bSBharata B Rao * to memory-less node, a reboot will set things accordingly 3254b556854bSBharata B Rao * and the previously hotplugged memory now ends in the right node. 3255b556854bSBharata B Rao * This appears as if some memory moved from one node to another. 3256b556854bSBharata B Rao * 3257b556854bSBharata B Rao * So until kernel starts supporting memory hotplug to memory-less 3258b556854bSBharata B Rao * nodes, just prevent such attempts upfront in QEMU. 3259b556854bSBharata B Rao */ 3260b556854bSBharata B Rao if (nb_numa_nodes && !numa_info[node].node_mem) { 3261b556854bSBharata B Rao error_setg(errp, "Can't hotplug memory to memory-less node %d", 3262b556854bSBharata B Rao node); 3263b556854bSBharata B Rao return; 3264b556854bSBharata B Rao } 3265b556854bSBharata B Rao 3266c20d332aSBharata B Rao spapr_memory_plug(hotplug_dev, dev, node, errp); 3267af81cf32SBharata B Rao } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 3268af81cf32SBharata B Rao spapr_core_plug(hotplug_dev, dev, errp); 3269c20d332aSBharata B Rao } 3270c20d332aSBharata B Rao } 3271c20d332aSBharata B Rao 3272cf632463SBharata B Rao static void spapr_machine_device_unplug_request(HotplugHandler *hotplug_dev, 3273cf632463SBharata B Rao DeviceState *dev, Error **errp) 3274cf632463SBharata B Rao { 3275cf632463SBharata B Rao sPAPRMachineState *sms = SPAPR_MACHINE(qdev_get_machine()); 3276cf632463SBharata B Rao MachineClass *mc = MACHINE_GET_CLASS(qdev_get_machine()); 3277cf632463SBharata B Rao 3278cf632463SBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { 3279cf632463SBharata B Rao if (spapr_ovec_test(sms->ov5_cas, OV5_HP_EVT)) { 3280cf632463SBharata B Rao spapr_memory_unplug_request(hotplug_dev, dev, errp); 3281cf632463SBharata B Rao } else { 3282cf632463SBharata B Rao /* NOTE: this means there is a window after guest reset, prior to 3283cf632463SBharata B Rao * CAS negotiation, where unplug requests will fail due to the 3284cf632463SBharata B Rao * capability not being detected yet. This is a bit different than 3285cf632463SBharata B Rao * the case with PCI unplug, where the events will be queued and 3286cf632463SBharata B Rao * eventually handled by the guest after boot 3287cf632463SBharata B Rao */ 3288cf632463SBharata B Rao error_setg(errp, "Memory hot unplug not supported for this guest"); 3289cf632463SBharata B Rao } 32906f4b5c3eSBharata B Rao } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 3291c5514d0eSIgor Mammedov if (!mc->has_hotpluggable_cpus) { 32926f4b5c3eSBharata B Rao error_setg(errp, "CPU hot unplug not supported on this machine"); 32936f4b5c3eSBharata B Rao return; 32946f4b5c3eSBharata B Rao } 3295115debf2SIgor Mammedov spapr_core_unplug_request(hotplug_dev, dev, errp); 3296c20d332aSBharata B Rao } 3297c20d332aSBharata B Rao } 3298c20d332aSBharata B Rao 329994a94e4cSBharata B Rao static void spapr_machine_device_pre_plug(HotplugHandler *hotplug_dev, 330094a94e4cSBharata B Rao DeviceState *dev, Error **errp) 330194a94e4cSBharata B Rao { 3302c871bc70SLaurent Vivier if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { 3303c871bc70SLaurent Vivier spapr_memory_pre_plug(hotplug_dev, dev, errp); 3304c871bc70SLaurent Vivier } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 330594a94e4cSBharata B Rao spapr_core_pre_plug(hotplug_dev, dev, errp); 330694a94e4cSBharata B Rao } 330794a94e4cSBharata B Rao } 330894a94e4cSBharata B Rao 33097ebaf795SBharata B Rao static HotplugHandler *spapr_get_hotplug_handler(MachineState *machine, 3310c20d332aSBharata B Rao DeviceState *dev) 3311c20d332aSBharata B Rao { 331294a94e4cSBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM) || 331394a94e4cSBharata B Rao object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 3314c20d332aSBharata B Rao return HOTPLUG_HANDLER(machine); 3315c20d332aSBharata B Rao } 3316c20d332aSBharata B Rao return NULL; 3317c20d332aSBharata B Rao } 3318c20d332aSBharata B Rao 3319ea089eebSIgor Mammedov static CpuInstanceProperties 3320ea089eebSIgor Mammedov spapr_cpu_index_to_props(MachineState *machine, unsigned cpu_index) 332120bb648dSDavid Gibson { 3322ea089eebSIgor Mammedov CPUArchId *core_slot; 3323ea089eebSIgor Mammedov MachineClass *mc = MACHINE_GET_CLASS(machine); 3324ea089eebSIgor Mammedov 3325ea089eebSIgor Mammedov /* make sure possible_cpu are intialized */ 3326ea089eebSIgor Mammedov mc->possible_cpu_arch_ids(machine); 3327ea089eebSIgor Mammedov /* get CPU core slot containing thread that matches cpu_index */ 3328ea089eebSIgor Mammedov core_slot = spapr_find_cpu_slot(machine, cpu_index, NULL); 3329ea089eebSIgor Mammedov assert(core_slot); 3330ea089eebSIgor Mammedov return core_slot->props; 333120bb648dSDavid Gibson } 333220bb648dSDavid Gibson 3333535455fdSIgor Mammedov static const CPUArchIdList *spapr_possible_cpu_arch_ids(MachineState *machine) 3334535455fdSIgor Mammedov { 3335535455fdSIgor Mammedov int i; 3336535455fdSIgor Mammedov int spapr_max_cores = max_cpus / smp_threads; 3337535455fdSIgor Mammedov MachineClass *mc = MACHINE_GET_CLASS(machine); 3338535455fdSIgor Mammedov 3339c5514d0eSIgor Mammedov if (!mc->has_hotpluggable_cpus) { 3340535455fdSIgor Mammedov spapr_max_cores = QEMU_ALIGN_UP(smp_cpus, smp_threads) / smp_threads; 3341535455fdSIgor Mammedov } 3342535455fdSIgor Mammedov if (machine->possible_cpus) { 3343535455fdSIgor Mammedov assert(machine->possible_cpus->len == spapr_max_cores); 3344535455fdSIgor Mammedov return machine->possible_cpus; 3345535455fdSIgor Mammedov } 3346535455fdSIgor Mammedov 3347535455fdSIgor Mammedov machine->possible_cpus = g_malloc0(sizeof(CPUArchIdList) + 3348535455fdSIgor Mammedov sizeof(CPUArchId) * spapr_max_cores); 3349535455fdSIgor Mammedov machine->possible_cpus->len = spapr_max_cores; 3350535455fdSIgor Mammedov for (i = 0; i < machine->possible_cpus->len; i++) { 3351535455fdSIgor Mammedov int core_id = i * smp_threads; 3352535455fdSIgor Mammedov 3353f2d672c2SIgor Mammedov machine->possible_cpus->cpus[i].vcpus_count = smp_threads; 3354535455fdSIgor Mammedov machine->possible_cpus->cpus[i].arch_id = core_id; 3355535455fdSIgor Mammedov machine->possible_cpus->cpus[i].props.has_core_id = true; 3356535455fdSIgor Mammedov machine->possible_cpus->cpus[i].props.core_id = core_id; 3357ea089eebSIgor Mammedov 3358ea089eebSIgor Mammedov /* default distribution of CPUs over NUMA nodes */ 3359ea089eebSIgor Mammedov if (nb_numa_nodes) { 3360ea089eebSIgor Mammedov /* preset values but do not enable them i.e. 'has_node_id = false', 3361ea089eebSIgor Mammedov * numa init code will enable them later if manual mapping wasn't 3362ea089eebSIgor Mammedov * present on CLI */ 3363ea089eebSIgor Mammedov machine->possible_cpus->cpus[i].props.node_id = 3364ea089eebSIgor Mammedov core_id / smp_threads / smp_cores % nb_numa_nodes; 3365ea089eebSIgor Mammedov } 3366535455fdSIgor Mammedov } 3367535455fdSIgor Mammedov return machine->possible_cpus; 3368535455fdSIgor Mammedov } 3369535455fdSIgor Mammedov 33706737d9adSDavid Gibson static void spapr_phb_placement(sPAPRMachineState *spapr, uint32_t index, 3371daa23699SDavid Gibson uint64_t *buid, hwaddr *pio, 3372daa23699SDavid Gibson hwaddr *mmio32, hwaddr *mmio64, 33736737d9adSDavid Gibson unsigned n_dma, uint32_t *liobns, Error **errp) 33746737d9adSDavid Gibson { 3375357d1e3bSDavid Gibson /* 3376357d1e3bSDavid Gibson * New-style PHB window placement. 3377357d1e3bSDavid Gibson * 3378357d1e3bSDavid Gibson * Goals: Gives large (1TiB), naturally aligned 64-bit MMIO window 3379357d1e3bSDavid Gibson * for each PHB, in addition to 2GiB 32-bit MMIO and 64kiB PIO 3380357d1e3bSDavid Gibson * windows. 3381357d1e3bSDavid Gibson * 3382357d1e3bSDavid Gibson * Some guest kernels can't work with MMIO windows above 1<<46 3383357d1e3bSDavid Gibson * (64TiB), so we place up to 31 PHBs in the area 32TiB..64TiB 3384357d1e3bSDavid Gibson * 3385357d1e3bSDavid Gibson * 32TiB..(33TiB+1984kiB) contains the 64kiB PIO windows for each 3386357d1e3bSDavid Gibson * PHB stacked together. (32TiB+2GiB)..(32TiB+64GiB) contains the 3387357d1e3bSDavid Gibson * 2GiB 32-bit MMIO windows for each PHB. Then 33..64TiB has the 3388357d1e3bSDavid Gibson * 1TiB 64-bit MMIO windows for each PHB. 3389357d1e3bSDavid Gibson */ 33906737d9adSDavid Gibson const uint64_t base_buid = 0x800000020000000ULL; 339125e6a118SMichael S. Tsirkin #define SPAPR_MAX_PHBS ((SPAPR_PCI_LIMIT - SPAPR_PCI_BASE) / \ 339225e6a118SMichael S. Tsirkin SPAPR_PCI_MEM64_WIN_SIZE - 1) 33936737d9adSDavid Gibson int i; 33946737d9adSDavid Gibson 3395357d1e3bSDavid Gibson /* Sanity check natural alignments */ 3396357d1e3bSDavid Gibson QEMU_BUILD_BUG_ON((SPAPR_PCI_BASE % SPAPR_PCI_MEM64_WIN_SIZE) != 0); 3397357d1e3bSDavid Gibson QEMU_BUILD_BUG_ON((SPAPR_PCI_LIMIT % SPAPR_PCI_MEM64_WIN_SIZE) != 0); 3398357d1e3bSDavid Gibson QEMU_BUILD_BUG_ON((SPAPR_PCI_MEM64_WIN_SIZE % SPAPR_PCI_MEM32_WIN_SIZE) != 0); 3399357d1e3bSDavid Gibson QEMU_BUILD_BUG_ON((SPAPR_PCI_MEM32_WIN_SIZE % SPAPR_PCI_IO_WIN_SIZE) != 0); 3400357d1e3bSDavid Gibson /* Sanity check bounds */ 340125e6a118SMichael S. Tsirkin QEMU_BUILD_BUG_ON((SPAPR_MAX_PHBS * SPAPR_PCI_IO_WIN_SIZE) > 340225e6a118SMichael S. Tsirkin SPAPR_PCI_MEM32_WIN_SIZE); 340325e6a118SMichael S. Tsirkin QEMU_BUILD_BUG_ON((SPAPR_MAX_PHBS * SPAPR_PCI_MEM32_WIN_SIZE) > 340425e6a118SMichael S. Tsirkin SPAPR_PCI_MEM64_WIN_SIZE); 34052efff1c0SDavid Gibson 340625e6a118SMichael S. Tsirkin if (index >= SPAPR_MAX_PHBS) { 340725e6a118SMichael S. Tsirkin error_setg(errp, "\"index\" for PAPR PHB is too large (max %llu)", 340825e6a118SMichael S. Tsirkin SPAPR_MAX_PHBS - 1); 34096737d9adSDavid Gibson return; 34106737d9adSDavid Gibson } 34116737d9adSDavid Gibson 34126737d9adSDavid Gibson *buid = base_buid + index; 34136737d9adSDavid Gibson for (i = 0; i < n_dma; ++i) { 34146737d9adSDavid Gibson liobns[i] = SPAPR_PCI_LIOBN(index, i); 34156737d9adSDavid Gibson } 34166737d9adSDavid Gibson 3417357d1e3bSDavid Gibson *pio = SPAPR_PCI_BASE + index * SPAPR_PCI_IO_WIN_SIZE; 3418357d1e3bSDavid Gibson *mmio32 = SPAPR_PCI_BASE + (index + 1) * SPAPR_PCI_MEM32_WIN_SIZE; 3419357d1e3bSDavid Gibson *mmio64 = SPAPR_PCI_BASE + (index + 1) * SPAPR_PCI_MEM64_WIN_SIZE; 34206737d9adSDavid Gibson } 34216737d9adSDavid Gibson 34227844e12bSCédric Le Goater static ICSState *spapr_ics_get(XICSFabric *dev, int irq) 34237844e12bSCédric Le Goater { 34247844e12bSCédric Le Goater sPAPRMachineState *spapr = SPAPR_MACHINE(dev); 34257844e12bSCédric Le Goater 34267844e12bSCédric Le Goater return ics_valid_irq(spapr->ics, irq) ? spapr->ics : NULL; 34277844e12bSCédric Le Goater } 34287844e12bSCédric Le Goater 34297844e12bSCédric Le Goater static void spapr_ics_resend(XICSFabric *dev) 34307844e12bSCédric Le Goater { 34317844e12bSCédric Le Goater sPAPRMachineState *spapr = SPAPR_MACHINE(dev); 34327844e12bSCédric Le Goater 34337844e12bSCédric Le Goater ics_resend(spapr->ics); 34347844e12bSCédric Le Goater } 34357844e12bSCédric Le Goater 343606747ba6SCédric Le Goater static ICPState *spapr_icp_get(XICSFabric *xi, int cpu_dt_id) 3437b2fc59aaSCédric Le Goater { 34385bc8d26dSCédric Le Goater PowerPCCPU *cpu = ppc_get_vcpu_by_dt_id(cpu_dt_id); 3439b2fc59aaSCédric Le Goater 34405bc8d26dSCédric Le Goater return cpu ? ICP(cpu->intc) : NULL; 3441b2fc59aaSCédric Le Goater } 3442b2fc59aaSCédric Le Goater 34436449da45SCédric Le Goater static void spapr_pic_print_info(InterruptStatsProvider *obj, 34446449da45SCédric Le Goater Monitor *mon) 34456449da45SCédric Le Goater { 34466449da45SCédric Le Goater sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 34475bc8d26dSCédric Le Goater CPUState *cs; 34486449da45SCédric Le Goater 34495bc8d26dSCédric Le Goater CPU_FOREACH(cs) { 34505bc8d26dSCédric Le Goater PowerPCCPU *cpu = POWERPC_CPU(cs); 34515bc8d26dSCédric Le Goater 34525bc8d26dSCédric Le Goater icp_pic_print_info(ICP(cpu->intc), mon); 34536449da45SCédric Le Goater } 34546449da45SCédric Le Goater 34556449da45SCédric Le Goater ics_pic_print_info(spapr->ics, mon); 34566449da45SCédric Le Goater } 34576449da45SCédric Le Goater 345829ee3247SAlexey Kardashevskiy static void spapr_machine_class_init(ObjectClass *oc, void *data) 345953018216SPaolo Bonzini { 346029ee3247SAlexey Kardashevskiy MachineClass *mc = MACHINE_CLASS(oc); 3461224245bfSDavid Gibson sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(oc); 346271461b0fSAlexey Kardashevskiy FWPathProviderClass *fwc = FW_PATH_PROVIDER_CLASS(oc); 346334316482SAlexey Kardashevskiy NMIClass *nc = NMI_CLASS(oc); 3464c20d332aSBharata B Rao HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(oc); 34651d1be34dSDavid Gibson PPCVirtualHypervisorClass *vhc = PPC_VIRTUAL_HYPERVISOR_CLASS(oc); 34667844e12bSCédric Le Goater XICSFabricClass *xic = XICS_FABRIC_CLASS(oc); 34676449da45SCédric Le Goater InterruptStatsProviderClass *ispc = INTERRUPT_STATS_PROVIDER_CLASS(oc); 346829ee3247SAlexey Kardashevskiy 34690eb9054cSDavid Gibson mc->desc = "pSeries Logical Partition (PAPR compliant)"; 3470fc9f38c3SDavid Gibson 3471fc9f38c3SDavid Gibson /* 3472fc9f38c3SDavid Gibson * We set up the default / latest behaviour here. The class_init 3473fc9f38c3SDavid Gibson * functions for the specific versioned machine types can override 3474fc9f38c3SDavid Gibson * these details for backwards compatibility 3475fc9f38c3SDavid Gibson */ 3476958db90cSMarcel Apfelbaum mc->init = ppc_spapr_init; 3477958db90cSMarcel Apfelbaum mc->reset = ppc_spapr_reset; 3478958db90cSMarcel Apfelbaum mc->block_default_type = IF_SCSI; 34796244bb7eSGreg Kurz mc->max_cpus = 1024; 3480958db90cSMarcel Apfelbaum mc->no_parallel = 1; 34815b2128d2SAlexander Graf mc->default_boot_order = ""; 3482a34944feSNikunj A Dadhania mc->default_ram_size = 512 * M_BYTE; 3483958db90cSMarcel Apfelbaum mc->kvm_type = spapr_kvm_type; 34849e3f9733SAlexander Graf mc->has_dynamic_sysbus = true; 3485e4024630SLaurent Vivier mc->pci_allow_0_address = true; 34867ebaf795SBharata B Rao mc->get_hotplug_handler = spapr_get_hotplug_handler; 348794a94e4cSBharata B Rao hc->pre_plug = spapr_machine_device_pre_plug; 3488c20d332aSBharata B Rao hc->plug = spapr_machine_device_plug; 3489ea089eebSIgor Mammedov mc->cpu_index_to_instance_props = spapr_cpu_index_to_props; 3490535455fdSIgor Mammedov mc->possible_cpu_arch_ids = spapr_possible_cpu_arch_ids; 3491cf632463SBharata B Rao hc->unplug_request = spapr_machine_device_unplug_request; 349200b4fbe2SMarcel Apfelbaum 3493fc9f38c3SDavid Gibson smc->dr_lmb_enabled = true; 34943daa4a9fSThomas Huth smc->tcg_default_cpu = "POWER8"; 3495c5514d0eSIgor Mammedov mc->has_hotpluggable_cpus = true; 349652b81ab5SDavid Gibson smc->resize_hpt_default = SPAPR_RESIZE_HPT_ENABLED; 349771461b0fSAlexey Kardashevskiy fwc->get_dev_path = spapr_get_fw_dev_path; 349834316482SAlexey Kardashevskiy nc->nmi_monitor_handler = spapr_nmi; 34996737d9adSDavid Gibson smc->phb_placement = spapr_phb_placement; 35001d1be34dSDavid Gibson vhc->hypercall = emulate_spapr_hypercall; 3501e57ca75cSDavid Gibson vhc->hpt_mask = spapr_hpt_mask; 3502e57ca75cSDavid Gibson vhc->map_hptes = spapr_map_hptes; 3503e57ca75cSDavid Gibson vhc->unmap_hptes = spapr_unmap_hptes; 3504e57ca75cSDavid Gibson vhc->store_hpte = spapr_store_hpte; 35059861bb3eSSuraj Jitindar Singh vhc->get_patbe = spapr_get_patbe; 35067844e12bSCédric Le Goater xic->ics_get = spapr_ics_get; 35077844e12bSCédric Le Goater xic->ics_resend = spapr_ics_resend; 3508b2fc59aaSCédric Le Goater xic->icp_get = spapr_icp_get; 35096449da45SCédric Le Goater ispc->print_info = spapr_pic_print_info; 351055641213SLaurent Vivier /* Force NUMA node memory size to be a multiple of 351155641213SLaurent Vivier * SPAPR_MEMORY_BLOCK_SIZE (256M) since that's the granularity 351255641213SLaurent Vivier * in which LMBs are represented and hot-added 351355641213SLaurent Vivier */ 351455641213SLaurent Vivier mc->numa_mem_align_shift = 28; 351553018216SPaolo Bonzini } 351653018216SPaolo Bonzini 351729ee3247SAlexey Kardashevskiy static const TypeInfo spapr_machine_info = { 351829ee3247SAlexey Kardashevskiy .name = TYPE_SPAPR_MACHINE, 351929ee3247SAlexey Kardashevskiy .parent = TYPE_MACHINE, 35204aee7362SDavid Gibson .abstract = true, 35216ca1502eSAlexey Kardashevskiy .instance_size = sizeof(sPAPRMachineState), 352223825581SEduardo Habkost .instance_init = spapr_machine_initfn, 352387bbdd9cSDavid Gibson .instance_finalize = spapr_machine_finalizefn, 3524183930c0SDavid Gibson .class_size = sizeof(sPAPRMachineClass), 352529ee3247SAlexey Kardashevskiy .class_init = spapr_machine_class_init, 352671461b0fSAlexey Kardashevskiy .interfaces = (InterfaceInfo[]) { 352771461b0fSAlexey Kardashevskiy { TYPE_FW_PATH_PROVIDER }, 352834316482SAlexey Kardashevskiy { TYPE_NMI }, 3529c20d332aSBharata B Rao { TYPE_HOTPLUG_HANDLER }, 35301d1be34dSDavid Gibson { TYPE_PPC_VIRTUAL_HYPERVISOR }, 35317844e12bSCédric Le Goater { TYPE_XICS_FABRIC }, 35326449da45SCédric Le Goater { TYPE_INTERRUPT_STATS_PROVIDER }, 353371461b0fSAlexey Kardashevskiy { } 353471461b0fSAlexey Kardashevskiy }, 353529ee3247SAlexey Kardashevskiy }; 353629ee3247SAlexey Kardashevskiy 3537fccbc785SDavid Gibson #define DEFINE_SPAPR_MACHINE(suffix, verstr, latest) \ 35385013c547SDavid Gibson static void spapr_machine_##suffix##_class_init(ObjectClass *oc, \ 35395013c547SDavid Gibson void *data) \ 35405013c547SDavid Gibson { \ 35415013c547SDavid Gibson MachineClass *mc = MACHINE_CLASS(oc); \ 35425013c547SDavid Gibson spapr_machine_##suffix##_class_options(mc); \ 3543fccbc785SDavid Gibson if (latest) { \ 3544fccbc785SDavid Gibson mc->alias = "pseries"; \ 3545fccbc785SDavid Gibson mc->is_default = 1; \ 3546fccbc785SDavid Gibson } \ 35475013c547SDavid Gibson } \ 35485013c547SDavid Gibson static void spapr_machine_##suffix##_instance_init(Object *obj) \ 35495013c547SDavid Gibson { \ 35505013c547SDavid Gibson MachineState *machine = MACHINE(obj); \ 35515013c547SDavid Gibson spapr_machine_##suffix##_instance_options(machine); \ 35525013c547SDavid Gibson } \ 35535013c547SDavid Gibson static const TypeInfo spapr_machine_##suffix##_info = { \ 35545013c547SDavid Gibson .name = MACHINE_TYPE_NAME("pseries-" verstr), \ 35555013c547SDavid Gibson .parent = TYPE_SPAPR_MACHINE, \ 35565013c547SDavid Gibson .class_init = spapr_machine_##suffix##_class_init, \ 35575013c547SDavid Gibson .instance_init = spapr_machine_##suffix##_instance_init, \ 35585013c547SDavid Gibson }; \ 35595013c547SDavid Gibson static void spapr_machine_register_##suffix(void) \ 35605013c547SDavid Gibson { \ 35615013c547SDavid Gibson type_register(&spapr_machine_##suffix##_info); \ 35625013c547SDavid Gibson } \ 35630e6aac87SEduardo Habkost type_init(spapr_machine_register_##suffix) 35645013c547SDavid Gibson 35651c5f29bbSDavid Gibson /* 35663fa14fbeSDavid Gibson * pseries-2.10 3567db800b21SDavid Gibson */ 35683fa14fbeSDavid Gibson static void spapr_machine_2_10_instance_options(MachineState *machine) 3569db800b21SDavid Gibson { 3570db800b21SDavid Gibson } 3571db800b21SDavid Gibson 35723fa14fbeSDavid Gibson static void spapr_machine_2_10_class_options(MachineClass *mc) 3573db800b21SDavid Gibson { 3574db800b21SDavid Gibson /* Defaults for the latest behaviour inherited from the base class */ 3575db800b21SDavid Gibson } 3576db800b21SDavid Gibson 35773fa14fbeSDavid Gibson DEFINE_SPAPR_MACHINE(2_10, "2.10", true); 35783fa14fbeSDavid Gibson 35793fa14fbeSDavid Gibson /* 35803fa14fbeSDavid Gibson * pseries-2.9 35813fa14fbeSDavid Gibson */ 35823fa14fbeSDavid Gibson #define SPAPR_COMPAT_2_9 \ 3583d5fc133eSDavid Gibson HW_COMPAT_2_9 \ 3584d5fc133eSDavid Gibson { \ 3585d5fc133eSDavid Gibson .driver = TYPE_POWERPC_CPU, \ 3586d5fc133eSDavid Gibson .property = "pre-2.10-migration", \ 3587d5fc133eSDavid Gibson .value = "on", \ 3588d5fc133eSDavid Gibson }, \ 35893fa14fbeSDavid Gibson 35903fa14fbeSDavid Gibson static void spapr_machine_2_9_instance_options(MachineState *machine) 35913fa14fbeSDavid Gibson { 35923fa14fbeSDavid Gibson spapr_machine_2_10_instance_options(machine); 35933fa14fbeSDavid Gibson } 35943fa14fbeSDavid Gibson 35953fa14fbeSDavid Gibson static void spapr_machine_2_9_class_options(MachineClass *mc) 35963fa14fbeSDavid Gibson { 359746f7afa3SGreg Kurz sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); 359846f7afa3SGreg Kurz 35993fa14fbeSDavid Gibson spapr_machine_2_10_class_options(mc); 36003fa14fbeSDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_9); 36013bfe5716SLaurent Vivier mc->numa_auto_assign_ram = numa_legacy_auto_assign_ram; 360246f7afa3SGreg Kurz smc->pre_2_10_has_unused_icps = true; 360352b81ab5SDavid Gibson smc->resize_hpt_default = SPAPR_RESIZE_HPT_DISABLED; 36043fa14fbeSDavid Gibson } 36053fa14fbeSDavid Gibson 36063fa14fbeSDavid Gibson DEFINE_SPAPR_MACHINE(2_9, "2.9", false); 3607fa325e6cSDavid Gibson 3608fa325e6cSDavid Gibson /* 3609fa325e6cSDavid Gibson * pseries-2.8 3610fa325e6cSDavid Gibson */ 3611fa325e6cSDavid Gibson #define SPAPR_COMPAT_2_8 \ 361282516263SDavid Gibson HW_COMPAT_2_8 \ 361382516263SDavid Gibson { \ 361482516263SDavid Gibson .driver = TYPE_SPAPR_PCI_HOST_BRIDGE, \ 361582516263SDavid Gibson .property = "pcie-extended-configuration-space", \ 361682516263SDavid Gibson .value = "off", \ 361782516263SDavid Gibson }, 3618fa325e6cSDavid Gibson 3619fa325e6cSDavid Gibson static void spapr_machine_2_8_instance_options(MachineState *machine) 3620fa325e6cSDavid Gibson { 3621fa325e6cSDavid Gibson spapr_machine_2_9_instance_options(machine); 3622fa325e6cSDavid Gibson } 3623fa325e6cSDavid Gibson 3624fa325e6cSDavid Gibson static void spapr_machine_2_8_class_options(MachineClass *mc) 3625fa325e6cSDavid Gibson { 3626fa325e6cSDavid Gibson spapr_machine_2_9_class_options(mc); 3627fa325e6cSDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_8); 362855641213SLaurent Vivier mc->numa_mem_align_shift = 23; 3629fa325e6cSDavid Gibson } 3630fa325e6cSDavid Gibson 3631fa325e6cSDavid Gibson DEFINE_SPAPR_MACHINE(2_8, "2.8", false); 3632db800b21SDavid Gibson 3633db800b21SDavid Gibson /* 36341ea1eefcSBharata B Rao * pseries-2.7 36351ea1eefcSBharata B Rao */ 3636db800b21SDavid Gibson #define SPAPR_COMPAT_2_7 \ 3637db800b21SDavid Gibson HW_COMPAT_2_7 \ 3638357d1e3bSDavid Gibson { \ 3639357d1e3bSDavid Gibson .driver = TYPE_SPAPR_PCI_HOST_BRIDGE, \ 3640357d1e3bSDavid Gibson .property = "mem_win_size", \ 3641357d1e3bSDavid Gibson .value = stringify(SPAPR_PCI_2_7_MMIO_WIN_SIZE),\ 3642357d1e3bSDavid Gibson }, \ 3643357d1e3bSDavid Gibson { \ 3644357d1e3bSDavid Gibson .driver = TYPE_SPAPR_PCI_HOST_BRIDGE, \ 3645357d1e3bSDavid Gibson .property = "mem64_win_size", \ 3646357d1e3bSDavid Gibson .value = "0", \ 3647146c11f1SDavid Gibson }, \ 3648146c11f1SDavid Gibson { \ 3649146c11f1SDavid Gibson .driver = TYPE_POWERPC_CPU, \ 3650146c11f1SDavid Gibson .property = "pre-2.8-migration", \ 3651146c11f1SDavid Gibson .value = "on", \ 36525c4537bdSDavid Gibson }, \ 36535c4537bdSDavid Gibson { \ 36545c4537bdSDavid Gibson .driver = TYPE_SPAPR_PCI_HOST_BRIDGE, \ 36555c4537bdSDavid Gibson .property = "pre-2.8-migration", \ 36565c4537bdSDavid Gibson .value = "on", \ 3657357d1e3bSDavid Gibson }, 3658357d1e3bSDavid Gibson 3659357d1e3bSDavid Gibson static void phb_placement_2_7(sPAPRMachineState *spapr, uint32_t index, 3660357d1e3bSDavid Gibson uint64_t *buid, hwaddr *pio, 3661357d1e3bSDavid Gibson hwaddr *mmio32, hwaddr *mmio64, 3662357d1e3bSDavid Gibson unsigned n_dma, uint32_t *liobns, Error **errp) 3663357d1e3bSDavid Gibson { 3664357d1e3bSDavid Gibson /* Legacy PHB placement for pseries-2.7 and earlier machine types */ 3665357d1e3bSDavid Gibson const uint64_t base_buid = 0x800000020000000ULL; 3666357d1e3bSDavid Gibson const hwaddr phb_spacing = 0x1000000000ULL; /* 64 GiB */ 3667357d1e3bSDavid Gibson const hwaddr mmio_offset = 0xa0000000; /* 2 GiB + 512 MiB */ 3668357d1e3bSDavid Gibson const hwaddr pio_offset = 0x80000000; /* 2 GiB */ 3669357d1e3bSDavid Gibson const uint32_t max_index = 255; 3670357d1e3bSDavid Gibson const hwaddr phb0_alignment = 0x10000000000ULL; /* 1 TiB */ 3671357d1e3bSDavid Gibson 3672357d1e3bSDavid Gibson uint64_t ram_top = MACHINE(spapr)->ram_size; 3673357d1e3bSDavid Gibson hwaddr phb0_base, phb_base; 3674357d1e3bSDavid Gibson int i; 3675357d1e3bSDavid Gibson 3676357d1e3bSDavid Gibson /* Do we have hotpluggable memory? */ 3677357d1e3bSDavid Gibson if (MACHINE(spapr)->maxram_size > ram_top) { 3678357d1e3bSDavid Gibson /* Can't just use maxram_size, because there may be an 3679357d1e3bSDavid Gibson * alignment gap between normal and hotpluggable memory 3680357d1e3bSDavid Gibson * regions */ 3681357d1e3bSDavid Gibson ram_top = spapr->hotplug_memory.base + 3682357d1e3bSDavid Gibson memory_region_size(&spapr->hotplug_memory.mr); 3683357d1e3bSDavid Gibson } 3684357d1e3bSDavid Gibson 3685357d1e3bSDavid Gibson phb0_base = QEMU_ALIGN_UP(ram_top, phb0_alignment); 3686357d1e3bSDavid Gibson 3687357d1e3bSDavid Gibson if (index > max_index) { 3688357d1e3bSDavid Gibson error_setg(errp, "\"index\" for PAPR PHB is too large (max %u)", 3689357d1e3bSDavid Gibson max_index); 3690357d1e3bSDavid Gibson return; 3691357d1e3bSDavid Gibson } 3692357d1e3bSDavid Gibson 3693357d1e3bSDavid Gibson *buid = base_buid + index; 3694357d1e3bSDavid Gibson for (i = 0; i < n_dma; ++i) { 3695357d1e3bSDavid Gibson liobns[i] = SPAPR_PCI_LIOBN(index, i); 3696357d1e3bSDavid Gibson } 3697357d1e3bSDavid Gibson 3698357d1e3bSDavid Gibson phb_base = phb0_base + index * phb_spacing; 3699357d1e3bSDavid Gibson *pio = phb_base + pio_offset; 3700357d1e3bSDavid Gibson *mmio32 = phb_base + mmio_offset; 3701357d1e3bSDavid Gibson /* 3702357d1e3bSDavid Gibson * We don't set the 64-bit MMIO window, relying on the PHB's 3703357d1e3bSDavid Gibson * fallback behaviour of automatically splitting a large "32-bit" 3704357d1e3bSDavid Gibson * window into contiguous 32-bit and 64-bit windows 3705357d1e3bSDavid Gibson */ 3706357d1e3bSDavid Gibson } 3707db800b21SDavid Gibson 37081ea1eefcSBharata B Rao static void spapr_machine_2_7_instance_options(MachineState *machine) 37091ea1eefcSBharata B Rao { 3710f6229214SMichael Roth sPAPRMachineState *spapr = SPAPR_MACHINE(machine); 3711f6229214SMichael Roth 3712672de881SMichael Roth spapr_machine_2_8_instance_options(machine); 3713f6229214SMichael Roth spapr->use_hotplug_event_source = false; 37141ea1eefcSBharata B Rao } 37151ea1eefcSBharata B Rao 37161ea1eefcSBharata B Rao static void spapr_machine_2_7_class_options(MachineClass *mc) 37171ea1eefcSBharata B Rao { 37183daa4a9fSThomas Huth sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); 37193daa4a9fSThomas Huth 3720db800b21SDavid Gibson spapr_machine_2_8_class_options(mc); 37213daa4a9fSThomas Huth smc->tcg_default_cpu = "POWER7"; 3722db800b21SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_7); 3723357d1e3bSDavid Gibson smc->phb_placement = phb_placement_2_7; 37241ea1eefcSBharata B Rao } 37251ea1eefcSBharata B Rao 3726db800b21SDavid Gibson DEFINE_SPAPR_MACHINE(2_7, "2.7", false); 37271ea1eefcSBharata B Rao 37281ea1eefcSBharata B Rao /* 37294b23699cSDavid Gibson * pseries-2.6 37304b23699cSDavid Gibson */ 37311ea1eefcSBharata B Rao #define SPAPR_COMPAT_2_6 \ 3732ae4de14cSAlexey Kardashevskiy HW_COMPAT_2_6 \ 3733ae4de14cSAlexey Kardashevskiy { \ 3734ae4de14cSAlexey Kardashevskiy .driver = TYPE_SPAPR_PCI_HOST_BRIDGE,\ 3735ae4de14cSAlexey Kardashevskiy .property = "ddw",\ 3736ae4de14cSAlexey Kardashevskiy .value = stringify(off),\ 3737ae4de14cSAlexey Kardashevskiy }, 37381ea1eefcSBharata B Rao 37394b23699cSDavid Gibson static void spapr_machine_2_6_instance_options(MachineState *machine) 37404b23699cSDavid Gibson { 3741672de881SMichael Roth spapr_machine_2_7_instance_options(machine); 37424b23699cSDavid Gibson } 37434b23699cSDavid Gibson 37444b23699cSDavid Gibson static void spapr_machine_2_6_class_options(MachineClass *mc) 37454b23699cSDavid Gibson { 37461ea1eefcSBharata B Rao spapr_machine_2_7_class_options(mc); 3747c5514d0eSIgor Mammedov mc->has_hotpluggable_cpus = false; 37481ea1eefcSBharata B Rao SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_6); 37494b23699cSDavid Gibson } 37504b23699cSDavid Gibson 37511ea1eefcSBharata B Rao DEFINE_SPAPR_MACHINE(2_6, "2.6", false); 37524b23699cSDavid Gibson 37534b23699cSDavid Gibson /* 37541c5f29bbSDavid Gibson * pseries-2.5 37551c5f29bbSDavid Gibson */ 37564b23699cSDavid Gibson #define SPAPR_COMPAT_2_5 \ 375757c522f4SThomas Huth HW_COMPAT_2_5 \ 375857c522f4SThomas Huth { \ 375957c522f4SThomas Huth .driver = "spapr-vlan", \ 376057c522f4SThomas Huth .property = "use-rx-buffer-pools", \ 376157c522f4SThomas Huth .value = "off", \ 376257c522f4SThomas Huth }, 37634b23699cSDavid Gibson 37645013c547SDavid Gibson static void spapr_machine_2_5_instance_options(MachineState *machine) 37651c5f29bbSDavid Gibson { 3766672de881SMichael Roth spapr_machine_2_6_instance_options(machine); 37675013c547SDavid Gibson } 37685013c547SDavid Gibson 37695013c547SDavid Gibson static void spapr_machine_2_5_class_options(MachineClass *mc) 37705013c547SDavid Gibson { 377157040d45SThomas Huth sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); 377257040d45SThomas Huth 37734b23699cSDavid Gibson spapr_machine_2_6_class_options(mc); 377457040d45SThomas Huth smc->use_ohci_by_default = true; 37754b23699cSDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_5); 37761c5f29bbSDavid Gibson } 37771c5f29bbSDavid Gibson 37784b23699cSDavid Gibson DEFINE_SPAPR_MACHINE(2_5, "2.5", false); 37791c5f29bbSDavid Gibson 37801c5f29bbSDavid Gibson /* 37811c5f29bbSDavid Gibson * pseries-2.4 37821c5f29bbSDavid Gibson */ 378380fd50f9SCornelia Huck #define SPAPR_COMPAT_2_4 \ 378480fd50f9SCornelia Huck HW_COMPAT_2_4 378580fd50f9SCornelia Huck 37865013c547SDavid Gibson static void spapr_machine_2_4_instance_options(MachineState *machine) 37871c5f29bbSDavid Gibson { 37885013c547SDavid Gibson spapr_machine_2_5_instance_options(machine); 37895013c547SDavid Gibson } 37901c5f29bbSDavid Gibson 37915013c547SDavid Gibson static void spapr_machine_2_4_class_options(MachineClass *mc) 37925013c547SDavid Gibson { 3793fc9f38c3SDavid Gibson sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); 3794fc9f38c3SDavid Gibson 3795fc9f38c3SDavid Gibson spapr_machine_2_5_class_options(mc); 3796fc9f38c3SDavid Gibson smc->dr_lmb_enabled = false; 3797f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_4); 37981c5f29bbSDavid Gibson } 37991c5f29bbSDavid Gibson 3800fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_4, "2.4", false); 38011c5f29bbSDavid Gibson 38021c5f29bbSDavid Gibson /* 38031c5f29bbSDavid Gibson * pseries-2.3 38041c5f29bbSDavid Gibson */ 380538ff32c6SEduardo Habkost #define SPAPR_COMPAT_2_3 \ 38067619c7b0SMichael Roth HW_COMPAT_2_3 \ 38077619c7b0SMichael Roth {\ 38087619c7b0SMichael Roth .driver = "spapr-pci-host-bridge",\ 38097619c7b0SMichael Roth .property = "dynamic-reconfiguration",\ 38107619c7b0SMichael Roth .value = "off",\ 38117619c7b0SMichael Roth }, 381238ff32c6SEduardo Habkost 38135013c547SDavid Gibson static void spapr_machine_2_3_instance_options(MachineState *machine) 38141c5f29bbSDavid Gibson { 38155013c547SDavid Gibson spapr_machine_2_4_instance_options(machine); 38161c5f29bbSDavid Gibson } 38171c5f29bbSDavid Gibson 38185013c547SDavid Gibson static void spapr_machine_2_3_class_options(MachineClass *mc) 38191c5f29bbSDavid Gibson { 3820fc9f38c3SDavid Gibson spapr_machine_2_4_class_options(mc); 3821f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_3); 38221c5f29bbSDavid Gibson } 3823fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_3, "2.3", false); 38241c5f29bbSDavid Gibson 38251c5f29bbSDavid Gibson /* 38261c5f29bbSDavid Gibson * pseries-2.2 38271c5f29bbSDavid Gibson */ 38281c5f29bbSDavid Gibson 3829b194df47SAlexey Kardashevskiy #define SPAPR_COMPAT_2_2 \ 38304dfd8eaaSEduardo Habkost HW_COMPAT_2_2 \ 3831b194df47SAlexey Kardashevskiy {\ 3832b194df47SAlexey Kardashevskiy .driver = TYPE_SPAPR_PCI_HOST_BRIDGE,\ 3833b194df47SAlexey Kardashevskiy .property = "mem_win_size",\ 3834b194df47SAlexey Kardashevskiy .value = "0x20000000",\ 3835dd754bafSEduardo Habkost }, 3836b194df47SAlexey Kardashevskiy 38375013c547SDavid Gibson static void spapr_machine_2_2_instance_options(MachineState *machine) 3838b0e966d0SJason Wang { 38395013c547SDavid Gibson spapr_machine_2_3_instance_options(machine); 3840cba0e779SGreg Kurz machine->suppress_vmdesc = true; 3841b0e966d0SJason Wang } 3842b0e966d0SJason Wang 38435013c547SDavid Gibson static void spapr_machine_2_2_class_options(MachineClass *mc) 3844b0e966d0SJason Wang { 3845fc9f38c3SDavid Gibson spapr_machine_2_3_class_options(mc); 3846f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_2); 38471c5f29bbSDavid Gibson } 3848fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_2, "2.2", false); 38491c5f29bbSDavid Gibson 38501c5f29bbSDavid Gibson /* 38511c5f29bbSDavid Gibson * pseries-2.1 38521c5f29bbSDavid Gibson */ 38531c5f29bbSDavid Gibson #define SPAPR_COMPAT_2_1 \ 38541c5f29bbSDavid Gibson HW_COMPAT_2_1 38551c5f29bbSDavid Gibson 38565013c547SDavid Gibson static void spapr_machine_2_1_instance_options(MachineState *machine) 38571c5f29bbSDavid Gibson { 38585013c547SDavid Gibson spapr_machine_2_2_instance_options(machine); 38591c5f29bbSDavid Gibson } 38601c5f29bbSDavid Gibson 38615013c547SDavid Gibson static void spapr_machine_2_1_class_options(MachineClass *mc) 3862b0e966d0SJason Wang { 3863fc9f38c3SDavid Gibson spapr_machine_2_2_class_options(mc); 3864f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_1); 38656026db45SAlexey Kardashevskiy } 3866fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_1, "2.1", false); 38676026db45SAlexey Kardashevskiy 386829ee3247SAlexey Kardashevskiy static void spapr_machine_register_types(void) 386929ee3247SAlexey Kardashevskiy { 387029ee3247SAlexey Kardashevskiy type_register_static(&spapr_machine_info); 387129ee3247SAlexey Kardashevskiy } 387229ee3247SAlexey Kardashevskiy 387329ee3247SAlexey Kardashevskiy type_init(spapr_machine_register_types) 3874