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" 41ff14e817SDr. David Alan Gilbert #include "migration/migration.h" 424be21d56SDavid Gibson #include "mmu-hash64.h" 43b4db5413SSuraj Jitindar Singh #include "mmu-book3s-v3.h" 443794d548SAlexey Kardashevskiy #include "qom/cpu.h" 4553018216SPaolo Bonzini 4653018216SPaolo Bonzini #include "hw/boards.h" 470d09e41aSPaolo Bonzini #include "hw/ppc/ppc.h" 4853018216SPaolo Bonzini #include "hw/loader.h" 4953018216SPaolo Bonzini 507804c353SCédric Le Goater #include "hw/ppc/fdt.h" 510d09e41aSPaolo Bonzini #include "hw/ppc/spapr.h" 520d09e41aSPaolo Bonzini #include "hw/ppc/spapr_vio.h" 530d09e41aSPaolo Bonzini #include "hw/pci-host/spapr.h" 540d09e41aSPaolo Bonzini #include "hw/ppc/xics.h" 5553018216SPaolo Bonzini #include "hw/pci/msi.h" 5653018216SPaolo Bonzini 5753018216SPaolo Bonzini #include "hw/pci/pci.h" 5871461b0fSAlexey Kardashevskiy #include "hw/scsi/scsi.h" 5971461b0fSAlexey Kardashevskiy #include "hw/virtio/virtio-scsi.h" 6053018216SPaolo Bonzini 6153018216SPaolo Bonzini #include "exec/address-spaces.h" 6253018216SPaolo Bonzini #include "hw/usb.h" 6353018216SPaolo Bonzini #include "qemu/config-file.h" 64135a129aSAneesh Kumar K.V #include "qemu/error-report.h" 652a6593cbSAlexey Kardashevskiy #include "trace.h" 6634316482SAlexey Kardashevskiy #include "hw/nmi.h" 676449da45SCédric Le Goater #include "hw/intc/intc.h" 6853018216SPaolo Bonzini 6968a27b20SMichael S. Tsirkin #include "hw/compat.h" 70f348b6d1SVeronia Bahaa #include "qemu/cutils.h" 7194a94e4cSBharata B Rao #include "hw/ppc/spapr_cpu_core.h" 722474bfd4SIgor Mammedov #include "qmp-commands.h" 7368a27b20SMichael S. Tsirkin 7453018216SPaolo Bonzini #include <libfdt.h> 7553018216SPaolo Bonzini 7653018216SPaolo Bonzini /* SLOF memory layout: 7753018216SPaolo Bonzini * 7853018216SPaolo Bonzini * SLOF raw image loaded at 0, copies its romfs right below the flat 7953018216SPaolo Bonzini * device-tree, then position SLOF itself 31M below that 8053018216SPaolo Bonzini * 8153018216SPaolo Bonzini * So we set FW_OVERHEAD to 40MB which should account for all of that 8253018216SPaolo Bonzini * and more 8353018216SPaolo Bonzini * 8453018216SPaolo Bonzini * We load our kernel at 4M, leaving space for SLOF initial image 8553018216SPaolo Bonzini */ 8638b02bd8SAlexey Kardashevskiy #define FDT_MAX_SIZE 0x100000 8753018216SPaolo Bonzini #define RTAS_MAX_SIZE 0x10000 88b7d1f77aSBenjamin Herrenschmidt #define RTAS_MAX_ADDR 0x80000000 /* RTAS must stay below that */ 8953018216SPaolo Bonzini #define FW_MAX_SIZE 0x400000 9053018216SPaolo Bonzini #define FW_FILE_NAME "slof.bin" 9153018216SPaolo Bonzini #define FW_OVERHEAD 0x2800000 9253018216SPaolo Bonzini #define KERNEL_LOAD_ADDR FW_MAX_SIZE 9353018216SPaolo Bonzini 9453018216SPaolo Bonzini #define MIN_RMA_SLOF 128UL 9553018216SPaolo Bonzini 9653018216SPaolo Bonzini #define PHANDLE_XICP 0x00001111 9753018216SPaolo Bonzini 9853018216SPaolo Bonzini #define HTAB_SIZE(spapr) (1ULL << ((spapr)->htab_shift)) 9953018216SPaolo Bonzini 10071cd4dacSCédric Le Goater static ICSState *spapr_ics_create(sPAPRMachineState *spapr, 10171cd4dacSCédric Le Goater const char *type_ics, 102817bb6a4SCédric Le Goater int nr_irqs, Error **errp) 103c04d6cfaSAnthony Liguori { 104175d2aa0SGreg Kurz Error *local_err = NULL; 10571cd4dacSCédric Le Goater Object *obj; 106c04d6cfaSAnthony Liguori 10771cd4dacSCédric Le Goater obj = object_new(type_ics); 108175d2aa0SGreg Kurz object_property_add_child(OBJECT(spapr), "ics", obj, &error_abort); 10971cd4dacSCédric Le Goater object_property_add_const_link(obj, "xics", OBJECT(spapr), &error_abort); 110175d2aa0SGreg Kurz object_property_set_int(obj, nr_irqs, "nr-irqs", &local_err); 111175d2aa0SGreg Kurz if (local_err) { 112175d2aa0SGreg Kurz goto error; 113175d2aa0SGreg Kurz } 11471cd4dacSCédric Le Goater object_property_set_bool(obj, true, "realized", &local_err); 115175d2aa0SGreg Kurz if (local_err) { 116175d2aa0SGreg Kurz goto error; 117c04d6cfaSAnthony Liguori } 118c04d6cfaSAnthony Liguori 11971cd4dacSCédric Le Goater return ICS_SIMPLE(obj); 120175d2aa0SGreg Kurz 121175d2aa0SGreg Kurz error: 122175d2aa0SGreg Kurz error_propagate(errp, local_err); 123175d2aa0SGreg Kurz return NULL; 1245bc8d26dSCédric Le Goater } 1255bc8d26dSCédric Le Goater 12671cd4dacSCédric Le Goater static void xics_system_init(MachineState *machine, int nr_irqs, Error **errp) 127c04d6cfaSAnthony Liguori { 12871cd4dacSCédric Le Goater sPAPRMachineState *spapr = SPAPR_MACHINE(machine); 129c04d6cfaSAnthony Liguori 13011ad93f6SDavid Gibson if (kvm_enabled()) { 1312192a930SCédric Le Goater if (machine_kernel_irqchip_allowed(machine) && 13271cd4dacSCédric Le Goater !xics_kvm_init(spapr, errp)) { 13371cd4dacSCédric Le Goater spapr->icp_type = TYPE_KVM_ICP; 1343d85885aSGreg Kurz spapr->ics = spapr_ics_create(spapr, TYPE_ICS_KVM, nr_irqs, errp); 13511ad93f6SDavid Gibson } 13671cd4dacSCédric Le Goater if (machine_kernel_irqchip_required(machine) && !spapr->ics) { 1373d85885aSGreg Kurz error_prepend(errp, "kernel_irqchip requested but unavailable: "); 1383d85885aSGreg Kurz return; 13911ad93f6SDavid Gibson } 140b83baa60SMarkus Armbruster } 14111ad93f6SDavid Gibson 14271cd4dacSCédric Le Goater if (!spapr->ics) { 143f63ebfe0SGreg Kurz xics_spapr_init(spapr); 14471cd4dacSCédric Le Goater spapr->icp_type = TYPE_ICP; 14571cd4dacSCédric Le Goater spapr->ics = spapr_ics_create(spapr, TYPE_ICS_SIMPLE, nr_irqs, errp); 1463d85885aSGreg Kurz if (!spapr->ics) { 1473d85885aSGreg Kurz return; 1483d85885aSGreg Kurz } 149c04d6cfaSAnthony Liguori } 150c04d6cfaSAnthony Liguori } 151c04d6cfaSAnthony Liguori 152833d4668SAlexey Kardashevskiy static int spapr_fixup_cpu_smt_dt(void *fdt, int offset, PowerPCCPU *cpu, 153833d4668SAlexey Kardashevskiy int smt_threads) 154833d4668SAlexey Kardashevskiy { 155833d4668SAlexey Kardashevskiy int i, ret = 0; 156833d4668SAlexey Kardashevskiy uint32_t servers_prop[smt_threads]; 157833d4668SAlexey Kardashevskiy uint32_t gservers_prop[smt_threads * 2]; 158833d4668SAlexey Kardashevskiy int index = ppc_get_vcpu_dt_id(cpu); 159833d4668SAlexey Kardashevskiy 160d6e166c0SDavid Gibson if (cpu->compat_pvr) { 161d6e166c0SDavid Gibson ret = fdt_setprop_cell(fdt, offset, "cpu-version", cpu->compat_pvr); 1626d9412eaSAlexey Kardashevskiy if (ret < 0) { 1636d9412eaSAlexey Kardashevskiy return ret; 1646d9412eaSAlexey Kardashevskiy } 1656d9412eaSAlexey Kardashevskiy } 1666d9412eaSAlexey Kardashevskiy 167833d4668SAlexey Kardashevskiy /* Build interrupt servers and gservers properties */ 168833d4668SAlexey Kardashevskiy for (i = 0; i < smt_threads; i++) { 169833d4668SAlexey Kardashevskiy servers_prop[i] = cpu_to_be32(index + i); 170833d4668SAlexey Kardashevskiy /* Hack, direct the group queues back to cpu 0 */ 171833d4668SAlexey Kardashevskiy gservers_prop[i*2] = cpu_to_be32(index + i); 172833d4668SAlexey Kardashevskiy gservers_prop[i*2 + 1] = 0; 173833d4668SAlexey Kardashevskiy } 174833d4668SAlexey Kardashevskiy ret = fdt_setprop(fdt, offset, "ibm,ppc-interrupt-server#s", 175833d4668SAlexey Kardashevskiy servers_prop, sizeof(servers_prop)); 176833d4668SAlexey Kardashevskiy if (ret < 0) { 177833d4668SAlexey Kardashevskiy return ret; 178833d4668SAlexey Kardashevskiy } 179833d4668SAlexey Kardashevskiy ret = fdt_setprop(fdt, offset, "ibm,ppc-interrupt-gserver#s", 180833d4668SAlexey Kardashevskiy gservers_prop, sizeof(gservers_prop)); 181833d4668SAlexey Kardashevskiy 182833d4668SAlexey Kardashevskiy return ret; 183833d4668SAlexey Kardashevskiy } 184833d4668SAlexey Kardashevskiy 185*99861ecbSIgor Mammedov static int spapr_fixup_cpu_numa_dt(void *fdt, int offset, PowerPCCPU *cpu) 1860da6f3feSBharata B Rao { 1870da6f3feSBharata B Rao int index = ppc_get_vcpu_dt_id(cpu); 1880da6f3feSBharata B Rao uint32_t associativity[] = {cpu_to_be32(0x5), 1890da6f3feSBharata B Rao cpu_to_be32(0x0), 1900da6f3feSBharata B Rao cpu_to_be32(0x0), 1910da6f3feSBharata B Rao cpu_to_be32(0x0), 19215f8b142SIgor Mammedov cpu_to_be32(cpu->node_id), 1930da6f3feSBharata B Rao cpu_to_be32(index)}; 1940da6f3feSBharata B Rao 1950da6f3feSBharata B Rao /* Advertise NUMA via ibm,associativity */ 196*99861ecbSIgor Mammedov return fdt_setprop(fdt, offset, "ibm,associativity", associativity, 1970da6f3feSBharata B Rao sizeof(associativity)); 1980da6f3feSBharata B Rao } 1990da6f3feSBharata B Rao 20086d5771aSSam Bobroff /* Populate the "ibm,pa-features" property */ 201e957f6a9SSam Bobroff static void spapr_populate_pa_features(CPUPPCState *env, void *fdt, int offset, 202e957f6a9SSam Bobroff bool legacy_guest) 20386d5771aSSam Bobroff { 20486d5771aSSam Bobroff uint8_t pa_features_206[] = { 6, 0, 20586d5771aSSam Bobroff 0xf6, 0x1f, 0xc7, 0x00, 0x80, 0xc0 }; 20686d5771aSSam Bobroff uint8_t pa_features_207[] = { 24, 0, 20786d5771aSSam Bobroff 0xf6, 0x1f, 0xc7, 0xc0, 0x80, 0xf0, 20886d5771aSSam Bobroff 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 20986d5771aSSam Bobroff 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 21086d5771aSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x00, 0x00 }; 2119fb4541fSSam Bobroff uint8_t pa_features_300[] = { 66, 0, 2129fb4541fSSam Bobroff /* 0: MMU|FPU|SLB|RUN|DABR|NX, 1: fri[nzpm]|DABRX|SPRG3|SLB0|PP110 */ 2139fb4541fSSam Bobroff /* 2: VPM|DS205|PPR|DS202|DS206, 3: LSD|URG, SSO, 5: LE|CFAR|EB|LSQ */ 21486d5771aSSam Bobroff 0xf6, 0x1f, 0xc7, 0xc0, 0x80, 0xf0, /* 0 - 5 */ 2159fb4541fSSam Bobroff /* 6: DS207 */ 21686d5771aSSam Bobroff 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, /* 6 - 11 */ 2179fb4541fSSam Bobroff /* 16: Vector */ 21886d5771aSSam Bobroff 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, /* 12 - 17 */ 2199fb4541fSSam Bobroff /* 18: Vec. Scalar, 20: Vec. XOR, 22: HTM */ 2209bf502feSDavid Gibson 0x80, 0x00, 0x80, 0x00, 0x00, 0x00, /* 18 - 23 */ 2219fb4541fSSam Bobroff /* 24: Ext. Dec, 26: 64 bit ftrs, 28: PM ftrs */ 2229fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, /* 24 - 29 */ 2239fb4541fSSam Bobroff /* 30: MMR, 32: LE atomic, 34: EBB + ext EBB */ 2249fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0xC0, 0x00, /* 30 - 35 */ 2259fb4541fSSam Bobroff /* 36: SPR SO, 38: Copy/Paste, 40: Radix MMU */ 2269fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, /* 36 - 41 */ 2279fb4541fSSam Bobroff /* 42: PM, 44: PC RA, 46: SC vec'd */ 2289fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, /* 42 - 47 */ 2299fb4541fSSam Bobroff /* 48: SIMD, 50: QP BFP, 52: String */ 2309fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, /* 48 - 53 */ 2319fb4541fSSam Bobroff /* 54: DecFP, 56: DecI, 58: SHA */ 2329fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, /* 54 - 59 */ 2339fb4541fSSam Bobroff /* 60: NM atomic, 62: RNG */ 2349fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x00, 0x00, /* 60 - 65 */ 2359fb4541fSSam Bobroff }; 23686d5771aSSam Bobroff uint8_t *pa_features; 23786d5771aSSam Bobroff size_t pa_size; 23886d5771aSSam Bobroff 23986d5771aSSam Bobroff switch (POWERPC_MMU_VER(env->mmu_model)) { 24086d5771aSSam Bobroff case POWERPC_MMU_VER_2_06: 24186d5771aSSam Bobroff pa_features = pa_features_206; 24286d5771aSSam Bobroff pa_size = sizeof(pa_features_206); 24386d5771aSSam Bobroff break; 24486d5771aSSam Bobroff case POWERPC_MMU_VER_2_07: 24586d5771aSSam Bobroff pa_features = pa_features_207; 24686d5771aSSam Bobroff pa_size = sizeof(pa_features_207); 24786d5771aSSam Bobroff break; 24886d5771aSSam Bobroff case POWERPC_MMU_VER_3_00: 24986d5771aSSam Bobroff pa_features = pa_features_300; 25086d5771aSSam Bobroff pa_size = sizeof(pa_features_300); 25186d5771aSSam Bobroff break; 25286d5771aSSam Bobroff default: 25386d5771aSSam Bobroff return; 25486d5771aSSam Bobroff } 25586d5771aSSam Bobroff 25686d5771aSSam Bobroff if (env->ci_large_pages) { 25786d5771aSSam Bobroff /* 25886d5771aSSam Bobroff * Note: we keep CI large pages off by default because a 64K capable 25986d5771aSSam Bobroff * guest provisioned with large pages might otherwise try to map a qemu 26086d5771aSSam Bobroff * framebuffer (or other kind of memory mapped PCI BAR) using 64K pages 26186d5771aSSam Bobroff * even if that qemu runs on a 4k host. 26286d5771aSSam Bobroff * We dd this bit back here if we are confident this is not an issue 26386d5771aSSam Bobroff */ 26486d5771aSSam Bobroff pa_features[3] |= 0x20; 26586d5771aSSam Bobroff } 26686d5771aSSam Bobroff if (kvmppc_has_cap_htm() && pa_size > 24) { 26786d5771aSSam Bobroff pa_features[24] |= 0x80; /* Transactional memory support */ 26886d5771aSSam Bobroff } 269e957f6a9SSam Bobroff if (legacy_guest && pa_size > 40) { 270e957f6a9SSam Bobroff /* Workaround for broken kernels that attempt (guest) radix 271e957f6a9SSam Bobroff * mode when they can't handle it, if they see the radix bit set 272e957f6a9SSam Bobroff * in pa-features. So hide it from them. */ 273e957f6a9SSam Bobroff pa_features[40 + 2] &= ~0x80; /* Radix MMU */ 274e957f6a9SSam Bobroff } 27586d5771aSSam Bobroff 27686d5771aSSam Bobroff _FDT((fdt_setprop(fdt, offset, "ibm,pa-features", pa_features, pa_size))); 27786d5771aSSam Bobroff } 27886d5771aSSam Bobroff 27928e02042SDavid Gibson static int spapr_fixup_cpu_dt(void *fdt, sPAPRMachineState *spapr) 28053018216SPaolo Bonzini { 28182677ed2SAlexey Kardashevskiy int ret = 0, offset, cpus_offset; 28282677ed2SAlexey Kardashevskiy CPUState *cs; 28353018216SPaolo Bonzini char cpu_model[32]; 28453018216SPaolo Bonzini int smt = kvmppc_smt_threads(); 28553018216SPaolo Bonzini uint32_t pft_size_prop[] = {0, cpu_to_be32(spapr->htab_shift)}; 28653018216SPaolo Bonzini 28782677ed2SAlexey Kardashevskiy CPU_FOREACH(cs) { 28882677ed2SAlexey Kardashevskiy PowerPCCPU *cpu = POWERPC_CPU(cs); 289e957f6a9SSam Bobroff CPUPPCState *env = &cpu->env; 29082677ed2SAlexey Kardashevskiy DeviceClass *dc = DEVICE_GET_CLASS(cs); 29182677ed2SAlexey Kardashevskiy int index = ppc_get_vcpu_dt_id(cpu); 29212dbeb16SDavid Gibson int compat_smt = MIN(smp_threads, ppc_compat_max_threads(cpu)); 29353018216SPaolo Bonzini 2940f20ba62SAlexey Kardashevskiy if ((index % smt) != 0) { 29553018216SPaolo Bonzini continue; 29653018216SPaolo Bonzini } 29753018216SPaolo Bonzini 29882677ed2SAlexey Kardashevskiy snprintf(cpu_model, 32, "%s@%x", dc->fw_name, index); 29953018216SPaolo Bonzini 30082677ed2SAlexey Kardashevskiy cpus_offset = fdt_path_offset(fdt, "/cpus"); 30182677ed2SAlexey Kardashevskiy if (cpus_offset < 0) { 30282677ed2SAlexey Kardashevskiy cpus_offset = fdt_add_subnode(fdt, fdt_path_offset(fdt, "/"), 30382677ed2SAlexey Kardashevskiy "cpus"); 30482677ed2SAlexey Kardashevskiy if (cpus_offset < 0) { 30582677ed2SAlexey Kardashevskiy return cpus_offset; 30682677ed2SAlexey Kardashevskiy } 30782677ed2SAlexey Kardashevskiy } 30882677ed2SAlexey Kardashevskiy offset = fdt_subnode_offset(fdt, cpus_offset, cpu_model); 30982677ed2SAlexey Kardashevskiy if (offset < 0) { 31082677ed2SAlexey Kardashevskiy offset = fdt_add_subnode(fdt, cpus_offset, cpu_model); 31153018216SPaolo Bonzini if (offset < 0) { 31253018216SPaolo Bonzini return offset; 31353018216SPaolo Bonzini } 31482677ed2SAlexey Kardashevskiy } 31553018216SPaolo Bonzini 3160da6f3feSBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,pft-size", 3170da6f3feSBharata B Rao pft_size_prop, sizeof(pft_size_prop)); 31853018216SPaolo Bonzini if (ret < 0) { 31953018216SPaolo Bonzini return ret; 32053018216SPaolo Bonzini } 32153018216SPaolo Bonzini 322*99861ecbSIgor Mammedov if (nb_numa_nodes > 1) { 323*99861ecbSIgor Mammedov ret = spapr_fixup_cpu_numa_dt(fdt, offset, cpu); 32453018216SPaolo Bonzini if (ret < 0) { 32553018216SPaolo Bonzini return ret; 32653018216SPaolo Bonzini } 327*99861ecbSIgor Mammedov } 328833d4668SAlexey Kardashevskiy 32912dbeb16SDavid Gibson ret = spapr_fixup_cpu_smt_dt(fdt, offset, cpu, compat_smt); 330833d4668SAlexey Kardashevskiy if (ret < 0) { 331833d4668SAlexey Kardashevskiy return ret; 332833d4668SAlexey Kardashevskiy } 333e957f6a9SSam Bobroff 334e957f6a9SSam Bobroff spapr_populate_pa_features(env, fdt, offset, 335e957f6a9SSam Bobroff spapr->cas_legacy_guest_workaround); 33653018216SPaolo Bonzini } 33753018216SPaolo Bonzini return ret; 33853018216SPaolo Bonzini } 33953018216SPaolo Bonzini 340b082d65aSAlexey Kardashevskiy static hwaddr spapr_node0_size(void) 341b082d65aSAlexey Kardashevskiy { 342fb164994SDavid Gibson MachineState *machine = MACHINE(qdev_get_machine()); 343fb164994SDavid Gibson 344b082d65aSAlexey Kardashevskiy if (nb_numa_nodes) { 345b082d65aSAlexey Kardashevskiy int i; 346b082d65aSAlexey Kardashevskiy for (i = 0; i < nb_numa_nodes; ++i) { 347b082d65aSAlexey Kardashevskiy if (numa_info[i].node_mem) { 348fb164994SDavid Gibson return MIN(pow2floor(numa_info[i].node_mem), 349fb164994SDavid Gibson machine->ram_size); 350b082d65aSAlexey Kardashevskiy } 351b082d65aSAlexey Kardashevskiy } 352b082d65aSAlexey Kardashevskiy } 353fb164994SDavid Gibson return machine->ram_size; 354b082d65aSAlexey Kardashevskiy } 355b082d65aSAlexey Kardashevskiy 356a1d59c0fSAlexey Kardashevskiy static void add_str(GString *s, const gchar *s1) 357a1d59c0fSAlexey Kardashevskiy { 358a1d59c0fSAlexey Kardashevskiy g_string_append_len(s, s1, strlen(s1) + 1); 359a1d59c0fSAlexey Kardashevskiy } 36053018216SPaolo Bonzini 36103d196b7SBharata B Rao static int spapr_populate_memory_node(void *fdt, int nodeid, hwaddr start, 36226a8c353SAlexey Kardashevskiy hwaddr size) 36326a8c353SAlexey Kardashevskiy { 36426a8c353SAlexey Kardashevskiy uint32_t associativity[] = { 36526a8c353SAlexey Kardashevskiy cpu_to_be32(0x4), /* length */ 36626a8c353SAlexey Kardashevskiy cpu_to_be32(0x0), cpu_to_be32(0x0), 367c3b4f589SAlexey Kardashevskiy cpu_to_be32(0x0), cpu_to_be32(nodeid) 36826a8c353SAlexey Kardashevskiy }; 36926a8c353SAlexey Kardashevskiy char mem_name[32]; 37026a8c353SAlexey Kardashevskiy uint64_t mem_reg_property[2]; 37126a8c353SAlexey Kardashevskiy int off; 37226a8c353SAlexey Kardashevskiy 37326a8c353SAlexey Kardashevskiy mem_reg_property[0] = cpu_to_be64(start); 37426a8c353SAlexey Kardashevskiy mem_reg_property[1] = cpu_to_be64(size); 37526a8c353SAlexey Kardashevskiy 37626a8c353SAlexey Kardashevskiy sprintf(mem_name, "memory@" TARGET_FMT_lx, start); 37726a8c353SAlexey Kardashevskiy off = fdt_add_subnode(fdt, 0, mem_name); 37826a8c353SAlexey Kardashevskiy _FDT(off); 37926a8c353SAlexey Kardashevskiy _FDT((fdt_setprop_string(fdt, off, "device_type", "memory"))); 38026a8c353SAlexey Kardashevskiy _FDT((fdt_setprop(fdt, off, "reg", mem_reg_property, 38126a8c353SAlexey Kardashevskiy sizeof(mem_reg_property)))); 38226a8c353SAlexey Kardashevskiy _FDT((fdt_setprop(fdt, off, "ibm,associativity", associativity, 38326a8c353SAlexey Kardashevskiy sizeof(associativity)))); 38403d196b7SBharata B Rao return off; 38526a8c353SAlexey Kardashevskiy } 38626a8c353SAlexey Kardashevskiy 38728e02042SDavid Gibson static int spapr_populate_memory(sPAPRMachineState *spapr, void *fdt) 38853018216SPaolo Bonzini { 389fb164994SDavid Gibson MachineState *machine = MACHINE(spapr); 3907db8a127SAlexey Kardashevskiy hwaddr mem_start, node_size; 3917db8a127SAlexey Kardashevskiy int i, nb_nodes = nb_numa_nodes; 3927db8a127SAlexey Kardashevskiy NodeInfo *nodes = numa_info; 3937db8a127SAlexey Kardashevskiy NodeInfo ramnode; 39453018216SPaolo Bonzini 3957db8a127SAlexey Kardashevskiy /* No NUMA nodes, assume there is just one node with whole RAM */ 3967db8a127SAlexey Kardashevskiy if (!nb_numa_nodes) { 3977db8a127SAlexey Kardashevskiy nb_nodes = 1; 398fb164994SDavid Gibson ramnode.node_mem = machine->ram_size; 3997db8a127SAlexey Kardashevskiy nodes = &ramnode; 4005fe269b1SPaul Mackerras } 40153018216SPaolo Bonzini 4027db8a127SAlexey Kardashevskiy for (i = 0, mem_start = 0; i < nb_nodes; ++i) { 4037db8a127SAlexey Kardashevskiy if (!nodes[i].node_mem) { 4047db8a127SAlexey Kardashevskiy continue; 40553018216SPaolo Bonzini } 406fb164994SDavid Gibson if (mem_start >= machine->ram_size) { 4075fe269b1SPaul Mackerras node_size = 0; 4085fe269b1SPaul Mackerras } else { 4097db8a127SAlexey Kardashevskiy node_size = nodes[i].node_mem; 410fb164994SDavid Gibson if (node_size > machine->ram_size - mem_start) { 411fb164994SDavid Gibson node_size = machine->ram_size - mem_start; 4125fe269b1SPaul Mackerras } 4135fe269b1SPaul Mackerras } 4147db8a127SAlexey Kardashevskiy if (!mem_start) { 4157db8a127SAlexey Kardashevskiy /* ppc_spapr_init() checks for rma_size <= node0_size already */ 416e8f986fcSBharata B Rao spapr_populate_memory_node(fdt, i, 0, spapr->rma_size); 4177db8a127SAlexey Kardashevskiy mem_start += spapr->rma_size; 4187db8a127SAlexey Kardashevskiy node_size -= spapr->rma_size; 4197db8a127SAlexey Kardashevskiy } 4206010818cSAlexey Kardashevskiy for ( ; node_size; ) { 4216010818cSAlexey Kardashevskiy hwaddr sizetmp = pow2floor(node_size); 4226010818cSAlexey Kardashevskiy 4236010818cSAlexey Kardashevskiy /* mem_start != 0 here */ 4246010818cSAlexey Kardashevskiy if (ctzl(mem_start) < ctzl(sizetmp)) { 4256010818cSAlexey Kardashevskiy sizetmp = 1ULL << ctzl(mem_start); 4266010818cSAlexey Kardashevskiy } 4276010818cSAlexey Kardashevskiy 4286010818cSAlexey Kardashevskiy spapr_populate_memory_node(fdt, i, mem_start, sizetmp); 4296010818cSAlexey Kardashevskiy node_size -= sizetmp; 4306010818cSAlexey Kardashevskiy mem_start += sizetmp; 4316010818cSAlexey Kardashevskiy } 43253018216SPaolo Bonzini } 43353018216SPaolo Bonzini 43453018216SPaolo Bonzini return 0; 43553018216SPaolo Bonzini } 43653018216SPaolo Bonzini 4370da6f3feSBharata B Rao static void spapr_populate_cpu_dt(CPUState *cs, void *fdt, int offset, 4380da6f3feSBharata B Rao sPAPRMachineState *spapr) 4390da6f3feSBharata B Rao { 4400da6f3feSBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(cs); 4410da6f3feSBharata B Rao CPUPPCState *env = &cpu->env; 4420da6f3feSBharata B Rao PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(cs); 4430da6f3feSBharata B Rao int index = ppc_get_vcpu_dt_id(cpu); 4440da6f3feSBharata B Rao uint32_t segs[] = {cpu_to_be32(28), cpu_to_be32(40), 4450da6f3feSBharata B Rao 0xffffffff, 0xffffffff}; 446afd10a0fSBharata B Rao uint32_t tbfreq = kvm_enabled() ? kvmppc_get_tbfreq() 447afd10a0fSBharata B Rao : SPAPR_TIMEBASE_FREQ; 4480da6f3feSBharata B Rao uint32_t cpufreq = kvm_enabled() ? kvmppc_get_clockfreq() : 1000000000; 4490da6f3feSBharata B Rao uint32_t page_sizes_prop[64]; 4500da6f3feSBharata B Rao size_t page_sizes_prop_size; 45122419c2aSDavid Gibson uint32_t vcpus_per_socket = smp_threads * smp_cores; 4520da6f3feSBharata B Rao uint32_t pft_size_prop[] = {0, cpu_to_be32(spapr->htab_shift)}; 45312dbeb16SDavid Gibson int compat_smt = MIN(smp_threads, ppc_compat_max_threads(cpu)); 454af81cf32SBharata B Rao sPAPRDRConnector *drc; 455af81cf32SBharata B Rao sPAPRDRConnectorClass *drck; 456af81cf32SBharata B Rao int drc_index; 457c64abd1fSSam Bobroff uint32_t radix_AP_encodings[PPC_PAGE_SIZES_MAX_SZ]; 458c64abd1fSSam Bobroff int i; 459af81cf32SBharata B Rao 460af81cf32SBharata B Rao drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_CPU, index); 461af81cf32SBharata B Rao if (drc) { 462af81cf32SBharata B Rao drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 463af81cf32SBharata B Rao drc_index = drck->get_index(drc); 464af81cf32SBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,my-drc-index", drc_index))); 465af81cf32SBharata B Rao } 4660da6f3feSBharata B Rao 4670da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "reg", index))); 4680da6f3feSBharata B Rao _FDT((fdt_setprop_string(fdt, offset, "device_type", "cpu"))); 4690da6f3feSBharata B Rao 4700da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "cpu-version", env->spr[SPR_PVR]))); 4710da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "d-cache-block-size", 4720da6f3feSBharata B Rao env->dcache_line_size))); 4730da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "d-cache-line-size", 4740da6f3feSBharata B Rao env->dcache_line_size))); 4750da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "i-cache-block-size", 4760da6f3feSBharata B Rao env->icache_line_size))); 4770da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "i-cache-line-size", 4780da6f3feSBharata B Rao env->icache_line_size))); 4790da6f3feSBharata B Rao 4800da6f3feSBharata B Rao if (pcc->l1_dcache_size) { 4810da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "d-cache-size", 4820da6f3feSBharata B Rao pcc->l1_dcache_size))); 4830da6f3feSBharata B Rao } else { 484ce9863b7SCédric Le Goater error_report("Warning: Unknown L1 dcache size for cpu"); 4850da6f3feSBharata B Rao } 4860da6f3feSBharata B Rao if (pcc->l1_icache_size) { 4870da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "i-cache-size", 4880da6f3feSBharata B Rao pcc->l1_icache_size))); 4890da6f3feSBharata B Rao } else { 490ce9863b7SCédric Le Goater error_report("Warning: Unknown L1 icache size for cpu"); 4910da6f3feSBharata B Rao } 4920da6f3feSBharata B Rao 4930da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "timebase-frequency", tbfreq))); 4940da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "clock-frequency", cpufreq))); 495fd5da5c4SThomas Huth _FDT((fdt_setprop_cell(fdt, offset, "slb-size", env->slb_nr))); 4960da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,slb-size", env->slb_nr))); 4970da6f3feSBharata B Rao _FDT((fdt_setprop_string(fdt, offset, "status", "okay"))); 4980da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "64-bit", NULL, 0))); 4990da6f3feSBharata B Rao 5000da6f3feSBharata B Rao if (env->spr_cb[SPR_PURR].oea_read) { 5010da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,purr", NULL, 0))); 5020da6f3feSBharata B Rao } 5030da6f3feSBharata B Rao 5040da6f3feSBharata B Rao if (env->mmu_model & POWERPC_MMU_1TSEG) { 5050da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,processor-segment-sizes", 5060da6f3feSBharata B Rao segs, sizeof(segs)))); 5070da6f3feSBharata B Rao } 5080da6f3feSBharata B Rao 5090da6f3feSBharata B Rao /* Advertise VMX/VSX (vector extensions) if available 5100da6f3feSBharata B Rao * 0 / no property == no vector extensions 5110da6f3feSBharata B Rao * 1 == VMX / Altivec available 5120da6f3feSBharata B Rao * 2 == VSX available */ 5130da6f3feSBharata B Rao if (env->insns_flags & PPC_ALTIVEC) { 5140da6f3feSBharata B Rao uint32_t vmx = (env->insns_flags2 & PPC2_VSX) ? 2 : 1; 5150da6f3feSBharata B Rao 5160da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,vmx", vmx))); 5170da6f3feSBharata B Rao } 5180da6f3feSBharata B Rao 5190da6f3feSBharata B Rao /* Advertise DFP (Decimal Floating Point) if available 5200da6f3feSBharata B Rao * 0 / no property == no DFP 5210da6f3feSBharata B Rao * 1 == DFP available */ 5220da6f3feSBharata B Rao if (env->insns_flags2 & PPC2_DFP) { 5230da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,dfp", 1))); 5240da6f3feSBharata B Rao } 5250da6f3feSBharata B Rao 5263654fa95SCédric Le Goater page_sizes_prop_size = ppc_create_page_sizes_prop(env, page_sizes_prop, 5270da6f3feSBharata B Rao sizeof(page_sizes_prop)); 5280da6f3feSBharata B Rao if (page_sizes_prop_size) { 5290da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,segment-page-sizes", 5300da6f3feSBharata B Rao page_sizes_prop, page_sizes_prop_size))); 5310da6f3feSBharata B Rao } 5320da6f3feSBharata B Rao 533e957f6a9SSam Bobroff spapr_populate_pa_features(env, fdt, offset, false); 53490da0d5aSBenjamin Herrenschmidt 5350da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,chip-id", 53622419c2aSDavid Gibson cs->cpu_index / vcpus_per_socket))); 5370da6f3feSBharata B Rao 5380da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,pft-size", 5390da6f3feSBharata B Rao pft_size_prop, sizeof(pft_size_prop)))); 5400da6f3feSBharata B Rao 541*99861ecbSIgor Mammedov if (nb_numa_nodes > 1) { 542*99861ecbSIgor Mammedov _FDT(spapr_fixup_cpu_numa_dt(fdt, offset, cpu)); 543*99861ecbSIgor Mammedov } 5440da6f3feSBharata B Rao 54512dbeb16SDavid Gibson _FDT(spapr_fixup_cpu_smt_dt(fdt, offset, cpu, compat_smt)); 546c64abd1fSSam Bobroff 547c64abd1fSSam Bobroff if (pcc->radix_page_info) { 548c64abd1fSSam Bobroff for (i = 0; i < pcc->radix_page_info->count; i++) { 549c64abd1fSSam Bobroff radix_AP_encodings[i] = 550c64abd1fSSam Bobroff cpu_to_be32(pcc->radix_page_info->entries[i]); 551c64abd1fSSam Bobroff } 552c64abd1fSSam Bobroff _FDT((fdt_setprop(fdt, offset, "ibm,processor-radix-AP-encodings", 553c64abd1fSSam Bobroff radix_AP_encodings, 554c64abd1fSSam Bobroff pcc->radix_page_info->count * 555c64abd1fSSam Bobroff sizeof(radix_AP_encodings[0])))); 556c64abd1fSSam Bobroff } 5570da6f3feSBharata B Rao } 5580da6f3feSBharata B Rao 5590da6f3feSBharata B Rao static void spapr_populate_cpus_dt_node(void *fdt, sPAPRMachineState *spapr) 5600da6f3feSBharata B Rao { 5610da6f3feSBharata B Rao CPUState *cs; 5620da6f3feSBharata B Rao int cpus_offset; 5630da6f3feSBharata B Rao char *nodename; 5640da6f3feSBharata B Rao int smt = kvmppc_smt_threads(); 5650da6f3feSBharata B Rao 5660da6f3feSBharata B Rao cpus_offset = fdt_add_subnode(fdt, 0, "cpus"); 5670da6f3feSBharata B Rao _FDT(cpus_offset); 5680da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, cpus_offset, "#address-cells", 0x1))); 5690da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, cpus_offset, "#size-cells", 0x0))); 5700da6f3feSBharata B Rao 5710da6f3feSBharata B Rao /* 5720da6f3feSBharata B Rao * We walk the CPUs in reverse order to ensure that CPU DT nodes 5730da6f3feSBharata B Rao * created by fdt_add_subnode() end up in the right order in FDT 5740da6f3feSBharata B Rao * for the guest kernel the enumerate the CPUs correctly. 5750da6f3feSBharata B Rao */ 5760da6f3feSBharata B Rao CPU_FOREACH_REVERSE(cs) { 5770da6f3feSBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(cs); 5780da6f3feSBharata B Rao int index = ppc_get_vcpu_dt_id(cpu); 5790da6f3feSBharata B Rao DeviceClass *dc = DEVICE_GET_CLASS(cs); 5800da6f3feSBharata B Rao int offset; 5810da6f3feSBharata B Rao 5820da6f3feSBharata B Rao if ((index % smt) != 0) { 5830da6f3feSBharata B Rao continue; 5840da6f3feSBharata B Rao } 5850da6f3feSBharata B Rao 5860da6f3feSBharata B Rao nodename = g_strdup_printf("%s@%x", dc->fw_name, index); 5870da6f3feSBharata B Rao offset = fdt_add_subnode(fdt, cpus_offset, nodename); 5880da6f3feSBharata B Rao g_free(nodename); 5890da6f3feSBharata B Rao _FDT(offset); 5900da6f3feSBharata B Rao spapr_populate_cpu_dt(cs, fdt, offset, spapr); 5910da6f3feSBharata B Rao } 5920da6f3feSBharata B Rao 5930da6f3feSBharata B Rao } 5940da6f3feSBharata B Rao 59503d196b7SBharata B Rao /* 59603d196b7SBharata B Rao * Adds ibm,dynamic-reconfiguration-memory node. 59703d196b7SBharata B Rao * Refer to docs/specs/ppc-spapr-hotplug.txt for the documentation 59803d196b7SBharata B Rao * of this device tree node. 59903d196b7SBharata B Rao */ 60003d196b7SBharata B Rao static int spapr_populate_drconf_memory(sPAPRMachineState *spapr, void *fdt) 60103d196b7SBharata B Rao { 60203d196b7SBharata B Rao MachineState *machine = MACHINE(spapr); 60303d196b7SBharata B Rao int ret, i, offset; 60403d196b7SBharata B Rao uint64_t lmb_size = SPAPR_MEMORY_BLOCK_SIZE; 60503d196b7SBharata B Rao uint32_t prop_lmb_size[] = {0, cpu_to_be32(lmb_size)}; 606d0e5a8f2SBharata B Rao uint32_t hotplug_lmb_start = spapr->hotplug_memory.base / lmb_size; 607d0e5a8f2SBharata B Rao uint32_t nr_lmbs = (spapr->hotplug_memory.base + 608d0e5a8f2SBharata B Rao memory_region_size(&spapr->hotplug_memory.mr)) / 609d0e5a8f2SBharata B Rao lmb_size; 61003d196b7SBharata B Rao uint32_t *int_buf, *cur_index, buf_len; 6116663864eSBharata B Rao int nr_nodes = nb_numa_nodes ? nb_numa_nodes : 1; 61203d196b7SBharata B Rao 613ef001f06SThomas Huth /* 614d0e5a8f2SBharata B Rao * Don't create the node if there is no hotpluggable memory 61516c25aefSBharata B Rao */ 616d0e5a8f2SBharata B Rao if (machine->ram_size == machine->maxram_size) { 61716c25aefSBharata B Rao return 0; 61816c25aefSBharata B Rao } 61916c25aefSBharata B Rao 62016c25aefSBharata B Rao /* 621ef001f06SThomas Huth * Allocate enough buffer size to fit in ibm,dynamic-memory 622ef001f06SThomas Huth * or ibm,associativity-lookup-arrays 623ef001f06SThomas Huth */ 624ef001f06SThomas Huth buf_len = MAX(nr_lmbs * SPAPR_DR_LMB_LIST_ENTRY_SIZE + 1, nr_nodes * 4 + 2) 625ef001f06SThomas Huth * sizeof(uint32_t); 62603d196b7SBharata B Rao cur_index = int_buf = g_malloc0(buf_len); 62703d196b7SBharata B Rao 62803d196b7SBharata B Rao offset = fdt_add_subnode(fdt, 0, "ibm,dynamic-reconfiguration-memory"); 62903d196b7SBharata B Rao 63003d196b7SBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,lmb-size", prop_lmb_size, 63103d196b7SBharata B Rao sizeof(prop_lmb_size)); 63203d196b7SBharata B Rao if (ret < 0) { 63303d196b7SBharata B Rao goto out; 63403d196b7SBharata B Rao } 63503d196b7SBharata B Rao 63603d196b7SBharata B Rao ret = fdt_setprop_cell(fdt, offset, "ibm,memory-flags-mask", 0xff); 63703d196b7SBharata B Rao if (ret < 0) { 63803d196b7SBharata B Rao goto out; 63903d196b7SBharata B Rao } 64003d196b7SBharata B Rao 64103d196b7SBharata B Rao ret = fdt_setprop_cell(fdt, offset, "ibm,memory-preservation-time", 0x0); 64203d196b7SBharata B Rao if (ret < 0) { 64303d196b7SBharata B Rao goto out; 64403d196b7SBharata B Rao } 64503d196b7SBharata B Rao 64603d196b7SBharata B Rao /* ibm,dynamic-memory */ 64703d196b7SBharata B Rao int_buf[0] = cpu_to_be32(nr_lmbs); 64803d196b7SBharata B Rao cur_index++; 64903d196b7SBharata B Rao for (i = 0; i < nr_lmbs; i++) { 650d0e5a8f2SBharata B Rao uint64_t addr = i * lmb_size; 65103d196b7SBharata B Rao uint32_t *dynamic_memory = cur_index; 65203d196b7SBharata B Rao 653d0e5a8f2SBharata B Rao if (i >= hotplug_lmb_start) { 654d0e5a8f2SBharata B Rao sPAPRDRConnector *drc; 655d0e5a8f2SBharata B Rao sPAPRDRConnectorClass *drck; 656d0e5a8f2SBharata B Rao 657d0e5a8f2SBharata B Rao drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_LMB, i); 65803d196b7SBharata B Rao g_assert(drc); 65903d196b7SBharata B Rao drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 66003d196b7SBharata B Rao 66103d196b7SBharata B Rao dynamic_memory[0] = cpu_to_be32(addr >> 32); 66203d196b7SBharata B Rao dynamic_memory[1] = cpu_to_be32(addr & 0xffffffff); 66303d196b7SBharata B Rao dynamic_memory[2] = cpu_to_be32(drck->get_index(drc)); 66403d196b7SBharata B Rao dynamic_memory[3] = cpu_to_be32(0); /* reserved */ 66503d196b7SBharata B Rao dynamic_memory[4] = cpu_to_be32(numa_get_node(addr, NULL)); 666d0e5a8f2SBharata B Rao if (memory_region_present(get_system_memory(), addr)) { 66703d196b7SBharata B Rao dynamic_memory[5] = cpu_to_be32(SPAPR_LMB_FLAGS_ASSIGNED); 66803d196b7SBharata B Rao } else { 66903d196b7SBharata B Rao dynamic_memory[5] = cpu_to_be32(0); 67003d196b7SBharata B Rao } 671d0e5a8f2SBharata B Rao } else { 672d0e5a8f2SBharata B Rao /* 673d0e5a8f2SBharata B Rao * LMB information for RMA, boot time RAM and gap b/n RAM and 674d0e5a8f2SBharata B Rao * hotplug memory region -- all these are marked as reserved 675d0e5a8f2SBharata B Rao * and as having no valid DRC. 676d0e5a8f2SBharata B Rao */ 677d0e5a8f2SBharata B Rao dynamic_memory[0] = cpu_to_be32(addr >> 32); 678d0e5a8f2SBharata B Rao dynamic_memory[1] = cpu_to_be32(addr & 0xffffffff); 679d0e5a8f2SBharata B Rao dynamic_memory[2] = cpu_to_be32(0); 680d0e5a8f2SBharata B Rao dynamic_memory[3] = cpu_to_be32(0); /* reserved */ 681d0e5a8f2SBharata B Rao dynamic_memory[4] = cpu_to_be32(-1); 682d0e5a8f2SBharata B Rao dynamic_memory[5] = cpu_to_be32(SPAPR_LMB_FLAGS_RESERVED | 683d0e5a8f2SBharata B Rao SPAPR_LMB_FLAGS_DRC_INVALID); 684d0e5a8f2SBharata B Rao } 68503d196b7SBharata B Rao 68603d196b7SBharata B Rao cur_index += SPAPR_DR_LMB_LIST_ENTRY_SIZE; 68703d196b7SBharata B Rao } 68803d196b7SBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,dynamic-memory", int_buf, buf_len); 68903d196b7SBharata B Rao if (ret < 0) { 69003d196b7SBharata B Rao goto out; 69103d196b7SBharata B Rao } 69203d196b7SBharata B Rao 69303d196b7SBharata B Rao /* ibm,associativity-lookup-arrays */ 69403d196b7SBharata B Rao cur_index = int_buf; 6956663864eSBharata B Rao int_buf[0] = cpu_to_be32(nr_nodes); 69603d196b7SBharata B Rao int_buf[1] = cpu_to_be32(4); /* Number of entries per associativity list */ 69703d196b7SBharata B Rao cur_index += 2; 6986663864eSBharata B Rao for (i = 0; i < nr_nodes; i++) { 69903d196b7SBharata B Rao uint32_t associativity[] = { 70003d196b7SBharata B Rao cpu_to_be32(0x0), 70103d196b7SBharata B Rao cpu_to_be32(0x0), 70203d196b7SBharata B Rao cpu_to_be32(0x0), 70303d196b7SBharata B Rao cpu_to_be32(i) 70403d196b7SBharata B Rao }; 70503d196b7SBharata B Rao memcpy(cur_index, associativity, sizeof(associativity)); 70603d196b7SBharata B Rao cur_index += 4; 70703d196b7SBharata B Rao } 70803d196b7SBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,associativity-lookup-arrays", int_buf, 70903d196b7SBharata B Rao (cur_index - int_buf) * sizeof(uint32_t)); 71003d196b7SBharata B Rao out: 71103d196b7SBharata B Rao g_free(int_buf); 71203d196b7SBharata B Rao return ret; 71303d196b7SBharata B Rao } 71403d196b7SBharata B Rao 7156787d27bSMichael Roth static int spapr_dt_cas_updates(sPAPRMachineState *spapr, void *fdt, 7166787d27bSMichael Roth sPAPROptionVector *ov5_updates) 7176787d27bSMichael Roth { 7186787d27bSMichael Roth sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(spapr); 719417ece33SMichael Roth int ret = 0, offset; 7206787d27bSMichael Roth 7216787d27bSMichael Roth /* Generate ibm,dynamic-reconfiguration-memory node if required */ 7226787d27bSMichael Roth if (spapr_ovec_test(ov5_updates, OV5_DRCONF_MEMORY)) { 7236787d27bSMichael Roth g_assert(smc->dr_lmb_enabled); 7246787d27bSMichael Roth ret = spapr_populate_drconf_memory(spapr, fdt); 725417ece33SMichael Roth if (ret) { 726417ece33SMichael Roth goto out; 727417ece33SMichael Roth } 7286787d27bSMichael Roth } 7296787d27bSMichael Roth 730417ece33SMichael Roth offset = fdt_path_offset(fdt, "/chosen"); 731417ece33SMichael Roth if (offset < 0) { 732417ece33SMichael Roth offset = fdt_add_subnode(fdt, 0, "chosen"); 733417ece33SMichael Roth if (offset < 0) { 734417ece33SMichael Roth return offset; 735417ece33SMichael Roth } 736417ece33SMichael Roth } 737417ece33SMichael Roth ret = spapr_ovec_populate_dt(fdt, offset, spapr->ov5_cas, 738417ece33SMichael Roth "ibm,architecture-vec-5"); 739417ece33SMichael Roth 740417ece33SMichael Roth out: 7416787d27bSMichael Roth return ret; 7426787d27bSMichael Roth } 7436787d27bSMichael Roth 74403d196b7SBharata B Rao int spapr_h_cas_compose_response(sPAPRMachineState *spapr, 74503d196b7SBharata B Rao target_ulong addr, target_ulong size, 7466787d27bSMichael Roth sPAPROptionVector *ov5_updates) 74703d196b7SBharata B Rao { 74803d196b7SBharata B Rao void *fdt, *fdt_skel; 74903d196b7SBharata B Rao sPAPRDeviceTreeUpdateHeader hdr = { .version_id = 1 }; 75003d196b7SBharata B Rao 75103d196b7SBharata B Rao size -= sizeof(hdr); 75203d196b7SBharata B Rao 75303d196b7SBharata B Rao /* Create sceleton */ 75403d196b7SBharata B Rao fdt_skel = g_malloc0(size); 75503d196b7SBharata B Rao _FDT((fdt_create(fdt_skel, size))); 75603d196b7SBharata B Rao _FDT((fdt_begin_node(fdt_skel, ""))); 75703d196b7SBharata B Rao _FDT((fdt_end_node(fdt_skel))); 75803d196b7SBharata B Rao _FDT((fdt_finish(fdt_skel))); 75903d196b7SBharata B Rao fdt = g_malloc0(size); 76003d196b7SBharata B Rao _FDT((fdt_open_into(fdt_skel, fdt, size))); 76103d196b7SBharata B Rao g_free(fdt_skel); 76203d196b7SBharata B Rao 76303d196b7SBharata B Rao /* Fixup cpu nodes */ 76403d196b7SBharata B Rao _FDT((spapr_fixup_cpu_dt(fdt, spapr))); 76503d196b7SBharata B Rao 7666787d27bSMichael Roth if (spapr_dt_cas_updates(spapr, fdt, ov5_updates)) { 7676787d27bSMichael Roth return -1; 76803d196b7SBharata B Rao } 76903d196b7SBharata B Rao 77003d196b7SBharata B Rao /* Pack resulting tree */ 77103d196b7SBharata B Rao _FDT((fdt_pack(fdt))); 77203d196b7SBharata B Rao 77303d196b7SBharata B Rao if (fdt_totalsize(fdt) + sizeof(hdr) > size) { 77403d196b7SBharata B Rao trace_spapr_cas_failed(size); 77503d196b7SBharata B Rao return -1; 77603d196b7SBharata B Rao } 77703d196b7SBharata B Rao 77803d196b7SBharata B Rao cpu_physical_memory_write(addr, &hdr, sizeof(hdr)); 77903d196b7SBharata B Rao cpu_physical_memory_write(addr + sizeof(hdr), fdt, fdt_totalsize(fdt)); 78003d196b7SBharata B Rao trace_spapr_cas_continue(fdt_totalsize(fdt) + sizeof(hdr)); 78103d196b7SBharata B Rao g_free(fdt); 78203d196b7SBharata B Rao 78303d196b7SBharata B Rao return 0; 78403d196b7SBharata B Rao } 78503d196b7SBharata B Rao 7863f5dabceSDavid Gibson static void spapr_dt_rtas(sPAPRMachineState *spapr, void *fdt) 7873f5dabceSDavid Gibson { 7883f5dabceSDavid Gibson int rtas; 7893f5dabceSDavid Gibson GString *hypertas = g_string_sized_new(256); 7903f5dabceSDavid Gibson GString *qemu_hypertas = g_string_sized_new(256); 7913f5dabceSDavid Gibson uint32_t refpoints[] = { cpu_to_be32(0x4), cpu_to_be32(0x4) }; 7923f5dabceSDavid Gibson uint64_t max_hotplug_addr = spapr->hotplug_memory.base + 7933f5dabceSDavid Gibson memory_region_size(&spapr->hotplug_memory.mr); 7943f5dabceSDavid Gibson uint32_t lrdr_capacity[] = { 7953f5dabceSDavid Gibson cpu_to_be32(max_hotplug_addr >> 32), 7963f5dabceSDavid Gibson cpu_to_be32(max_hotplug_addr & 0xffffffff), 7973f5dabceSDavid Gibson 0, cpu_to_be32(SPAPR_MEMORY_BLOCK_SIZE), 7983f5dabceSDavid Gibson cpu_to_be32(max_cpus / smp_threads), 7993f5dabceSDavid Gibson }; 8003f5dabceSDavid Gibson 8013f5dabceSDavid Gibson _FDT(rtas = fdt_add_subnode(fdt, 0, "rtas")); 8023f5dabceSDavid Gibson 8033f5dabceSDavid Gibson /* hypertas */ 8043f5dabceSDavid Gibson add_str(hypertas, "hcall-pft"); 8053f5dabceSDavid Gibson add_str(hypertas, "hcall-term"); 8063f5dabceSDavid Gibson add_str(hypertas, "hcall-dabr"); 8073f5dabceSDavid Gibson add_str(hypertas, "hcall-interrupt"); 8083f5dabceSDavid Gibson add_str(hypertas, "hcall-tce"); 8093f5dabceSDavid Gibson add_str(hypertas, "hcall-vio"); 8103f5dabceSDavid Gibson add_str(hypertas, "hcall-splpar"); 8113f5dabceSDavid Gibson add_str(hypertas, "hcall-bulk"); 8123f5dabceSDavid Gibson add_str(hypertas, "hcall-set-mode"); 8133f5dabceSDavid Gibson add_str(hypertas, "hcall-sprg0"); 8143f5dabceSDavid Gibson add_str(hypertas, "hcall-copy"); 8153f5dabceSDavid Gibson add_str(hypertas, "hcall-debug"); 8163f5dabceSDavid Gibson add_str(qemu_hypertas, "hcall-memop1"); 8173f5dabceSDavid Gibson 8183f5dabceSDavid Gibson if (!kvm_enabled() || kvmppc_spapr_use_multitce()) { 8193f5dabceSDavid Gibson add_str(hypertas, "hcall-multi-tce"); 8203f5dabceSDavid Gibson } 8213f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,hypertas-functions", 8223f5dabceSDavid Gibson hypertas->str, hypertas->len)); 8233f5dabceSDavid Gibson g_string_free(hypertas, TRUE); 8243f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "qemu,hypertas-functions", 8253f5dabceSDavid Gibson qemu_hypertas->str, qemu_hypertas->len)); 8263f5dabceSDavid Gibson g_string_free(qemu_hypertas, TRUE); 8273f5dabceSDavid Gibson 8283f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,associativity-reference-points", 8293f5dabceSDavid Gibson refpoints, sizeof(refpoints))); 8303f5dabceSDavid Gibson 8313f5dabceSDavid Gibson _FDT(fdt_setprop_cell(fdt, rtas, "rtas-error-log-max", 8323f5dabceSDavid Gibson RTAS_ERROR_LOG_MAX)); 8333f5dabceSDavid Gibson _FDT(fdt_setprop_cell(fdt, rtas, "rtas-event-scan-rate", 8343f5dabceSDavid Gibson RTAS_EVENT_SCAN_RATE)); 8353f5dabceSDavid Gibson 8363f5dabceSDavid Gibson if (msi_nonbroken) { 8373f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,change-msix-capable", NULL, 0)); 8383f5dabceSDavid Gibson } 8393f5dabceSDavid Gibson 8403f5dabceSDavid Gibson /* 8413f5dabceSDavid Gibson * According to PAPR, rtas ibm,os-term does not guarantee a return 8423f5dabceSDavid Gibson * back to the guest cpu. 8433f5dabceSDavid Gibson * 8443f5dabceSDavid Gibson * While an additional ibm,extended-os-term property indicates 8453f5dabceSDavid Gibson * that rtas call return will always occur. Set this property. 8463f5dabceSDavid Gibson */ 8473f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,extended-os-term", NULL, 0)); 8483f5dabceSDavid Gibson 8493f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,lrdr-capacity", 8503f5dabceSDavid Gibson lrdr_capacity, sizeof(lrdr_capacity))); 8513f5dabceSDavid Gibson 8523f5dabceSDavid Gibson spapr_dt_rtas_tokens(fdt, rtas); 8533f5dabceSDavid Gibson } 8543f5dabceSDavid Gibson 8559fb4541fSSam Bobroff /* Prepare ibm,arch-vec-5-platform-support, which indicates the MMU features 8569fb4541fSSam Bobroff * that the guest may request and thus the valid values for bytes 24..26 of 8579fb4541fSSam Bobroff * option vector 5: */ 8589fb4541fSSam Bobroff static void spapr_dt_ov5_platform_support(void *fdt, int chosen) 8599fb4541fSSam Bobroff { 860545d6e2bSSuraj Jitindar Singh PowerPCCPU *first_ppc_cpu = POWERPC_CPU(first_cpu); 861545d6e2bSSuraj Jitindar Singh 8629fb4541fSSam Bobroff char val[2 * 3] = { 8639fb4541fSSam Bobroff 24, 0x00, /* Hash/Radix, filled in below. */ 8649fb4541fSSam Bobroff 25, 0x00, /* Hash options: Segment Tables == no, GTSE == no. */ 8659fb4541fSSam Bobroff 26, 0x40, /* Radix options: GTSE == yes. */ 8669fb4541fSSam Bobroff }; 8679fb4541fSSam Bobroff 8689fb4541fSSam Bobroff if (kvm_enabled()) { 8699fb4541fSSam Bobroff if (kvmppc_has_cap_mmu_radix() && kvmppc_has_cap_mmu_hash_v3()) { 8709fb4541fSSam Bobroff val[1] = 0x80; /* OV5_MMU_BOTH */ 8719fb4541fSSam Bobroff } else if (kvmppc_has_cap_mmu_radix()) { 8729fb4541fSSam Bobroff val[1] = 0x40; /* OV5_MMU_RADIX_300 */ 8739fb4541fSSam Bobroff } else { 8749fb4541fSSam Bobroff val[1] = 0x00; /* Hash */ 8759fb4541fSSam Bobroff } 8769fb4541fSSam Bobroff } else { 877545d6e2bSSuraj Jitindar Singh if (first_ppc_cpu->env.mmu_model & POWERPC_MMU_V3) { 878545d6e2bSSuraj Jitindar Singh /* V3 MMU supports both hash and radix (with dynamic switching) */ 879545d6e2bSSuraj Jitindar Singh val[1] = 0xC0; 880545d6e2bSSuraj Jitindar Singh } else { 881545d6e2bSSuraj Jitindar Singh /* Otherwise we can only do hash */ 8829fb4541fSSam Bobroff val[1] = 0x00; 8839fb4541fSSam Bobroff } 884545d6e2bSSuraj Jitindar Singh } 8859fb4541fSSam Bobroff _FDT(fdt_setprop(fdt, chosen, "ibm,arch-vec-5-platform-support", 8869fb4541fSSam Bobroff val, sizeof(val))); 8879fb4541fSSam Bobroff } 8889fb4541fSSam Bobroff 8897c866c6aSDavid Gibson static void spapr_dt_chosen(sPAPRMachineState *spapr, void *fdt) 8907c866c6aSDavid Gibson { 8917c866c6aSDavid Gibson MachineState *machine = MACHINE(spapr); 8927c866c6aSDavid Gibson int chosen; 8937c866c6aSDavid Gibson const char *boot_device = machine->boot_order; 8947c866c6aSDavid Gibson char *stdout_path = spapr_vio_stdout_path(spapr->vio_bus); 8957c866c6aSDavid Gibson size_t cb = 0; 8967c866c6aSDavid Gibson char *bootlist = get_boot_devices_list(&cb, true); 8977c866c6aSDavid Gibson 8987c866c6aSDavid Gibson _FDT(chosen = fdt_add_subnode(fdt, 0, "chosen")); 8997c866c6aSDavid Gibson 9007c866c6aSDavid Gibson _FDT(fdt_setprop_string(fdt, chosen, "bootargs", machine->kernel_cmdline)); 9017c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "linux,initrd-start", 9027c866c6aSDavid Gibson spapr->initrd_base)); 9037c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "linux,initrd-end", 9047c866c6aSDavid Gibson spapr->initrd_base + spapr->initrd_size)); 9057c866c6aSDavid Gibson 9067c866c6aSDavid Gibson if (spapr->kernel_size) { 9077c866c6aSDavid Gibson uint64_t kprop[2] = { cpu_to_be64(KERNEL_LOAD_ADDR), 9087c866c6aSDavid Gibson cpu_to_be64(spapr->kernel_size) }; 9097c866c6aSDavid Gibson 9107c866c6aSDavid Gibson _FDT(fdt_setprop(fdt, chosen, "qemu,boot-kernel", 9117c866c6aSDavid Gibson &kprop, sizeof(kprop))); 9127c866c6aSDavid Gibson if (spapr->kernel_le) { 9137c866c6aSDavid Gibson _FDT(fdt_setprop(fdt, chosen, "qemu,boot-kernel-le", NULL, 0)); 9147c866c6aSDavid Gibson } 9157c866c6aSDavid Gibson } 9167c866c6aSDavid Gibson if (boot_menu) { 9177c866c6aSDavid Gibson _FDT((fdt_setprop_cell(fdt, chosen, "qemu,boot-menu", boot_menu))); 9187c866c6aSDavid Gibson } 9197c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "qemu,graphic-width", graphic_width)); 9207c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "qemu,graphic-height", graphic_height)); 9217c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "qemu,graphic-depth", graphic_depth)); 9227c866c6aSDavid Gibson 9237c866c6aSDavid Gibson if (cb && bootlist) { 9247c866c6aSDavid Gibson int i; 9257c866c6aSDavid Gibson 9267c866c6aSDavid Gibson for (i = 0; i < cb; i++) { 9277c866c6aSDavid Gibson if (bootlist[i] == '\n') { 9287c866c6aSDavid Gibson bootlist[i] = ' '; 9297c866c6aSDavid Gibson } 9307c866c6aSDavid Gibson } 9317c866c6aSDavid Gibson _FDT(fdt_setprop_string(fdt, chosen, "qemu,boot-list", bootlist)); 9327c866c6aSDavid Gibson } 9337c866c6aSDavid Gibson 9347c866c6aSDavid Gibson if (boot_device && strlen(boot_device)) { 9357c866c6aSDavid Gibson _FDT(fdt_setprop_string(fdt, chosen, "qemu,boot-device", boot_device)); 9367c866c6aSDavid Gibson } 9377c866c6aSDavid Gibson 9387c866c6aSDavid Gibson if (!spapr->has_graphics && stdout_path) { 9397c866c6aSDavid Gibson _FDT(fdt_setprop_string(fdt, chosen, "linux,stdout-path", stdout_path)); 9407c866c6aSDavid Gibson } 9417c866c6aSDavid Gibson 9429fb4541fSSam Bobroff spapr_dt_ov5_platform_support(fdt, chosen); 9439fb4541fSSam Bobroff 9447c866c6aSDavid Gibson g_free(stdout_path); 9457c866c6aSDavid Gibson g_free(bootlist); 9467c866c6aSDavid Gibson } 9477c866c6aSDavid Gibson 948fca5f2dcSDavid Gibson static void spapr_dt_hypervisor(sPAPRMachineState *spapr, void *fdt) 949fca5f2dcSDavid Gibson { 950fca5f2dcSDavid Gibson /* The /hypervisor node isn't in PAPR - this is a hack to allow PR 951fca5f2dcSDavid Gibson * KVM to work under pHyp with some guest co-operation */ 952fca5f2dcSDavid Gibson int hypervisor; 953fca5f2dcSDavid Gibson uint8_t hypercall[16]; 954fca5f2dcSDavid Gibson 955fca5f2dcSDavid Gibson _FDT(hypervisor = fdt_add_subnode(fdt, 0, "hypervisor")); 956fca5f2dcSDavid Gibson /* indicate KVM hypercall interface */ 957fca5f2dcSDavid Gibson _FDT(fdt_setprop_string(fdt, hypervisor, "compatible", "linux,kvm")); 958fca5f2dcSDavid Gibson if (kvmppc_has_cap_fixup_hcalls()) { 959fca5f2dcSDavid Gibson /* 960fca5f2dcSDavid Gibson * Older KVM versions with older guest kernels were broken 961fca5f2dcSDavid Gibson * with the magic page, don't allow the guest to map it. 962fca5f2dcSDavid Gibson */ 963fca5f2dcSDavid Gibson if (!kvmppc_get_hypercall(first_cpu->env_ptr, hypercall, 964fca5f2dcSDavid Gibson sizeof(hypercall))) { 965fca5f2dcSDavid Gibson _FDT(fdt_setprop(fdt, hypervisor, "hcall-instructions", 966fca5f2dcSDavid Gibson hypercall, sizeof(hypercall))); 967fca5f2dcSDavid Gibson } 968fca5f2dcSDavid Gibson } 969fca5f2dcSDavid Gibson } 970fca5f2dcSDavid Gibson 971997b6cfcSDavid Gibson static void *spapr_build_fdt(sPAPRMachineState *spapr, 97253018216SPaolo Bonzini hwaddr rtas_addr, 97353018216SPaolo Bonzini hwaddr rtas_size) 97453018216SPaolo Bonzini { 9755b2128d2SAlexander Graf MachineState *machine = MACHINE(qdev_get_machine()); 9763c0c47e3SDavid Gibson MachineClass *mc = MACHINE_GET_CLASS(machine); 977c20d332aSBharata B Rao sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(machine); 9787c866c6aSDavid Gibson int ret; 97953018216SPaolo Bonzini void *fdt; 98053018216SPaolo Bonzini sPAPRPHBState *phb; 981398a0bd5SDavid Gibson char *buf; 98271cd4dacSCédric Le Goater int smt = kvmppc_smt_threads(); 98353018216SPaolo Bonzini 984398a0bd5SDavid Gibson fdt = g_malloc0(FDT_MAX_SIZE); 985398a0bd5SDavid Gibson _FDT((fdt_create_empty_tree(fdt, FDT_MAX_SIZE))); 98653018216SPaolo Bonzini 987398a0bd5SDavid Gibson /* Root node */ 988398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "device_type", "chrp")); 989398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "model", "IBM pSeries (emulated by qemu)")); 990398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "compatible", "qemu,pseries")); 991398a0bd5SDavid Gibson 992398a0bd5SDavid Gibson /* 993398a0bd5SDavid Gibson * Add info to guest to indentify which host is it being run on 994398a0bd5SDavid Gibson * and what is the uuid of the guest 995398a0bd5SDavid Gibson */ 996398a0bd5SDavid Gibson if (kvmppc_get_host_model(&buf)) { 997398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "host-model", buf)); 998398a0bd5SDavid Gibson g_free(buf); 999398a0bd5SDavid Gibson } 1000398a0bd5SDavid Gibson if (kvmppc_get_host_serial(&buf)) { 1001398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "host-serial", buf)); 1002398a0bd5SDavid Gibson g_free(buf); 1003398a0bd5SDavid Gibson } 1004398a0bd5SDavid Gibson 1005398a0bd5SDavid Gibson buf = qemu_uuid_unparse_strdup(&qemu_uuid); 1006398a0bd5SDavid Gibson 1007398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "vm,uuid", buf)); 1008398a0bd5SDavid Gibson if (qemu_uuid_set) { 1009398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "system-id", buf)); 1010398a0bd5SDavid Gibson } 1011398a0bd5SDavid Gibson g_free(buf); 1012398a0bd5SDavid Gibson 1013398a0bd5SDavid Gibson if (qemu_get_vm_name()) { 1014398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "ibm,partition-name", 1015398a0bd5SDavid Gibson qemu_get_vm_name())); 1016398a0bd5SDavid Gibson } 1017398a0bd5SDavid Gibson 1018398a0bd5SDavid Gibson _FDT(fdt_setprop_cell(fdt, 0, "#address-cells", 2)); 1019398a0bd5SDavid Gibson _FDT(fdt_setprop_cell(fdt, 0, "#size-cells", 2)); 102053018216SPaolo Bonzini 10219b9a1908SDavid Gibson /* /interrupt controller */ 102271cd4dacSCédric Le Goater spapr_dt_xics(DIV_ROUND_UP(max_cpus * smt, smp_threads), fdt, PHANDLE_XICP); 10239b9a1908SDavid Gibson 1024e8f986fcSBharata B Rao ret = spapr_populate_memory(spapr, fdt); 1025e8f986fcSBharata B Rao if (ret < 0) { 1026ce9863b7SCédric Le Goater error_report("couldn't setup memory nodes in fdt"); 1027e8f986fcSBharata B Rao exit(1); 102853018216SPaolo Bonzini } 102953018216SPaolo Bonzini 1030bf5a6696SDavid Gibson /* /vdevice */ 1031bf5a6696SDavid Gibson spapr_dt_vdevice(spapr->vio_bus, fdt); 103253018216SPaolo Bonzini 10334d9392beSThomas Huth if (object_resolve_path_type("", TYPE_SPAPR_RNG, NULL)) { 10344d9392beSThomas Huth ret = spapr_rng_populate_dt(fdt); 10354d9392beSThomas Huth if (ret < 0) { 1036ce9863b7SCédric Le Goater error_report("could not set up rng device in the fdt"); 10374d9392beSThomas Huth exit(1); 10384d9392beSThomas Huth } 10394d9392beSThomas Huth } 10404d9392beSThomas Huth 104153018216SPaolo Bonzini QLIST_FOREACH(phb, &spapr->phbs, list) { 104253018216SPaolo Bonzini ret = spapr_populate_pci_dt(phb, PHANDLE_XICP, fdt); 104353018216SPaolo Bonzini if (ret < 0) { 1044da34fed7SThomas Huth error_report("couldn't setup PCI devices in fdt"); 104553018216SPaolo Bonzini exit(1); 104653018216SPaolo Bonzini } 1047da34fed7SThomas Huth } 104853018216SPaolo Bonzini 10490da6f3feSBharata B Rao /* cpus */ 10500da6f3feSBharata B Rao spapr_populate_cpus_dt_node(fdt, spapr); 105153018216SPaolo Bonzini 1052c20d332aSBharata B Rao if (smc->dr_lmb_enabled) { 1053c20d332aSBharata B Rao _FDT(spapr_drc_populate_dt(fdt, 0, NULL, SPAPR_DR_CONNECTOR_TYPE_LMB)); 1054c20d332aSBharata B Rao } 1055c20d332aSBharata B Rao 1056c5514d0eSIgor Mammedov if (mc->has_hotpluggable_cpus) { 1057af81cf32SBharata B Rao int offset = fdt_path_offset(fdt, "/cpus"); 1058af81cf32SBharata B Rao ret = spapr_drc_populate_dt(fdt, offset, NULL, 1059af81cf32SBharata B Rao SPAPR_DR_CONNECTOR_TYPE_CPU); 1060af81cf32SBharata B Rao if (ret < 0) { 1061af81cf32SBharata B Rao error_report("Couldn't set up CPU DR device tree properties"); 1062af81cf32SBharata B Rao exit(1); 1063af81cf32SBharata B Rao } 1064af81cf32SBharata B Rao } 1065af81cf32SBharata B Rao 1066ffb1e275SDavid Gibson /* /event-sources */ 1067ffbb1705SMichael Roth spapr_dt_events(spapr, fdt); 1068ffb1e275SDavid Gibson 10693f5dabceSDavid Gibson /* /rtas */ 10703f5dabceSDavid Gibson spapr_dt_rtas(spapr, fdt); 10713f5dabceSDavid Gibson 10727c866c6aSDavid Gibson /* /chosen */ 10737c866c6aSDavid Gibson spapr_dt_chosen(spapr, fdt); 1074cf6e5223SDavid Gibson 1075fca5f2dcSDavid Gibson /* /hypervisor */ 1076fca5f2dcSDavid Gibson if (kvm_enabled()) { 1077fca5f2dcSDavid Gibson spapr_dt_hypervisor(spapr, fdt); 1078fca5f2dcSDavid Gibson } 1079fca5f2dcSDavid Gibson 1080cf6e5223SDavid Gibson /* Build memory reserve map */ 1081cf6e5223SDavid Gibson if (spapr->kernel_size) { 1082cf6e5223SDavid Gibson _FDT((fdt_add_mem_rsv(fdt, KERNEL_LOAD_ADDR, spapr->kernel_size))); 1083cf6e5223SDavid Gibson } 1084cf6e5223SDavid Gibson if (spapr->initrd_size) { 1085cf6e5223SDavid Gibson _FDT((fdt_add_mem_rsv(fdt, spapr->initrd_base, spapr->initrd_size))); 1086cf6e5223SDavid Gibson } 1087cf6e5223SDavid Gibson 10886787d27bSMichael Roth /* ibm,client-architecture-support updates */ 10896787d27bSMichael Roth ret = spapr_dt_cas_updates(spapr, fdt, spapr->ov5_cas); 10906787d27bSMichael Roth if (ret < 0) { 10916787d27bSMichael Roth error_report("couldn't setup CAS properties fdt"); 10926787d27bSMichael Roth exit(1); 10936787d27bSMichael Roth } 10946787d27bSMichael Roth 1095997b6cfcSDavid Gibson return fdt; 109653018216SPaolo Bonzini } 109753018216SPaolo Bonzini 109853018216SPaolo Bonzini static uint64_t translate_kernel_address(void *opaque, uint64_t addr) 109953018216SPaolo Bonzini { 110053018216SPaolo Bonzini return (addr & 0x0fffffff) + KERNEL_LOAD_ADDR; 110153018216SPaolo Bonzini } 110253018216SPaolo Bonzini 11031d1be34dSDavid Gibson static void emulate_spapr_hypercall(PPCVirtualHypervisor *vhyp, 11041d1be34dSDavid Gibson PowerPCCPU *cpu) 110553018216SPaolo Bonzini { 110653018216SPaolo Bonzini CPUPPCState *env = &cpu->env; 110753018216SPaolo Bonzini 11088d04fb55SJan Kiszka /* The TCG path should also be holding the BQL at this point */ 11098d04fb55SJan Kiszka g_assert(qemu_mutex_iothread_locked()); 11108d04fb55SJan Kiszka 111153018216SPaolo Bonzini if (msr_pr) { 111253018216SPaolo Bonzini hcall_dprintf("Hypercall made with MSR[PR]=1\n"); 111353018216SPaolo Bonzini env->gpr[3] = H_PRIVILEGE; 111453018216SPaolo Bonzini } else { 111553018216SPaolo Bonzini env->gpr[3] = spapr_hypercall(cpu, env->gpr[3], &env->gpr[4]); 111653018216SPaolo Bonzini } 111753018216SPaolo Bonzini } 111853018216SPaolo Bonzini 11199861bb3eSSuraj Jitindar Singh static uint64_t spapr_get_patbe(PPCVirtualHypervisor *vhyp) 11209861bb3eSSuraj Jitindar Singh { 11219861bb3eSSuraj Jitindar Singh sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 11229861bb3eSSuraj Jitindar Singh 11239861bb3eSSuraj Jitindar Singh return spapr->patb_entry; 11249861bb3eSSuraj Jitindar Singh } 11259861bb3eSSuraj Jitindar Singh 1126e6b8fd24SSamuel Mendoza-Jonas #define HPTE(_table, _i) (void *)(((uint64_t *)(_table)) + ((_i) * 2)) 1127e6b8fd24SSamuel Mendoza-Jonas #define HPTE_VALID(_hpte) (tswap64(*((uint64_t *)(_hpte))) & HPTE64_V_VALID) 1128e6b8fd24SSamuel Mendoza-Jonas #define HPTE_DIRTY(_hpte) (tswap64(*((uint64_t *)(_hpte))) & HPTE64_V_HPTE_DIRTY) 1129e6b8fd24SSamuel Mendoza-Jonas #define CLEAN_HPTE(_hpte) ((*(uint64_t *)(_hpte)) &= tswap64(~HPTE64_V_HPTE_DIRTY)) 1130e6b8fd24SSamuel Mendoza-Jonas #define DIRTY_HPTE(_hpte) ((*(uint64_t *)(_hpte)) |= tswap64(HPTE64_V_HPTE_DIRTY)) 1131e6b8fd24SSamuel Mendoza-Jonas 1132715c5407SDavid Gibson /* 1133715c5407SDavid Gibson * Get the fd to access the kernel htab, re-opening it if necessary 1134715c5407SDavid Gibson */ 1135715c5407SDavid Gibson static int get_htab_fd(sPAPRMachineState *spapr) 1136715c5407SDavid Gibson { 1137715c5407SDavid Gibson if (spapr->htab_fd >= 0) { 1138715c5407SDavid Gibson return spapr->htab_fd; 1139715c5407SDavid Gibson } 1140715c5407SDavid Gibson 1141715c5407SDavid Gibson spapr->htab_fd = kvmppc_get_htab_fd(false); 1142715c5407SDavid Gibson if (spapr->htab_fd < 0) { 1143715c5407SDavid Gibson error_report("Unable to open fd for reading hash table from KVM: %s", 1144715c5407SDavid Gibson strerror(errno)); 1145715c5407SDavid Gibson } 1146715c5407SDavid Gibson 1147715c5407SDavid Gibson return spapr->htab_fd; 1148715c5407SDavid Gibson } 1149715c5407SDavid Gibson 1150b4db5413SSuraj Jitindar Singh void close_htab_fd(sPAPRMachineState *spapr) 1151715c5407SDavid Gibson { 1152715c5407SDavid Gibson if (spapr->htab_fd >= 0) { 1153715c5407SDavid Gibson close(spapr->htab_fd); 1154715c5407SDavid Gibson } 1155715c5407SDavid Gibson spapr->htab_fd = -1; 1156715c5407SDavid Gibson } 1157715c5407SDavid Gibson 1158e57ca75cSDavid Gibson static hwaddr spapr_hpt_mask(PPCVirtualHypervisor *vhyp) 1159e57ca75cSDavid Gibson { 1160e57ca75cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 1161e57ca75cSDavid Gibson 1162e57ca75cSDavid Gibson return HTAB_SIZE(spapr) / HASH_PTEG_SIZE_64 - 1; 1163e57ca75cSDavid Gibson } 1164e57ca75cSDavid Gibson 1165e57ca75cSDavid Gibson static const ppc_hash_pte64_t *spapr_map_hptes(PPCVirtualHypervisor *vhyp, 1166e57ca75cSDavid Gibson hwaddr ptex, int n) 1167e57ca75cSDavid Gibson { 1168e57ca75cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 1169e57ca75cSDavid Gibson hwaddr pte_offset = ptex * HASH_PTE_SIZE_64; 1170e57ca75cSDavid Gibson 1171e57ca75cSDavid Gibson if (!spapr->htab) { 1172e57ca75cSDavid Gibson /* 1173e57ca75cSDavid Gibson * HTAB is controlled by KVM. Fetch into temporary buffer 1174e57ca75cSDavid Gibson */ 1175e57ca75cSDavid Gibson ppc_hash_pte64_t *hptes = g_malloc(n * HASH_PTE_SIZE_64); 1176e57ca75cSDavid Gibson kvmppc_read_hptes(hptes, ptex, n); 1177e57ca75cSDavid Gibson return hptes; 1178e57ca75cSDavid Gibson } 1179e57ca75cSDavid Gibson 1180e57ca75cSDavid Gibson /* 1181e57ca75cSDavid Gibson * HTAB is controlled by QEMU. Just point to the internally 1182e57ca75cSDavid Gibson * accessible PTEG. 1183e57ca75cSDavid Gibson */ 1184e57ca75cSDavid Gibson return (const ppc_hash_pte64_t *)(spapr->htab + pte_offset); 1185e57ca75cSDavid Gibson } 1186e57ca75cSDavid Gibson 1187e57ca75cSDavid Gibson static void spapr_unmap_hptes(PPCVirtualHypervisor *vhyp, 1188e57ca75cSDavid Gibson const ppc_hash_pte64_t *hptes, 1189e57ca75cSDavid Gibson hwaddr ptex, int n) 1190e57ca75cSDavid Gibson { 1191e57ca75cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 1192e57ca75cSDavid Gibson 1193e57ca75cSDavid Gibson if (!spapr->htab) { 1194e57ca75cSDavid Gibson g_free((void *)hptes); 1195e57ca75cSDavid Gibson } 1196e57ca75cSDavid Gibson 1197e57ca75cSDavid Gibson /* Nothing to do for qemu managed HPT */ 1198e57ca75cSDavid Gibson } 1199e57ca75cSDavid Gibson 1200e57ca75cSDavid Gibson static void spapr_store_hpte(PPCVirtualHypervisor *vhyp, hwaddr ptex, 1201e57ca75cSDavid Gibson uint64_t pte0, uint64_t pte1) 1202e57ca75cSDavid Gibson { 1203e57ca75cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 1204e57ca75cSDavid Gibson hwaddr offset = ptex * HASH_PTE_SIZE_64; 1205e57ca75cSDavid Gibson 1206e57ca75cSDavid Gibson if (!spapr->htab) { 1207e57ca75cSDavid Gibson kvmppc_write_hpte(ptex, pte0, pte1); 1208e57ca75cSDavid Gibson } else { 1209e57ca75cSDavid Gibson stq_p(spapr->htab + offset, pte0); 1210e57ca75cSDavid Gibson stq_p(spapr->htab + offset + HASH_PTE_SIZE_64 / 2, pte1); 1211e57ca75cSDavid Gibson } 1212e57ca75cSDavid Gibson } 1213e57ca75cSDavid Gibson 12148dfe8e7fSDavid Gibson static int spapr_hpt_shift_for_ramsize(uint64_t ramsize) 12158dfe8e7fSDavid Gibson { 12168dfe8e7fSDavid Gibson int shift; 12178dfe8e7fSDavid Gibson 12188dfe8e7fSDavid Gibson /* We aim for a hash table of size 1/128 the size of RAM (rounded 12198dfe8e7fSDavid Gibson * up). The PAPR recommendation is actually 1/64 of RAM size, but 12208dfe8e7fSDavid Gibson * that's much more than is needed for Linux guests */ 12218dfe8e7fSDavid Gibson shift = ctz64(pow2ceil(ramsize)) - 7; 12228dfe8e7fSDavid Gibson shift = MAX(shift, 18); /* Minimum architected size */ 12238dfe8e7fSDavid Gibson shift = MIN(shift, 46); /* Maximum architected size */ 12248dfe8e7fSDavid Gibson return shift; 12258dfe8e7fSDavid Gibson } 12268dfe8e7fSDavid Gibson 122706ec79e8SBharata B Rao void spapr_free_hpt(sPAPRMachineState *spapr) 122806ec79e8SBharata B Rao { 122906ec79e8SBharata B Rao g_free(spapr->htab); 123006ec79e8SBharata B Rao spapr->htab = NULL; 123106ec79e8SBharata B Rao spapr->htab_shift = 0; 123206ec79e8SBharata B Rao close_htab_fd(spapr); 123306ec79e8SBharata B Rao } 123406ec79e8SBharata B Rao 1235c5f54f3eSDavid Gibson static void spapr_reallocate_hpt(sPAPRMachineState *spapr, int shift, 1236c5f54f3eSDavid Gibson Error **errp) 123753018216SPaolo Bonzini { 1238c5f54f3eSDavid Gibson long rc; 123953018216SPaolo Bonzini 1240c5f54f3eSDavid Gibson /* Clean up any HPT info from a previous boot */ 124106ec79e8SBharata B Rao spapr_free_hpt(spapr); 124253018216SPaolo Bonzini 1243c5f54f3eSDavid Gibson rc = kvmppc_reset_htab(shift); 1244c5f54f3eSDavid Gibson if (rc < 0) { 1245c5f54f3eSDavid Gibson /* kernel-side HPT needed, but couldn't allocate one */ 1246c5f54f3eSDavid Gibson error_setg_errno(errp, errno, 1247c5f54f3eSDavid Gibson "Failed to allocate KVM HPT of order %d (try smaller maxmem?)", 1248c5f54f3eSDavid Gibson shift); 1249c5f54f3eSDavid Gibson /* This is almost certainly fatal, but if the caller really 1250c5f54f3eSDavid Gibson * wants to carry on with shift == 0, it's welcome to try */ 1251c5f54f3eSDavid Gibson } else if (rc > 0) { 1252c5f54f3eSDavid Gibson /* kernel-side HPT allocated */ 1253c5f54f3eSDavid Gibson if (rc != shift) { 1254c5f54f3eSDavid Gibson error_setg(errp, 1255c5f54f3eSDavid Gibson "Requested order %d HPT, but kernel allocated order %ld (try smaller maxmem?)", 1256c5f54f3eSDavid Gibson shift, rc); 12577735fedaSBharata B Rao } 12587735fedaSBharata B Rao 125953018216SPaolo Bonzini spapr->htab_shift = shift; 1260c18ad9a5SDavid Gibson spapr->htab = NULL; 1261b817772aSBharata B Rao } else { 1262c5f54f3eSDavid Gibson /* kernel-side HPT not needed, allocate in userspace instead */ 1263c5f54f3eSDavid Gibson size_t size = 1ULL << shift; 1264c5f54f3eSDavid Gibson int i; 126501a57972SSamuel Mendoza-Jonas 1266c5f54f3eSDavid Gibson spapr->htab = qemu_memalign(size, size); 1267c5f54f3eSDavid Gibson if (!spapr->htab) { 1268c5f54f3eSDavid Gibson error_setg_errno(errp, errno, 1269c5f54f3eSDavid Gibson "Could not allocate HPT of order %d", shift); 1270c5f54f3eSDavid Gibson return; 1271b817772aSBharata B Rao } 1272b817772aSBharata B Rao 1273c5f54f3eSDavid Gibson memset(spapr->htab, 0, size); 1274c5f54f3eSDavid Gibson spapr->htab_shift = shift; 1275b817772aSBharata B Rao 1276c5f54f3eSDavid Gibson for (i = 0; i < size / HASH_PTE_SIZE_64; i++) { 1277c5f54f3eSDavid Gibson DIRTY_HPTE(HPTE(spapr->htab, i)); 12787735fedaSBharata B Rao } 127953018216SPaolo Bonzini } 128053018216SPaolo Bonzini } 128153018216SPaolo Bonzini 1282b4db5413SSuraj Jitindar Singh void spapr_setup_hpt_and_vrma(sPAPRMachineState *spapr) 1283b4db5413SSuraj Jitindar Singh { 1284b4db5413SSuraj Jitindar Singh spapr_reallocate_hpt(spapr, 1285b4db5413SSuraj Jitindar Singh spapr_hpt_shift_for_ramsize(MACHINE(spapr)->maxram_size), 1286b4db5413SSuraj Jitindar Singh &error_fatal); 1287b4db5413SSuraj Jitindar Singh if (spapr->vrma_adjust) { 1288b4db5413SSuraj Jitindar Singh spapr->rma_size = kvmppc_rma_size(spapr_node0_size(), 1289b4db5413SSuraj Jitindar Singh spapr->htab_shift); 1290b4db5413SSuraj Jitindar Singh } 1291b4db5413SSuraj Jitindar Singh /* We're setting up a hash table, so that means we're not radix */ 1292b4db5413SSuraj Jitindar Singh spapr->patb_entry = 0; 1293b4db5413SSuraj Jitindar Singh } 1294b4db5413SSuraj Jitindar Singh 12954f01a637SDavid Gibson static void find_unknown_sysbus_device(SysBusDevice *sbdev, void *opaque) 12969e3f9733SAlexander Graf { 12979e3f9733SAlexander Graf bool matched = false; 12989e3f9733SAlexander Graf 12999e3f9733SAlexander Graf if (object_dynamic_cast(OBJECT(sbdev), TYPE_SPAPR_PCI_HOST_BRIDGE)) { 13009e3f9733SAlexander Graf matched = true; 13019e3f9733SAlexander Graf } 13029e3f9733SAlexander Graf 13039e3f9733SAlexander Graf if (!matched) { 13049e3f9733SAlexander Graf error_report("Device %s is not supported by this machine yet.", 13059e3f9733SAlexander Graf qdev_fw_name(DEVICE(sbdev))); 13069e3f9733SAlexander Graf exit(1); 13079e3f9733SAlexander Graf } 13089e3f9733SAlexander Graf } 13099e3f9733SAlexander Graf 131053018216SPaolo Bonzini static void ppc_spapr_reset(void) 131153018216SPaolo Bonzini { 1312c5f54f3eSDavid Gibson MachineState *machine = MACHINE(qdev_get_machine()); 1313c5f54f3eSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(machine); 1314182735efSAndreas Färber PowerPCCPU *first_ppc_cpu; 1315b7d1f77aSBenjamin Herrenschmidt uint32_t rtas_limit; 1316cae172abSDavid Gibson hwaddr rtas_addr, fdt_addr; 1317997b6cfcSDavid Gibson void *fdt; 1318997b6cfcSDavid Gibson int rc; 1319259186a7SAndreas Färber 13209e3f9733SAlexander Graf /* Check for unknown sysbus devices */ 13219e3f9733SAlexander Graf foreach_dynamic_sysbus_device(find_unknown_sysbus_device, NULL); 13229e3f9733SAlexander Graf 1323b4db5413SSuraj Jitindar Singh if (kvm_enabled() && kvmppc_has_cap_mmu_radix()) { 1324b4db5413SSuraj Jitindar Singh /* If using KVM with radix mode available, VCPUs can be started 1325b4db5413SSuraj Jitindar Singh * without a HPT because KVM will start them in radix mode. 1326b4db5413SSuraj Jitindar Singh * Set the GR bit in PATB so that we know there is no HPT. */ 1327b4db5413SSuraj Jitindar Singh spapr->patb_entry = PATBE1_GR; 1328b4db5413SSuraj Jitindar Singh } else { 13299861bb3eSSuraj Jitindar Singh spapr->patb_entry = 0; 1330b4db5413SSuraj Jitindar Singh spapr_setup_hpt_and_vrma(spapr); 1331c5f54f3eSDavid Gibson } 133253018216SPaolo Bonzini 133353018216SPaolo Bonzini qemu_devices_reset(); 133453018216SPaolo Bonzini 1335b7d1f77aSBenjamin Herrenschmidt /* 1336b7d1f77aSBenjamin Herrenschmidt * We place the device tree and RTAS just below either the top of the RMA, 1337b7d1f77aSBenjamin Herrenschmidt * or just below 2GB, whichever is lowere, so that it can be 1338b7d1f77aSBenjamin Herrenschmidt * processed with 32-bit real mode code if necessary 1339b7d1f77aSBenjamin Herrenschmidt */ 1340b7d1f77aSBenjamin Herrenschmidt rtas_limit = MIN(spapr->rma_size, RTAS_MAX_ADDR); 1341cae172abSDavid Gibson rtas_addr = rtas_limit - RTAS_MAX_SIZE; 1342cae172abSDavid Gibson fdt_addr = rtas_addr - FDT_MAX_SIZE; 1343b7d1f77aSBenjamin Herrenschmidt 13446787d27bSMichael Roth /* if this reset wasn't generated by CAS, we should reset our 13456787d27bSMichael Roth * negotiated options and start from scratch */ 13466787d27bSMichael Roth if (!spapr->cas_reboot) { 13476787d27bSMichael Roth spapr_ovec_cleanup(spapr->ov5_cas); 13486787d27bSMichael Roth spapr->ov5_cas = spapr_ovec_new(); 13496787d27bSMichael Roth } 13506787d27bSMichael Roth 1351cae172abSDavid Gibson fdt = spapr_build_fdt(spapr, rtas_addr, spapr->rtas_size); 135253018216SPaolo Bonzini 13532cac78c1SDavid Gibson spapr_load_rtas(spapr, fdt, rtas_addr); 1354b7d1f77aSBenjamin Herrenschmidt 1355997b6cfcSDavid Gibson rc = fdt_pack(fdt); 1356997b6cfcSDavid Gibson 1357997b6cfcSDavid Gibson /* Should only fail if we've built a corrupted tree */ 1358997b6cfcSDavid Gibson assert(rc == 0); 1359997b6cfcSDavid Gibson 1360997b6cfcSDavid Gibson if (fdt_totalsize(fdt) > FDT_MAX_SIZE) { 1361997b6cfcSDavid Gibson error_report("FDT too big ! 0x%x bytes (max is 0x%x)", 1362997b6cfcSDavid Gibson fdt_totalsize(fdt), FDT_MAX_SIZE); 1363997b6cfcSDavid Gibson exit(1); 1364997b6cfcSDavid Gibson } 1365997b6cfcSDavid Gibson 1366997b6cfcSDavid Gibson /* Load the fdt */ 1367997b6cfcSDavid Gibson qemu_fdt_dumpdtb(fdt, fdt_totalsize(fdt)); 1368cae172abSDavid Gibson cpu_physical_memory_write(fdt_addr, fdt, fdt_totalsize(fdt)); 1369997b6cfcSDavid Gibson g_free(fdt); 1370997b6cfcSDavid Gibson 137153018216SPaolo Bonzini /* Set up the entry state */ 1372182735efSAndreas Färber first_ppc_cpu = POWERPC_CPU(first_cpu); 1373cae172abSDavid Gibson first_ppc_cpu->env.gpr[3] = fdt_addr; 1374182735efSAndreas Färber first_ppc_cpu->env.gpr[5] = 0; 1375182735efSAndreas Färber first_cpu->halted = 0; 13761b718907SDavid Gibson first_ppc_cpu->env.nip = SPAPR_ENTRY_POINT; 137753018216SPaolo Bonzini 13786787d27bSMichael Roth spapr->cas_reboot = false; 137953018216SPaolo Bonzini } 138053018216SPaolo Bonzini 138128e02042SDavid Gibson static void spapr_create_nvram(sPAPRMachineState *spapr) 138253018216SPaolo Bonzini { 13832ff3de68SMarkus Armbruster DeviceState *dev = qdev_create(&spapr->vio_bus->bus, "spapr-nvram"); 13843978b863SPaolo Bonzini DriveInfo *dinfo = drive_get(IF_PFLASH, 0, 0); 138553018216SPaolo Bonzini 13863978b863SPaolo Bonzini if (dinfo) { 13876231a6daSMarkus Armbruster qdev_prop_set_drive(dev, "drive", blk_by_legacy_dinfo(dinfo), 13886231a6daSMarkus Armbruster &error_fatal); 138953018216SPaolo Bonzini } 139053018216SPaolo Bonzini 139153018216SPaolo Bonzini qdev_init_nofail(dev); 139253018216SPaolo Bonzini 139353018216SPaolo Bonzini spapr->nvram = (struct sPAPRNVRAM *)dev; 139453018216SPaolo Bonzini } 139553018216SPaolo Bonzini 139628e02042SDavid Gibson static void spapr_rtc_create(sPAPRMachineState *spapr) 139728df36a1SDavid Gibson { 1398147ff807SCédric Le Goater object_initialize(&spapr->rtc, sizeof(spapr->rtc), TYPE_SPAPR_RTC); 1399147ff807SCédric Le Goater object_property_add_child(OBJECT(spapr), "rtc", OBJECT(&spapr->rtc), 1400147ff807SCédric Le Goater &error_fatal); 1401147ff807SCédric Le Goater object_property_set_bool(OBJECT(&spapr->rtc), true, "realized", 1402147ff807SCédric Le Goater &error_fatal); 1403147ff807SCédric Le Goater object_property_add_alias(OBJECT(spapr), "rtc-time", OBJECT(&spapr->rtc), 1404147ff807SCédric Le Goater "date", &error_fatal); 140528df36a1SDavid Gibson } 140628df36a1SDavid Gibson 140753018216SPaolo Bonzini /* Returns whether we want to use VGA or not */ 140814c6a894SDavid Gibson static bool spapr_vga_init(PCIBus *pci_bus, Error **errp) 140953018216SPaolo Bonzini { 141053018216SPaolo Bonzini switch (vga_interface_type) { 141153018216SPaolo Bonzini case VGA_NONE: 14127effdaa3SMark Wu return false; 14137effdaa3SMark Wu case VGA_DEVICE: 14147effdaa3SMark Wu return true; 141553018216SPaolo Bonzini case VGA_STD: 1416b798c190SBenjamin Herrenschmidt case VGA_VIRTIO: 141753018216SPaolo Bonzini return pci_vga_init(pci_bus) != NULL; 141853018216SPaolo Bonzini default: 141914c6a894SDavid Gibson error_setg(errp, 142014c6a894SDavid Gibson "Unsupported VGA mode, only -vga std or -vga virtio is supported"); 142114c6a894SDavid Gibson return false; 142253018216SPaolo Bonzini } 142353018216SPaolo Bonzini } 142453018216SPaolo Bonzini 1425880ae7deSDavid Gibson static int spapr_post_load(void *opaque, int version_id) 1426880ae7deSDavid Gibson { 142728e02042SDavid Gibson sPAPRMachineState *spapr = (sPAPRMachineState *)opaque; 1428880ae7deSDavid Gibson int err = 0; 1429880ae7deSDavid Gibson 1430a7ff1212SCédric Le Goater if (!object_dynamic_cast(OBJECT(spapr->ics), TYPE_ICS_KVM)) { 14315bc8d26dSCédric Le Goater CPUState *cs; 14325bc8d26dSCédric Le Goater CPU_FOREACH(cs) { 14335bc8d26dSCédric Le Goater PowerPCCPU *cpu = POWERPC_CPU(cs); 14345bc8d26dSCédric Le Goater icp_resend(ICP(cpu->intc)); 1435a7ff1212SCédric Le Goater } 1436a7ff1212SCédric Le Goater } 1437a7ff1212SCédric Le Goater 1438631b22eaSStefan Weil /* In earlier versions, there was no separate qdev for the PAPR 1439880ae7deSDavid Gibson * RTC, so the RTC offset was stored directly in sPAPREnvironment. 1440880ae7deSDavid Gibson * So when migrating from those versions, poke the incoming offset 1441880ae7deSDavid Gibson * value into the RTC device */ 1442880ae7deSDavid Gibson if (version_id < 3) { 1443147ff807SCédric Le Goater err = spapr_rtc_import_offset(&spapr->rtc, spapr->rtc_offset); 1444880ae7deSDavid Gibson } 1445880ae7deSDavid Gibson 1446880ae7deSDavid Gibson return err; 1447880ae7deSDavid Gibson } 1448880ae7deSDavid Gibson 1449880ae7deSDavid Gibson static bool version_before_3(void *opaque, int version_id) 1450880ae7deSDavid Gibson { 1451880ae7deSDavid Gibson return version_id < 3; 1452880ae7deSDavid Gibson } 1453880ae7deSDavid Gibson 145462ef3760SMichael Roth static bool spapr_ov5_cas_needed(void *opaque) 145562ef3760SMichael Roth { 145662ef3760SMichael Roth sPAPRMachineState *spapr = opaque; 145762ef3760SMichael Roth sPAPROptionVector *ov5_mask = spapr_ovec_new(); 145862ef3760SMichael Roth sPAPROptionVector *ov5_legacy = spapr_ovec_new(); 145962ef3760SMichael Roth sPAPROptionVector *ov5_removed = spapr_ovec_new(); 146062ef3760SMichael Roth bool cas_needed; 146162ef3760SMichael Roth 146262ef3760SMichael Roth /* Prior to the introduction of sPAPROptionVector, we had two option 146362ef3760SMichael Roth * vectors we dealt with: OV5_FORM1_AFFINITY, and OV5_DRCONF_MEMORY. 146462ef3760SMichael Roth * Both of these options encode machine topology into the device-tree 146562ef3760SMichael Roth * in such a way that the now-booted OS should still be able to interact 146662ef3760SMichael Roth * appropriately with QEMU regardless of what options were actually 146762ef3760SMichael Roth * negotiatied on the source side. 146862ef3760SMichael Roth * 146962ef3760SMichael Roth * As such, we can avoid migrating the CAS-negotiated options if these 147062ef3760SMichael Roth * are the only options available on the current machine/platform. 147162ef3760SMichael Roth * Since these are the only options available for pseries-2.7 and 147262ef3760SMichael Roth * earlier, this allows us to maintain old->new/new->old migration 147362ef3760SMichael Roth * compatibility. 147462ef3760SMichael Roth * 147562ef3760SMichael Roth * For QEMU 2.8+, there are additional CAS-negotiatable options available 147662ef3760SMichael Roth * via default pseries-2.8 machines and explicit command-line parameters. 147762ef3760SMichael Roth * Some of these options, like OV5_HP_EVT, *do* require QEMU to be aware 147862ef3760SMichael Roth * of the actual CAS-negotiated values to continue working properly. For 147962ef3760SMichael Roth * example, availability of memory unplug depends on knowing whether 148062ef3760SMichael Roth * OV5_HP_EVT was negotiated via CAS. 148162ef3760SMichael Roth * 148262ef3760SMichael Roth * Thus, for any cases where the set of available CAS-negotiatable 148362ef3760SMichael Roth * options extends beyond OV5_FORM1_AFFINITY and OV5_DRCONF_MEMORY, we 148462ef3760SMichael Roth * include the CAS-negotiated options in the migration stream. 148562ef3760SMichael Roth */ 148662ef3760SMichael Roth spapr_ovec_set(ov5_mask, OV5_FORM1_AFFINITY); 148762ef3760SMichael Roth spapr_ovec_set(ov5_mask, OV5_DRCONF_MEMORY); 148862ef3760SMichael Roth 148962ef3760SMichael Roth /* spapr_ovec_diff returns true if bits were removed. we avoid using 149062ef3760SMichael Roth * the mask itself since in the future it's possible "legacy" bits may be 149162ef3760SMichael Roth * removed via machine options, which could generate a false positive 149262ef3760SMichael Roth * that breaks migration. 149362ef3760SMichael Roth */ 149462ef3760SMichael Roth spapr_ovec_intersect(ov5_legacy, spapr->ov5, ov5_mask); 149562ef3760SMichael Roth cas_needed = spapr_ovec_diff(ov5_removed, spapr->ov5, ov5_legacy); 149662ef3760SMichael Roth 149762ef3760SMichael Roth spapr_ovec_cleanup(ov5_mask); 149862ef3760SMichael Roth spapr_ovec_cleanup(ov5_legacy); 149962ef3760SMichael Roth spapr_ovec_cleanup(ov5_removed); 150062ef3760SMichael Roth 150162ef3760SMichael Roth return cas_needed; 150262ef3760SMichael Roth } 150362ef3760SMichael Roth 150462ef3760SMichael Roth static const VMStateDescription vmstate_spapr_ov5_cas = { 150562ef3760SMichael Roth .name = "spapr_option_vector_ov5_cas", 150662ef3760SMichael Roth .version_id = 1, 150762ef3760SMichael Roth .minimum_version_id = 1, 150862ef3760SMichael Roth .needed = spapr_ov5_cas_needed, 150962ef3760SMichael Roth .fields = (VMStateField[]) { 151062ef3760SMichael Roth VMSTATE_STRUCT_POINTER_V(ov5_cas, sPAPRMachineState, 1, 151162ef3760SMichael Roth vmstate_spapr_ovec, sPAPROptionVector), 151262ef3760SMichael Roth VMSTATE_END_OF_LIST() 151362ef3760SMichael Roth }, 151462ef3760SMichael Roth }; 151562ef3760SMichael Roth 15169861bb3eSSuraj Jitindar Singh static bool spapr_patb_entry_needed(void *opaque) 15179861bb3eSSuraj Jitindar Singh { 15189861bb3eSSuraj Jitindar Singh sPAPRMachineState *spapr = opaque; 15199861bb3eSSuraj Jitindar Singh 15209861bb3eSSuraj Jitindar Singh return !!spapr->patb_entry; 15219861bb3eSSuraj Jitindar Singh } 15229861bb3eSSuraj Jitindar Singh 15239861bb3eSSuraj Jitindar Singh static const VMStateDescription vmstate_spapr_patb_entry = { 15249861bb3eSSuraj Jitindar Singh .name = "spapr_patb_entry", 15259861bb3eSSuraj Jitindar Singh .version_id = 1, 15269861bb3eSSuraj Jitindar Singh .minimum_version_id = 1, 15279861bb3eSSuraj Jitindar Singh .needed = spapr_patb_entry_needed, 15289861bb3eSSuraj Jitindar Singh .fields = (VMStateField[]) { 15299861bb3eSSuraj Jitindar Singh VMSTATE_UINT64(patb_entry, sPAPRMachineState), 15309861bb3eSSuraj Jitindar Singh VMSTATE_END_OF_LIST() 15319861bb3eSSuraj Jitindar Singh }, 15329861bb3eSSuraj Jitindar Singh }; 15339861bb3eSSuraj Jitindar Singh 15344be21d56SDavid Gibson static const VMStateDescription vmstate_spapr = { 15354be21d56SDavid Gibson .name = "spapr", 1536880ae7deSDavid Gibson .version_id = 3, 15374be21d56SDavid Gibson .minimum_version_id = 1, 1538880ae7deSDavid Gibson .post_load = spapr_post_load, 15394be21d56SDavid Gibson .fields = (VMStateField[]) { 1540880ae7deSDavid Gibson /* used to be @next_irq */ 1541880ae7deSDavid Gibson VMSTATE_UNUSED_BUFFER(version_before_3, 0, 4), 15424be21d56SDavid Gibson 15434be21d56SDavid Gibson /* RTC offset */ 154428e02042SDavid Gibson VMSTATE_UINT64_TEST(rtc_offset, sPAPRMachineState, version_before_3), 1545880ae7deSDavid Gibson 154628e02042SDavid Gibson VMSTATE_PPC_TIMEBASE_V(tb, sPAPRMachineState, 2), 15474be21d56SDavid Gibson VMSTATE_END_OF_LIST() 15484be21d56SDavid Gibson }, 154962ef3760SMichael Roth .subsections = (const VMStateDescription*[]) { 155062ef3760SMichael Roth &vmstate_spapr_ov5_cas, 15519861bb3eSSuraj Jitindar Singh &vmstate_spapr_patb_entry, 155262ef3760SMichael Roth NULL 155362ef3760SMichael Roth } 15544be21d56SDavid Gibson }; 15554be21d56SDavid Gibson 15564be21d56SDavid Gibson static int htab_save_setup(QEMUFile *f, void *opaque) 15574be21d56SDavid Gibson { 155828e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 15594be21d56SDavid Gibson 15604be21d56SDavid Gibson /* "Iteration" header */ 15614be21d56SDavid Gibson qemu_put_be32(f, spapr->htab_shift); 15624be21d56SDavid Gibson 1563e68cb8b4SAlexey Kardashevskiy if (spapr->htab) { 1564e68cb8b4SAlexey Kardashevskiy spapr->htab_save_index = 0; 1565e68cb8b4SAlexey Kardashevskiy spapr->htab_first_pass = true; 1566e68cb8b4SAlexey Kardashevskiy } else { 1567e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 15684be21d56SDavid Gibson } 15694be21d56SDavid Gibson 1570e68cb8b4SAlexey Kardashevskiy 1571e68cb8b4SAlexey Kardashevskiy return 0; 1572e68cb8b4SAlexey Kardashevskiy } 15734be21d56SDavid Gibson 157428e02042SDavid Gibson static void htab_save_first_pass(QEMUFile *f, sPAPRMachineState *spapr, 15754be21d56SDavid Gibson int64_t max_ns) 15764be21d56SDavid Gibson { 1577378bc217SDavid Gibson bool has_timeout = max_ns != -1; 15784be21d56SDavid Gibson int htabslots = HTAB_SIZE(spapr) / HASH_PTE_SIZE_64; 15794be21d56SDavid Gibson int index = spapr->htab_save_index; 1580bc72ad67SAlex Bligh int64_t starttime = qemu_clock_get_ns(QEMU_CLOCK_REALTIME); 15814be21d56SDavid Gibson 15824be21d56SDavid Gibson assert(spapr->htab_first_pass); 15834be21d56SDavid Gibson 15844be21d56SDavid Gibson do { 15854be21d56SDavid Gibson int chunkstart; 15864be21d56SDavid Gibson 15874be21d56SDavid Gibson /* Consume invalid HPTEs */ 15884be21d56SDavid Gibson while ((index < htabslots) 15894be21d56SDavid Gibson && !HPTE_VALID(HPTE(spapr->htab, index))) { 15904be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 159124ec2863SMarc-André Lureau index++; 15924be21d56SDavid Gibson } 15934be21d56SDavid Gibson 15944be21d56SDavid Gibson /* Consume valid HPTEs */ 15954be21d56SDavid Gibson chunkstart = index; 1596338c25b6SSamuel Mendoza-Jonas while ((index < htabslots) && (index - chunkstart < USHRT_MAX) 15974be21d56SDavid Gibson && HPTE_VALID(HPTE(spapr->htab, index))) { 15984be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 159924ec2863SMarc-André Lureau index++; 16004be21d56SDavid Gibson } 16014be21d56SDavid Gibson 16024be21d56SDavid Gibson if (index > chunkstart) { 16034be21d56SDavid Gibson int n_valid = index - chunkstart; 16044be21d56SDavid Gibson 16054be21d56SDavid Gibson qemu_put_be32(f, chunkstart); 16064be21d56SDavid Gibson qemu_put_be16(f, n_valid); 16074be21d56SDavid Gibson qemu_put_be16(f, 0); 16084be21d56SDavid Gibson qemu_put_buffer(f, HPTE(spapr->htab, chunkstart), 16094be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_valid); 16104be21d56SDavid Gibson 1611378bc217SDavid Gibson if (has_timeout && 1612378bc217SDavid Gibson (qemu_clock_get_ns(QEMU_CLOCK_REALTIME) - starttime) > max_ns) { 16134be21d56SDavid Gibson break; 16144be21d56SDavid Gibson } 16154be21d56SDavid Gibson } 16164be21d56SDavid Gibson } while ((index < htabslots) && !qemu_file_rate_limit(f)); 16174be21d56SDavid Gibson 16184be21d56SDavid Gibson if (index >= htabslots) { 16194be21d56SDavid Gibson assert(index == htabslots); 16204be21d56SDavid Gibson index = 0; 16214be21d56SDavid Gibson spapr->htab_first_pass = false; 16224be21d56SDavid Gibson } 16234be21d56SDavid Gibson spapr->htab_save_index = index; 16244be21d56SDavid Gibson } 16254be21d56SDavid Gibson 162628e02042SDavid Gibson static int htab_save_later_pass(QEMUFile *f, sPAPRMachineState *spapr, 16274be21d56SDavid Gibson int64_t max_ns) 16284be21d56SDavid Gibson { 16294be21d56SDavid Gibson bool final = max_ns < 0; 16304be21d56SDavid Gibson int htabslots = HTAB_SIZE(spapr) / HASH_PTE_SIZE_64; 16314be21d56SDavid Gibson int examined = 0, sent = 0; 16324be21d56SDavid Gibson int index = spapr->htab_save_index; 1633bc72ad67SAlex Bligh int64_t starttime = qemu_clock_get_ns(QEMU_CLOCK_REALTIME); 16344be21d56SDavid Gibson 16354be21d56SDavid Gibson assert(!spapr->htab_first_pass); 16364be21d56SDavid Gibson 16374be21d56SDavid Gibson do { 16384be21d56SDavid Gibson int chunkstart, invalidstart; 16394be21d56SDavid Gibson 16404be21d56SDavid Gibson /* Consume non-dirty HPTEs */ 16414be21d56SDavid Gibson while ((index < htabslots) 16424be21d56SDavid Gibson && !HPTE_DIRTY(HPTE(spapr->htab, index))) { 16434be21d56SDavid Gibson index++; 16444be21d56SDavid Gibson examined++; 16454be21d56SDavid Gibson } 16464be21d56SDavid Gibson 16474be21d56SDavid Gibson chunkstart = index; 16484be21d56SDavid Gibson /* Consume valid dirty HPTEs */ 1649338c25b6SSamuel Mendoza-Jonas while ((index < htabslots) && (index - chunkstart < USHRT_MAX) 16504be21d56SDavid Gibson && HPTE_DIRTY(HPTE(spapr->htab, index)) 16514be21d56SDavid Gibson && HPTE_VALID(HPTE(spapr->htab, index))) { 16524be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 16534be21d56SDavid Gibson index++; 16544be21d56SDavid Gibson examined++; 16554be21d56SDavid Gibson } 16564be21d56SDavid Gibson 16574be21d56SDavid Gibson invalidstart = index; 16584be21d56SDavid Gibson /* Consume invalid dirty HPTEs */ 1659338c25b6SSamuel Mendoza-Jonas while ((index < htabslots) && (index - invalidstart < USHRT_MAX) 16604be21d56SDavid Gibson && HPTE_DIRTY(HPTE(spapr->htab, index)) 16614be21d56SDavid Gibson && !HPTE_VALID(HPTE(spapr->htab, index))) { 16624be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 16634be21d56SDavid Gibson index++; 16644be21d56SDavid Gibson examined++; 16654be21d56SDavid Gibson } 16664be21d56SDavid Gibson 16674be21d56SDavid Gibson if (index > chunkstart) { 16684be21d56SDavid Gibson int n_valid = invalidstart - chunkstart; 16694be21d56SDavid Gibson int n_invalid = index - invalidstart; 16704be21d56SDavid Gibson 16714be21d56SDavid Gibson qemu_put_be32(f, chunkstart); 16724be21d56SDavid Gibson qemu_put_be16(f, n_valid); 16734be21d56SDavid Gibson qemu_put_be16(f, n_invalid); 16744be21d56SDavid Gibson qemu_put_buffer(f, HPTE(spapr->htab, chunkstart), 16754be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_valid); 16764be21d56SDavid Gibson sent += index - chunkstart; 16774be21d56SDavid Gibson 1678bc72ad67SAlex Bligh if (!final && (qemu_clock_get_ns(QEMU_CLOCK_REALTIME) - starttime) > max_ns) { 16794be21d56SDavid Gibson break; 16804be21d56SDavid Gibson } 16814be21d56SDavid Gibson } 16824be21d56SDavid Gibson 16834be21d56SDavid Gibson if (examined >= htabslots) { 16844be21d56SDavid Gibson break; 16854be21d56SDavid Gibson } 16864be21d56SDavid Gibson 16874be21d56SDavid Gibson if (index >= htabslots) { 16884be21d56SDavid Gibson assert(index == htabslots); 16894be21d56SDavid Gibson index = 0; 16904be21d56SDavid Gibson } 16914be21d56SDavid Gibson } while ((examined < htabslots) && (!qemu_file_rate_limit(f) || final)); 16924be21d56SDavid Gibson 16934be21d56SDavid Gibson if (index >= htabslots) { 16944be21d56SDavid Gibson assert(index == htabslots); 16954be21d56SDavid Gibson index = 0; 16964be21d56SDavid Gibson } 16974be21d56SDavid Gibson 16984be21d56SDavid Gibson spapr->htab_save_index = index; 16994be21d56SDavid Gibson 1700e68cb8b4SAlexey Kardashevskiy return (examined >= htabslots) && (sent == 0) ? 1 : 0; 17014be21d56SDavid Gibson } 17024be21d56SDavid Gibson 1703e68cb8b4SAlexey Kardashevskiy #define MAX_ITERATION_NS 5000000 /* 5 ms */ 1704e68cb8b4SAlexey Kardashevskiy #define MAX_KVM_BUF_SIZE 2048 1705e68cb8b4SAlexey Kardashevskiy 17064be21d56SDavid Gibson static int htab_save_iterate(QEMUFile *f, void *opaque) 17074be21d56SDavid Gibson { 170828e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 1709715c5407SDavid Gibson int fd; 1710e68cb8b4SAlexey Kardashevskiy int rc = 0; 17114be21d56SDavid Gibson 17124be21d56SDavid Gibson /* Iteration header */ 17134be21d56SDavid Gibson qemu_put_be32(f, 0); 17144be21d56SDavid Gibson 1715e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1716e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 1717e68cb8b4SAlexey Kardashevskiy 1718715c5407SDavid Gibson fd = get_htab_fd(spapr); 1719715c5407SDavid Gibson if (fd < 0) { 1720715c5407SDavid Gibson return fd; 172101a57972SSamuel Mendoza-Jonas } 172201a57972SSamuel Mendoza-Jonas 1723715c5407SDavid Gibson rc = kvmppc_save_htab(f, fd, MAX_KVM_BUF_SIZE, MAX_ITERATION_NS); 1724e68cb8b4SAlexey Kardashevskiy if (rc < 0) { 1725e68cb8b4SAlexey Kardashevskiy return rc; 1726e68cb8b4SAlexey Kardashevskiy } 1727e68cb8b4SAlexey Kardashevskiy } else if (spapr->htab_first_pass) { 17284be21d56SDavid Gibson htab_save_first_pass(f, spapr, MAX_ITERATION_NS); 17294be21d56SDavid Gibson } else { 1730e68cb8b4SAlexey Kardashevskiy rc = htab_save_later_pass(f, spapr, MAX_ITERATION_NS); 17314be21d56SDavid Gibson } 17324be21d56SDavid Gibson 17334be21d56SDavid Gibson /* End marker */ 17344be21d56SDavid Gibson qemu_put_be32(f, 0); 17354be21d56SDavid Gibson qemu_put_be16(f, 0); 17364be21d56SDavid Gibson qemu_put_be16(f, 0); 17374be21d56SDavid Gibson 1738e68cb8b4SAlexey Kardashevskiy return rc; 17394be21d56SDavid Gibson } 17404be21d56SDavid Gibson 17414be21d56SDavid Gibson static int htab_save_complete(QEMUFile *f, void *opaque) 17424be21d56SDavid Gibson { 174328e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 1744715c5407SDavid Gibson int fd; 17454be21d56SDavid Gibson 17464be21d56SDavid Gibson /* Iteration header */ 17474be21d56SDavid Gibson qemu_put_be32(f, 0); 17484be21d56SDavid Gibson 1749e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1750e68cb8b4SAlexey Kardashevskiy int rc; 1751e68cb8b4SAlexey Kardashevskiy 1752e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 1753e68cb8b4SAlexey Kardashevskiy 1754715c5407SDavid Gibson fd = get_htab_fd(spapr); 1755715c5407SDavid Gibson if (fd < 0) { 1756715c5407SDavid Gibson return fd; 175701a57972SSamuel Mendoza-Jonas } 175801a57972SSamuel Mendoza-Jonas 1759715c5407SDavid Gibson rc = kvmppc_save_htab(f, fd, MAX_KVM_BUF_SIZE, -1); 1760e68cb8b4SAlexey Kardashevskiy if (rc < 0) { 1761e68cb8b4SAlexey Kardashevskiy return rc; 1762e68cb8b4SAlexey Kardashevskiy } 1763e68cb8b4SAlexey Kardashevskiy } else { 1764378bc217SDavid Gibson if (spapr->htab_first_pass) { 1765378bc217SDavid Gibson htab_save_first_pass(f, spapr, -1); 1766378bc217SDavid Gibson } 17674be21d56SDavid Gibson htab_save_later_pass(f, spapr, -1); 1768e68cb8b4SAlexey Kardashevskiy } 17694be21d56SDavid Gibson 17704be21d56SDavid Gibson /* End marker */ 17714be21d56SDavid Gibson qemu_put_be32(f, 0); 17724be21d56SDavid Gibson qemu_put_be16(f, 0); 17734be21d56SDavid Gibson qemu_put_be16(f, 0); 17744be21d56SDavid Gibson 17754be21d56SDavid Gibson return 0; 17764be21d56SDavid Gibson } 17774be21d56SDavid Gibson 17784be21d56SDavid Gibson static int htab_load(QEMUFile *f, void *opaque, int version_id) 17794be21d56SDavid Gibson { 178028e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 17814be21d56SDavid Gibson uint32_t section_hdr; 1782e68cb8b4SAlexey Kardashevskiy int fd = -1; 17834be21d56SDavid Gibson 17844be21d56SDavid Gibson if (version_id < 1 || version_id > 1) { 178598a5d100SDavid Gibson error_report("htab_load() bad version"); 17864be21d56SDavid Gibson return -EINVAL; 17874be21d56SDavid Gibson } 17884be21d56SDavid Gibson 17894be21d56SDavid Gibson section_hdr = qemu_get_be32(f); 17904be21d56SDavid Gibson 17914be21d56SDavid Gibson if (section_hdr) { 17929897e462SGreg Kurz Error *local_err = NULL; 1793c5f54f3eSDavid Gibson 1794c5f54f3eSDavid Gibson /* First section gives the htab size */ 1795c5f54f3eSDavid Gibson spapr_reallocate_hpt(spapr, section_hdr, &local_err); 1796c5f54f3eSDavid Gibson if (local_err) { 1797c5f54f3eSDavid Gibson error_report_err(local_err); 17984be21d56SDavid Gibson return -EINVAL; 17994be21d56SDavid Gibson } 18004be21d56SDavid Gibson return 0; 18014be21d56SDavid Gibson } 18024be21d56SDavid Gibson 1803e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1804e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 1805e68cb8b4SAlexey Kardashevskiy 1806e68cb8b4SAlexey Kardashevskiy fd = kvmppc_get_htab_fd(true); 1807e68cb8b4SAlexey Kardashevskiy if (fd < 0) { 180898a5d100SDavid Gibson error_report("Unable to open fd to restore KVM hash table: %s", 1809e68cb8b4SAlexey Kardashevskiy strerror(errno)); 1810e68cb8b4SAlexey Kardashevskiy } 1811e68cb8b4SAlexey Kardashevskiy } 1812e68cb8b4SAlexey Kardashevskiy 18134be21d56SDavid Gibson while (true) { 18144be21d56SDavid Gibson uint32_t index; 18154be21d56SDavid Gibson uint16_t n_valid, n_invalid; 18164be21d56SDavid Gibson 18174be21d56SDavid Gibson index = qemu_get_be32(f); 18184be21d56SDavid Gibson n_valid = qemu_get_be16(f); 18194be21d56SDavid Gibson n_invalid = qemu_get_be16(f); 18204be21d56SDavid Gibson 18214be21d56SDavid Gibson if ((index == 0) && (n_valid == 0) && (n_invalid == 0)) { 18224be21d56SDavid Gibson /* End of Stream */ 18234be21d56SDavid Gibson break; 18244be21d56SDavid Gibson } 18254be21d56SDavid Gibson 1826e68cb8b4SAlexey Kardashevskiy if ((index + n_valid + n_invalid) > 18274be21d56SDavid Gibson (HTAB_SIZE(spapr) / HASH_PTE_SIZE_64)) { 18284be21d56SDavid Gibson /* Bad index in stream */ 182998a5d100SDavid Gibson error_report( 183098a5d100SDavid Gibson "htab_load() bad index %d (%hd+%hd entries) in htab stream (htab_shift=%d)", 183198a5d100SDavid Gibson index, n_valid, n_invalid, spapr->htab_shift); 18324be21d56SDavid Gibson return -EINVAL; 18334be21d56SDavid Gibson } 18344be21d56SDavid Gibson 1835e68cb8b4SAlexey Kardashevskiy if (spapr->htab) { 18364be21d56SDavid Gibson if (n_valid) { 18374be21d56SDavid Gibson qemu_get_buffer(f, HPTE(spapr->htab, index), 18384be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_valid); 18394be21d56SDavid Gibson } 18404be21d56SDavid Gibson if (n_invalid) { 18414be21d56SDavid Gibson memset(HPTE(spapr->htab, index + n_valid), 0, 18424be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_invalid); 18434be21d56SDavid Gibson } 1844e68cb8b4SAlexey Kardashevskiy } else { 1845e68cb8b4SAlexey Kardashevskiy int rc; 1846e68cb8b4SAlexey Kardashevskiy 1847e68cb8b4SAlexey Kardashevskiy assert(fd >= 0); 1848e68cb8b4SAlexey Kardashevskiy 1849e68cb8b4SAlexey Kardashevskiy rc = kvmppc_load_htab_chunk(f, fd, index, n_valid, n_invalid); 1850e68cb8b4SAlexey Kardashevskiy if (rc < 0) { 1851e68cb8b4SAlexey Kardashevskiy return rc; 1852e68cb8b4SAlexey Kardashevskiy } 1853e68cb8b4SAlexey Kardashevskiy } 1854e68cb8b4SAlexey Kardashevskiy } 1855e68cb8b4SAlexey Kardashevskiy 1856e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1857e68cb8b4SAlexey Kardashevskiy assert(fd >= 0); 1858e68cb8b4SAlexey Kardashevskiy close(fd); 18594be21d56SDavid Gibson } 18604be21d56SDavid Gibson 18614be21d56SDavid Gibson return 0; 18624be21d56SDavid Gibson } 18634be21d56SDavid Gibson 1864c573fc03SThomas Huth static void htab_cleanup(void *opaque) 1865c573fc03SThomas Huth { 1866c573fc03SThomas Huth sPAPRMachineState *spapr = opaque; 1867c573fc03SThomas Huth 1868c573fc03SThomas Huth close_htab_fd(spapr); 1869c573fc03SThomas Huth } 1870c573fc03SThomas Huth 18714be21d56SDavid Gibson static SaveVMHandlers savevm_htab_handlers = { 18724be21d56SDavid Gibson .save_live_setup = htab_save_setup, 18734be21d56SDavid Gibson .save_live_iterate = htab_save_iterate, 1874a3e06c3dSDr. David Alan Gilbert .save_live_complete_precopy = htab_save_complete, 1875c573fc03SThomas Huth .cleanup = htab_cleanup, 18764be21d56SDavid Gibson .load_state = htab_load, 18774be21d56SDavid Gibson }; 18784be21d56SDavid Gibson 18795b2128d2SAlexander Graf static void spapr_boot_set(void *opaque, const char *boot_device, 18805b2128d2SAlexander Graf Error **errp) 18815b2128d2SAlexander Graf { 18825b2128d2SAlexander Graf MachineState *machine = MACHINE(qdev_get_machine()); 18835b2128d2SAlexander Graf machine->boot_order = g_strdup(boot_device); 18845b2128d2SAlexander Graf } 18855b2128d2SAlexander Graf 1886224245bfSDavid Gibson /* 1887224245bfSDavid Gibson * Reset routine for LMB DR devices. 1888224245bfSDavid Gibson * 1889224245bfSDavid Gibson * Unlike PCI DR devices, LMB DR devices explicitly register this reset 1890224245bfSDavid Gibson * routine. Reset for PCI DR devices will be handled by PHB reset routine 1891224245bfSDavid Gibson * when it walks all its children devices. LMB devices reset occurs 1892224245bfSDavid Gibson * as part of spapr_ppc_reset(). 1893224245bfSDavid Gibson */ 1894224245bfSDavid Gibson static void spapr_drc_reset(void *opaque) 1895224245bfSDavid Gibson { 1896224245bfSDavid Gibson sPAPRDRConnector *drc = opaque; 1897224245bfSDavid Gibson DeviceState *d = DEVICE(drc); 1898224245bfSDavid Gibson 1899224245bfSDavid Gibson if (d) { 1900224245bfSDavid Gibson device_reset(d); 1901224245bfSDavid Gibson } 1902224245bfSDavid Gibson } 1903224245bfSDavid Gibson 1904224245bfSDavid Gibson static void spapr_create_lmb_dr_connectors(sPAPRMachineState *spapr) 1905224245bfSDavid Gibson { 1906224245bfSDavid Gibson MachineState *machine = MACHINE(spapr); 1907224245bfSDavid Gibson uint64_t lmb_size = SPAPR_MEMORY_BLOCK_SIZE; 1908e8f986fcSBharata B Rao uint32_t nr_lmbs = (machine->maxram_size - machine->ram_size)/lmb_size; 1909224245bfSDavid Gibson int i; 1910224245bfSDavid Gibson 1911224245bfSDavid Gibson for (i = 0; i < nr_lmbs; i++) { 1912224245bfSDavid Gibson sPAPRDRConnector *drc; 1913224245bfSDavid Gibson uint64_t addr; 1914224245bfSDavid Gibson 1915e8f986fcSBharata B Rao addr = i * lmb_size + spapr->hotplug_memory.base; 1916224245bfSDavid Gibson drc = spapr_dr_connector_new(OBJECT(spapr), SPAPR_DR_CONNECTOR_TYPE_LMB, 1917224245bfSDavid Gibson addr/lmb_size); 1918224245bfSDavid Gibson qemu_register_reset(spapr_drc_reset, drc); 1919224245bfSDavid Gibson } 1920224245bfSDavid Gibson } 1921224245bfSDavid Gibson 1922224245bfSDavid Gibson /* 1923224245bfSDavid Gibson * If RAM size, maxmem size and individual node mem sizes aren't aligned 1924224245bfSDavid Gibson * to SPAPR_MEMORY_BLOCK_SIZE(256MB), then refuse to start the guest 1925224245bfSDavid Gibson * since we can't support such unaligned sizes with DRCONF_MEMORY. 1926224245bfSDavid Gibson */ 19277c150d6fSDavid Gibson static void spapr_validate_node_memory(MachineState *machine, Error **errp) 1928224245bfSDavid Gibson { 1929224245bfSDavid Gibson int i; 1930224245bfSDavid Gibson 19317c150d6fSDavid Gibson if (machine->ram_size % SPAPR_MEMORY_BLOCK_SIZE) { 19327c150d6fSDavid Gibson error_setg(errp, "Memory size 0x" RAM_ADDR_FMT 19337c150d6fSDavid Gibson " is not aligned to %llu MiB", 19347c150d6fSDavid Gibson machine->ram_size, 1935224245bfSDavid Gibson SPAPR_MEMORY_BLOCK_SIZE / M_BYTE); 19367c150d6fSDavid Gibson return; 19377c150d6fSDavid Gibson } 19387c150d6fSDavid Gibson 19397c150d6fSDavid Gibson if (machine->maxram_size % SPAPR_MEMORY_BLOCK_SIZE) { 19407c150d6fSDavid Gibson error_setg(errp, "Maximum memory size 0x" RAM_ADDR_FMT 19417c150d6fSDavid Gibson " is not aligned to %llu MiB", 19427c150d6fSDavid Gibson machine->ram_size, 19437c150d6fSDavid Gibson SPAPR_MEMORY_BLOCK_SIZE / M_BYTE); 19447c150d6fSDavid Gibson return; 1945224245bfSDavid Gibson } 1946224245bfSDavid Gibson 1947224245bfSDavid Gibson for (i = 0; i < nb_numa_nodes; i++) { 1948224245bfSDavid Gibson if (numa_info[i].node_mem % SPAPR_MEMORY_BLOCK_SIZE) { 19497c150d6fSDavid Gibson error_setg(errp, 19507c150d6fSDavid Gibson "Node %d memory size 0x%" PRIx64 19517c150d6fSDavid Gibson " is not aligned to %llu MiB", 19527c150d6fSDavid Gibson i, numa_info[i].node_mem, 1953224245bfSDavid Gibson SPAPR_MEMORY_BLOCK_SIZE / M_BYTE); 19547c150d6fSDavid Gibson return; 1955224245bfSDavid Gibson } 1956224245bfSDavid Gibson } 1957224245bfSDavid Gibson } 1958224245bfSDavid Gibson 1959535455fdSIgor Mammedov /* find cpu slot in machine->possible_cpus by core_id */ 1960535455fdSIgor Mammedov static CPUArchId *spapr_find_cpu_slot(MachineState *ms, uint32_t id, int *idx) 1961535455fdSIgor Mammedov { 1962535455fdSIgor Mammedov int index = id / smp_threads; 1963535455fdSIgor Mammedov 1964535455fdSIgor Mammedov if (index >= ms->possible_cpus->len) { 1965535455fdSIgor Mammedov return NULL; 1966535455fdSIgor Mammedov } 1967535455fdSIgor Mammedov if (idx) { 1968535455fdSIgor Mammedov *idx = index; 1969535455fdSIgor Mammedov } 1970535455fdSIgor Mammedov return &ms->possible_cpus->cpus[index]; 1971535455fdSIgor Mammedov } 1972535455fdSIgor Mammedov 19730c86d0fdSDavid Gibson static void spapr_init_cpus(sPAPRMachineState *spapr) 19740c86d0fdSDavid Gibson { 19750c86d0fdSDavid Gibson MachineState *machine = MACHINE(spapr); 19760c86d0fdSDavid Gibson MachineClass *mc = MACHINE_GET_CLASS(machine); 19770c86d0fdSDavid Gibson char *type = spapr_get_cpu_core_type(machine->cpu_model); 19780c86d0fdSDavid Gibson int smt = kvmppc_smt_threads(); 1979535455fdSIgor Mammedov const CPUArchIdList *possible_cpus; 1980535455fdSIgor Mammedov int boot_cores_nr = smp_cpus / smp_threads; 19810c86d0fdSDavid Gibson int i; 19820c86d0fdSDavid Gibson 19830c86d0fdSDavid Gibson if (!type) { 19840c86d0fdSDavid Gibson error_report("Unable to find sPAPR CPU Core definition"); 19850c86d0fdSDavid Gibson exit(1); 19860c86d0fdSDavid Gibson } 19870c86d0fdSDavid Gibson 1988535455fdSIgor Mammedov possible_cpus = mc->possible_cpu_arch_ids(machine); 1989c5514d0eSIgor Mammedov if (mc->has_hotpluggable_cpus) { 19900c86d0fdSDavid Gibson if (smp_cpus % smp_threads) { 19910c86d0fdSDavid Gibson error_report("smp_cpus (%u) must be multiple of threads (%u)", 19920c86d0fdSDavid Gibson smp_cpus, smp_threads); 19930c86d0fdSDavid Gibson exit(1); 19940c86d0fdSDavid Gibson } 19950c86d0fdSDavid Gibson if (max_cpus % smp_threads) { 19960c86d0fdSDavid Gibson error_report("max_cpus (%u) must be multiple of threads (%u)", 19970c86d0fdSDavid Gibson max_cpus, smp_threads); 19980c86d0fdSDavid Gibson exit(1); 19990c86d0fdSDavid Gibson } 20000c86d0fdSDavid Gibson } else { 20010c86d0fdSDavid Gibson if (max_cpus != smp_cpus) { 20020c86d0fdSDavid Gibson error_report("This machine version does not support CPU hotplug"); 20030c86d0fdSDavid Gibson exit(1); 20040c86d0fdSDavid Gibson } 2005535455fdSIgor Mammedov boot_cores_nr = possible_cpus->len; 20060c86d0fdSDavid Gibson } 20070c86d0fdSDavid Gibson 2008535455fdSIgor Mammedov for (i = 0; i < possible_cpus->len; i++) { 20090c86d0fdSDavid Gibson int core_id = i * smp_threads; 20100c86d0fdSDavid Gibson 2011c5514d0eSIgor Mammedov if (mc->has_hotpluggable_cpus) { 20120c86d0fdSDavid Gibson sPAPRDRConnector *drc = 20130c86d0fdSDavid Gibson spapr_dr_connector_new(OBJECT(spapr), 20140c86d0fdSDavid Gibson SPAPR_DR_CONNECTOR_TYPE_CPU, 20150c86d0fdSDavid Gibson (core_id / smp_threads) * smt); 20160c86d0fdSDavid Gibson 20170c86d0fdSDavid Gibson qemu_register_reset(spapr_drc_reset, drc); 20180c86d0fdSDavid Gibson } 20190c86d0fdSDavid Gibson 2020535455fdSIgor Mammedov if (i < boot_cores_nr) { 20210c86d0fdSDavid Gibson Object *core = object_new(type); 20220c86d0fdSDavid Gibson int nr_threads = smp_threads; 20230c86d0fdSDavid Gibson 20240c86d0fdSDavid Gibson /* Handle the partially filled core for older machine types */ 20250c86d0fdSDavid Gibson if ((i + 1) * smp_threads >= smp_cpus) { 20260c86d0fdSDavid Gibson nr_threads = smp_cpus - i * smp_threads; 20270c86d0fdSDavid Gibson } 20280c86d0fdSDavid Gibson 20290c86d0fdSDavid Gibson object_property_set_int(core, nr_threads, "nr-threads", 20300c86d0fdSDavid Gibson &error_fatal); 20310c86d0fdSDavid Gibson object_property_set_int(core, core_id, CPU_CORE_PROP_CORE_ID, 20320c86d0fdSDavid Gibson &error_fatal); 20330c86d0fdSDavid Gibson object_property_set_bool(core, true, "realized", &error_fatal); 20340c86d0fdSDavid Gibson } 20350c86d0fdSDavid Gibson } 20360c86d0fdSDavid Gibson g_free(type); 20370c86d0fdSDavid Gibson } 20380c86d0fdSDavid Gibson 203953018216SPaolo Bonzini /* pSeries LPAR / sPAPR hardware init */ 20403ef96221SMarcel Apfelbaum static void ppc_spapr_init(MachineState *machine) 204153018216SPaolo Bonzini { 204228e02042SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(machine); 2043224245bfSDavid Gibson sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(machine); 20443ef96221SMarcel Apfelbaum const char *kernel_filename = machine->kernel_filename; 20453ef96221SMarcel Apfelbaum const char *initrd_filename = machine->initrd_filename; 204653018216SPaolo Bonzini PCIHostState *phb; 204753018216SPaolo Bonzini int i; 204853018216SPaolo Bonzini MemoryRegion *sysmem = get_system_memory(); 204953018216SPaolo Bonzini MemoryRegion *ram = g_new(MemoryRegion, 1); 2050658fa66bSAlexey Kardashevskiy MemoryRegion *rma_region; 2051658fa66bSAlexey Kardashevskiy void *rma = NULL; 205253018216SPaolo Bonzini hwaddr rma_alloc_size; 2053b082d65aSAlexey Kardashevskiy hwaddr node0_size = spapr_node0_size(); 2054b7d1f77aSBenjamin Herrenschmidt long load_limit, fw_size; 205553018216SPaolo Bonzini char *filename; 205653018216SPaolo Bonzini 2057226419d6SMichael S. Tsirkin msi_nonbroken = true; 205853018216SPaolo Bonzini 205953018216SPaolo Bonzini QLIST_INIT(&spapr->phbs); 20600cffce56SDavid Gibson QTAILQ_INIT(&spapr->pending_dimm_unplugs); 206153018216SPaolo Bonzini 206253018216SPaolo Bonzini /* Allocate RMA if necessary */ 2063658fa66bSAlexey Kardashevskiy rma_alloc_size = kvmppc_alloc_rma(&rma); 206453018216SPaolo Bonzini 206553018216SPaolo Bonzini if (rma_alloc_size == -1) { 2066730fce59SThomas Huth error_report("Unable to create RMA"); 206753018216SPaolo Bonzini exit(1); 206853018216SPaolo Bonzini } 206953018216SPaolo Bonzini 2070c4177479SAlexey Kardashevskiy if (rma_alloc_size && (rma_alloc_size < node0_size)) { 207153018216SPaolo Bonzini spapr->rma_size = rma_alloc_size; 207253018216SPaolo Bonzini } else { 2073c4177479SAlexey Kardashevskiy spapr->rma_size = node0_size; 207453018216SPaolo Bonzini 207553018216SPaolo Bonzini /* With KVM, we don't actually know whether KVM supports an 207653018216SPaolo Bonzini * unbounded RMA (PR KVM) or is limited by the hash table size 207753018216SPaolo Bonzini * (HV KVM using VRMA), so we always assume the latter 207853018216SPaolo Bonzini * 207953018216SPaolo Bonzini * In that case, we also limit the initial allocations for RTAS 208053018216SPaolo Bonzini * etc... to 256M since we have no way to know what the VRMA size 208153018216SPaolo Bonzini * is going to be as it depends on the size of the hash table 208253018216SPaolo Bonzini * isn't determined yet. 208353018216SPaolo Bonzini */ 208453018216SPaolo Bonzini if (kvm_enabled()) { 208553018216SPaolo Bonzini spapr->vrma_adjust = 1; 208653018216SPaolo Bonzini spapr->rma_size = MIN(spapr->rma_size, 0x10000000); 208753018216SPaolo Bonzini } 2088912acdf4SBenjamin Herrenschmidt 2089912acdf4SBenjamin Herrenschmidt /* Actually we don't support unbounded RMA anymore since we 2090912acdf4SBenjamin Herrenschmidt * added proper emulation of HV mode. The max we can get is 2091912acdf4SBenjamin Herrenschmidt * 16G which also happens to be what we configure for PAPR 2092912acdf4SBenjamin Herrenschmidt * mode so make sure we don't do anything bigger than that 2093912acdf4SBenjamin Herrenschmidt */ 2094912acdf4SBenjamin Herrenschmidt spapr->rma_size = MIN(spapr->rma_size, 0x400000000ull); 209553018216SPaolo Bonzini } 209653018216SPaolo Bonzini 2097c4177479SAlexey Kardashevskiy if (spapr->rma_size > node0_size) { 2098d54e4d76SDavid Gibson error_report("Numa node 0 has to span the RMA (%#08"HWADDR_PRIx")", 2099c4177479SAlexey Kardashevskiy spapr->rma_size); 2100c4177479SAlexey Kardashevskiy exit(1); 2101c4177479SAlexey Kardashevskiy } 2102c4177479SAlexey Kardashevskiy 2103b7d1f77aSBenjamin Herrenschmidt /* Setup a load limit for the ramdisk leaving room for SLOF and FDT */ 2104b7d1f77aSBenjamin Herrenschmidt load_limit = MIN(spapr->rma_size, RTAS_MAX_ADDR) - FW_OVERHEAD; 210553018216SPaolo Bonzini 21067b565160SDavid Gibson /* Set up Interrupt Controller before we create the VCPUs */ 210771cd4dacSCédric Le Goater xics_system_init(machine, XICS_IRQS_SPAPR, &error_fatal); 21087b565160SDavid Gibson 2109facdb8b6SMichael Roth /* Set up containers for ibm,client-set-architecture negotiated options */ 2110facdb8b6SMichael Roth spapr->ov5 = spapr_ovec_new(); 2111facdb8b6SMichael Roth spapr->ov5_cas = spapr_ovec_new(); 2112facdb8b6SMichael Roth 2113224245bfSDavid Gibson if (smc->dr_lmb_enabled) { 2114facdb8b6SMichael Roth spapr_ovec_set(spapr->ov5, OV5_DRCONF_MEMORY); 21157c150d6fSDavid Gibson spapr_validate_node_memory(machine, &error_fatal); 2116224245bfSDavid Gibson } 2117224245bfSDavid Gibson 2118417ece33SMichael Roth spapr_ovec_set(spapr->ov5, OV5_FORM1_AFFINITY); 2119545d6e2bSSuraj Jitindar Singh if (!kvm_enabled() || kvmppc_has_cap_mmu_radix()) { 2120545d6e2bSSuraj Jitindar Singh /* KVM and TCG always allow GTSE with radix... */ 21219fb4541fSSam Bobroff spapr_ovec_set(spapr->ov5, OV5_MMU_RADIX_GTSE); 21229fb4541fSSam Bobroff } 21239fb4541fSSam Bobroff /* ... but not with hash (currently). */ 2124417ece33SMichael Roth 2125ffbb1705SMichael Roth /* advertise support for dedicated HP event source to guests */ 2126ffbb1705SMichael Roth if (spapr->use_hotplug_event_source) { 2127ffbb1705SMichael Roth spapr_ovec_set(spapr->ov5, OV5_HP_EVT); 2128ffbb1705SMichael Roth } 2129ffbb1705SMichael Roth 213053018216SPaolo Bonzini /* init CPUs */ 213119fb2c36SBharata B Rao if (machine->cpu_model == NULL) { 21323daa4a9fSThomas Huth machine->cpu_model = kvm_enabled() ? "host" : smc->tcg_default_cpu; 213353018216SPaolo Bonzini } 213494a94e4cSBharata B Rao 2135e703d2f7SGreg Kurz ppc_cpu_parse_features(machine->cpu_model); 2136e703d2f7SGreg Kurz 21370c86d0fdSDavid Gibson spapr_init_cpus(spapr); 213853018216SPaolo Bonzini 2139026bfd89SDavid Gibson if (kvm_enabled()) { 2140026bfd89SDavid Gibson /* Enable H_LOGICAL_CI_* so SLOF can talk to in-kernel devices */ 2141026bfd89SDavid Gibson kvmppc_enable_logical_ci_hcalls(); 2142ef9971ddSAlexey Kardashevskiy kvmppc_enable_set_mode_hcall(); 21435145ad4fSNathan Whitehorn 21445145ad4fSNathan Whitehorn /* H_CLEAR_MOD/_REF are mandatory in PAPR, but off by default */ 21455145ad4fSNathan Whitehorn kvmppc_enable_clear_ref_mod_hcalls(); 2146026bfd89SDavid Gibson } 2147026bfd89SDavid Gibson 214853018216SPaolo Bonzini /* allocate RAM */ 2149f92f5da1SAlexey Kardashevskiy memory_region_allocate_system_memory(ram, NULL, "ppc_spapr.ram", 2150fb164994SDavid Gibson machine->ram_size); 2151f92f5da1SAlexey Kardashevskiy memory_region_add_subregion(sysmem, 0, ram); 215253018216SPaolo Bonzini 2153658fa66bSAlexey Kardashevskiy if (rma_alloc_size && rma) { 2154658fa66bSAlexey Kardashevskiy rma_region = g_new(MemoryRegion, 1); 2155658fa66bSAlexey Kardashevskiy memory_region_init_ram_ptr(rma_region, NULL, "ppc_spapr.rma", 2156658fa66bSAlexey Kardashevskiy rma_alloc_size, rma); 2157658fa66bSAlexey Kardashevskiy vmstate_register_ram_global(rma_region); 2158658fa66bSAlexey Kardashevskiy memory_region_add_subregion(sysmem, 0, rma_region); 2159658fa66bSAlexey Kardashevskiy } 2160658fa66bSAlexey Kardashevskiy 21614a1c9cf0SBharata B Rao /* initialize hotplug memory address space */ 21624a1c9cf0SBharata B Rao if (machine->ram_size < machine->maxram_size) { 21634a1c9cf0SBharata B Rao ram_addr_t hotplug_mem_size = machine->maxram_size - machine->ram_size; 216471c9a3ddSBharata B Rao /* 216571c9a3ddSBharata B Rao * Limit the number of hotpluggable memory slots to half the number 216671c9a3ddSBharata B Rao * slots that KVM supports, leaving the other half for PCI and other 216771c9a3ddSBharata B Rao * devices. However ensure that number of slots doesn't drop below 32. 216871c9a3ddSBharata B Rao */ 216971c9a3ddSBharata B Rao int max_memslots = kvm_enabled() ? kvm_get_max_memslots() / 2 : 217071c9a3ddSBharata B Rao SPAPR_MAX_RAM_SLOTS; 21714a1c9cf0SBharata B Rao 217271c9a3ddSBharata B Rao if (max_memslots < SPAPR_MAX_RAM_SLOTS) { 217371c9a3ddSBharata B Rao max_memslots = SPAPR_MAX_RAM_SLOTS; 217471c9a3ddSBharata B Rao } 217571c9a3ddSBharata B Rao if (machine->ram_slots > max_memslots) { 2176d54e4d76SDavid Gibson error_report("Specified number of memory slots %" 2177d54e4d76SDavid Gibson PRIu64" exceeds max supported %d", 217871c9a3ddSBharata B Rao machine->ram_slots, max_memslots); 2179d54e4d76SDavid Gibson exit(1); 21804a1c9cf0SBharata B Rao } 21814a1c9cf0SBharata B Rao 21824a1c9cf0SBharata B Rao spapr->hotplug_memory.base = ROUND_UP(machine->ram_size, 21834a1c9cf0SBharata B Rao SPAPR_HOTPLUG_MEM_ALIGN); 21844a1c9cf0SBharata B Rao memory_region_init(&spapr->hotplug_memory.mr, OBJECT(spapr), 21854a1c9cf0SBharata B Rao "hotplug-memory", hotplug_mem_size); 21864a1c9cf0SBharata B Rao memory_region_add_subregion(sysmem, spapr->hotplug_memory.base, 21874a1c9cf0SBharata B Rao &spapr->hotplug_memory.mr); 21884a1c9cf0SBharata B Rao } 21894a1c9cf0SBharata B Rao 2190224245bfSDavid Gibson if (smc->dr_lmb_enabled) { 2191224245bfSDavid Gibson spapr_create_lmb_dr_connectors(spapr); 2192224245bfSDavid Gibson } 2193224245bfSDavid Gibson 219453018216SPaolo Bonzini filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, "spapr-rtas.bin"); 21954c56440dSStefan Weil if (!filename) { 2196730fce59SThomas Huth error_report("Could not find LPAR rtas '%s'", "spapr-rtas.bin"); 21974c56440dSStefan Weil exit(1); 21984c56440dSStefan Weil } 2199b7d1f77aSBenjamin Herrenschmidt spapr->rtas_size = get_image_size(filename); 22008afc22a2SZhou Jie if (spapr->rtas_size < 0) { 22018afc22a2SZhou Jie error_report("Could not get size of LPAR rtas '%s'", filename); 22028afc22a2SZhou Jie exit(1); 22038afc22a2SZhou Jie } 2204b7d1f77aSBenjamin Herrenschmidt spapr->rtas_blob = g_malloc(spapr->rtas_size); 2205b7d1f77aSBenjamin Herrenschmidt if (load_image_size(filename, spapr->rtas_blob, spapr->rtas_size) < 0) { 2206730fce59SThomas Huth error_report("Could not load LPAR rtas '%s'", filename); 220753018216SPaolo Bonzini exit(1); 220853018216SPaolo Bonzini } 220953018216SPaolo Bonzini if (spapr->rtas_size > RTAS_MAX_SIZE) { 2210730fce59SThomas Huth error_report("RTAS too big ! 0x%zx bytes (max is 0x%x)", 22112f285bddSPeter Maydell (size_t)spapr->rtas_size, RTAS_MAX_SIZE); 221253018216SPaolo Bonzini exit(1); 221353018216SPaolo Bonzini } 221453018216SPaolo Bonzini g_free(filename); 221553018216SPaolo Bonzini 2216ffbb1705SMichael Roth /* Set up RTAS event infrastructure */ 221753018216SPaolo Bonzini spapr_events_init(spapr); 221853018216SPaolo Bonzini 221912f42174SDavid Gibson /* Set up the RTC RTAS interfaces */ 222028df36a1SDavid Gibson spapr_rtc_create(spapr); 222112f42174SDavid Gibson 222253018216SPaolo Bonzini /* Set up VIO bus */ 222353018216SPaolo Bonzini spapr->vio_bus = spapr_vio_bus_init(); 222453018216SPaolo Bonzini 222553018216SPaolo Bonzini for (i = 0; i < MAX_SERIAL_PORTS; i++) { 222653018216SPaolo Bonzini if (serial_hds[i]) { 222753018216SPaolo Bonzini spapr_vty_create(spapr->vio_bus, serial_hds[i]); 222853018216SPaolo Bonzini } 222953018216SPaolo Bonzini } 223053018216SPaolo Bonzini 223153018216SPaolo Bonzini /* We always have at least the nvram device on VIO */ 223253018216SPaolo Bonzini spapr_create_nvram(spapr); 223353018216SPaolo Bonzini 223453018216SPaolo Bonzini /* Set up PCI */ 223553018216SPaolo Bonzini spapr_pci_rtas_init(); 223653018216SPaolo Bonzini 223789dfd6e1SDavid Gibson phb = spapr_create_phb(spapr, 0); 223853018216SPaolo Bonzini 223953018216SPaolo Bonzini for (i = 0; i < nb_nics; i++) { 224053018216SPaolo Bonzini NICInfo *nd = &nd_table[i]; 224153018216SPaolo Bonzini 224253018216SPaolo Bonzini if (!nd->model) { 224353018216SPaolo Bonzini nd->model = g_strdup("ibmveth"); 224453018216SPaolo Bonzini } 224553018216SPaolo Bonzini 224653018216SPaolo Bonzini if (strcmp(nd->model, "ibmveth") == 0) { 224753018216SPaolo Bonzini spapr_vlan_create(spapr->vio_bus, nd); 224853018216SPaolo Bonzini } else { 224929b358f9SDavid Gibson pci_nic_init_nofail(&nd_table[i], phb->bus, nd->model, NULL); 225053018216SPaolo Bonzini } 225153018216SPaolo Bonzini } 225253018216SPaolo Bonzini 225353018216SPaolo Bonzini for (i = 0; i <= drive_get_max_bus(IF_SCSI); i++) { 225453018216SPaolo Bonzini spapr_vscsi_create(spapr->vio_bus); 225553018216SPaolo Bonzini } 225653018216SPaolo Bonzini 225753018216SPaolo Bonzini /* Graphics */ 225814c6a894SDavid Gibson if (spapr_vga_init(phb->bus, &error_fatal)) { 225953018216SPaolo Bonzini spapr->has_graphics = true; 2260c6e76503SPaolo Bonzini machine->usb |= defaults_enabled() && !machine->usb_disabled; 226153018216SPaolo Bonzini } 226253018216SPaolo Bonzini 22634ee9ced9SMarcel Apfelbaum if (machine->usb) { 226457040d45SThomas Huth if (smc->use_ohci_by_default) { 226553018216SPaolo Bonzini pci_create_simple(phb->bus, -1, "pci-ohci"); 226657040d45SThomas Huth } else { 226757040d45SThomas Huth pci_create_simple(phb->bus, -1, "nec-usb-xhci"); 226857040d45SThomas Huth } 2269c86580b8SMarkus Armbruster 227053018216SPaolo Bonzini if (spapr->has_graphics) { 2271c86580b8SMarkus Armbruster USBBus *usb_bus = usb_bus_find(-1); 2272c86580b8SMarkus Armbruster 2273c86580b8SMarkus Armbruster usb_create_simple(usb_bus, "usb-kbd"); 2274c86580b8SMarkus Armbruster usb_create_simple(usb_bus, "usb-mouse"); 227553018216SPaolo Bonzini } 227653018216SPaolo Bonzini } 227753018216SPaolo Bonzini 227853018216SPaolo Bonzini if (spapr->rma_size < (MIN_RMA_SLOF << 20)) { 2279d54e4d76SDavid Gibson error_report( 2280d54e4d76SDavid Gibson "pSeries SLOF firmware requires >= %ldM guest RMA (Real Mode Area memory)", 2281d54e4d76SDavid Gibson MIN_RMA_SLOF); 228253018216SPaolo Bonzini exit(1); 228353018216SPaolo Bonzini } 228453018216SPaolo Bonzini 228553018216SPaolo Bonzini if (kernel_filename) { 228653018216SPaolo Bonzini uint64_t lowaddr = 0; 228753018216SPaolo Bonzini 2288a19f7fb0SDavid Gibson spapr->kernel_size = load_elf(kernel_filename, translate_kernel_address, 2289a19f7fb0SDavid Gibson NULL, NULL, &lowaddr, NULL, 1, 2290a19f7fb0SDavid Gibson PPC_ELF_MACHINE, 0, 0); 2291a19f7fb0SDavid Gibson if (spapr->kernel_size == ELF_LOAD_WRONG_ENDIAN) { 2292a19f7fb0SDavid Gibson spapr->kernel_size = load_elf(kernel_filename, 2293a19f7fb0SDavid Gibson translate_kernel_address, NULL, NULL, 2294a19f7fb0SDavid Gibson &lowaddr, NULL, 0, PPC_ELF_MACHINE, 22957ef295eaSPeter Crosthwaite 0, 0); 2296a19f7fb0SDavid Gibson spapr->kernel_le = spapr->kernel_size > 0; 229716457e7fSBenjamin Herrenschmidt } 2298a19f7fb0SDavid Gibson if (spapr->kernel_size < 0) { 2299a19f7fb0SDavid Gibson error_report("error loading %s: %s", kernel_filename, 2300a19f7fb0SDavid Gibson load_elf_strerror(spapr->kernel_size)); 230153018216SPaolo Bonzini exit(1); 230253018216SPaolo Bonzini } 230353018216SPaolo Bonzini 230453018216SPaolo Bonzini /* load initrd */ 230553018216SPaolo Bonzini if (initrd_filename) { 230653018216SPaolo Bonzini /* Try to locate the initrd in the gap between the kernel 230753018216SPaolo Bonzini * and the firmware. Add a bit of space just in case 230853018216SPaolo Bonzini */ 2309a19f7fb0SDavid Gibson spapr->initrd_base = (KERNEL_LOAD_ADDR + spapr->kernel_size 2310a19f7fb0SDavid Gibson + 0x1ffff) & ~0xffff; 2311a19f7fb0SDavid Gibson spapr->initrd_size = load_image_targphys(initrd_filename, 2312a19f7fb0SDavid Gibson spapr->initrd_base, 2313a19f7fb0SDavid Gibson load_limit 2314a19f7fb0SDavid Gibson - spapr->initrd_base); 2315a19f7fb0SDavid Gibson if (spapr->initrd_size < 0) { 2316d54e4d76SDavid Gibson error_report("could not load initial ram disk '%s'", 231753018216SPaolo Bonzini initrd_filename); 231853018216SPaolo Bonzini exit(1); 231953018216SPaolo Bonzini } 232053018216SPaolo Bonzini } 232153018216SPaolo Bonzini } 232253018216SPaolo Bonzini 23238e7ea787SAndreas Färber if (bios_name == NULL) { 23248e7ea787SAndreas Färber bios_name = FW_FILE_NAME; 23258e7ea787SAndreas Färber } 23268e7ea787SAndreas Färber filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name); 23274c56440dSStefan Weil if (!filename) { 232868fea5a0SThomas Huth error_report("Could not find LPAR firmware '%s'", bios_name); 23294c56440dSStefan Weil exit(1); 23304c56440dSStefan Weil } 233153018216SPaolo Bonzini fw_size = load_image_targphys(filename, 0, FW_MAX_SIZE); 233268fea5a0SThomas Huth if (fw_size <= 0) { 233368fea5a0SThomas Huth error_report("Could not load LPAR firmware '%s'", filename); 233453018216SPaolo Bonzini exit(1); 233553018216SPaolo Bonzini } 233653018216SPaolo Bonzini g_free(filename); 233753018216SPaolo Bonzini 233828e02042SDavid Gibson /* FIXME: Should register things through the MachineState's qdev 233928e02042SDavid Gibson * interface, this is a legacy from the sPAPREnvironment structure 234028e02042SDavid Gibson * which predated MachineState but had a similar function */ 23414be21d56SDavid Gibson vmstate_register(NULL, 0, &vmstate_spapr, spapr); 23424be21d56SDavid Gibson register_savevm_live(NULL, "spapr/htab", -1, 1, 23434be21d56SDavid Gibson &savevm_htab_handlers, spapr); 23444be21d56SDavid Gibson 234546503c2bSMichael Roth /* used by RTAS */ 234646503c2bSMichael Roth QTAILQ_INIT(&spapr->ccs_list); 234746503c2bSMichael Roth qemu_register_reset(spapr_ccs_reset_hook, spapr); 234846503c2bSMichael Roth 23495b2128d2SAlexander Graf qemu_register_boot_set(spapr_boot_set, spapr); 235042043e4fSLaurent Vivier 235142043e4fSLaurent Vivier if (kvm_enabled()) { 23523dc410aeSAlexey Kardashevskiy /* to stop and start vmclock */ 235342043e4fSLaurent Vivier qemu_add_vm_change_state_handler(cpu_ppc_clock_vm_state_change, 235442043e4fSLaurent Vivier &spapr->tb); 23553dc410aeSAlexey Kardashevskiy 23563dc410aeSAlexey Kardashevskiy kvmppc_spapr_enable_inkernel_multitce(); 235742043e4fSLaurent Vivier } 235853018216SPaolo Bonzini } 235953018216SPaolo Bonzini 2360135a129aSAneesh Kumar K.V static int spapr_kvm_type(const char *vm_type) 2361135a129aSAneesh Kumar K.V { 2362135a129aSAneesh Kumar K.V if (!vm_type) { 2363135a129aSAneesh Kumar K.V return 0; 2364135a129aSAneesh Kumar K.V } 2365135a129aSAneesh Kumar K.V 2366135a129aSAneesh Kumar K.V if (!strcmp(vm_type, "HV")) { 2367135a129aSAneesh Kumar K.V return 1; 2368135a129aSAneesh Kumar K.V } 2369135a129aSAneesh Kumar K.V 2370135a129aSAneesh Kumar K.V if (!strcmp(vm_type, "PR")) { 2371135a129aSAneesh Kumar K.V return 2; 2372135a129aSAneesh Kumar K.V } 2373135a129aSAneesh Kumar K.V 2374135a129aSAneesh Kumar K.V error_report("Unknown kvm-type specified '%s'", vm_type); 2375135a129aSAneesh Kumar K.V exit(1); 2376135a129aSAneesh Kumar K.V } 2377135a129aSAneesh Kumar K.V 237871461b0fSAlexey Kardashevskiy /* 2379627b84f4SGonglei * Implementation of an interface to adjust firmware path 238071461b0fSAlexey Kardashevskiy * for the bootindex property handling. 238171461b0fSAlexey Kardashevskiy */ 238271461b0fSAlexey Kardashevskiy static char *spapr_get_fw_dev_path(FWPathProvider *p, BusState *bus, 238371461b0fSAlexey Kardashevskiy DeviceState *dev) 238471461b0fSAlexey Kardashevskiy { 238571461b0fSAlexey Kardashevskiy #define CAST(type, obj, name) \ 238671461b0fSAlexey Kardashevskiy ((type *)object_dynamic_cast(OBJECT(obj), (name))) 238771461b0fSAlexey Kardashevskiy SCSIDevice *d = CAST(SCSIDevice, dev, TYPE_SCSI_DEVICE); 238871461b0fSAlexey Kardashevskiy sPAPRPHBState *phb = CAST(sPAPRPHBState, dev, TYPE_SPAPR_PCI_HOST_BRIDGE); 238971461b0fSAlexey Kardashevskiy 239071461b0fSAlexey Kardashevskiy if (d) { 239171461b0fSAlexey Kardashevskiy void *spapr = CAST(void, bus->parent, "spapr-vscsi"); 239271461b0fSAlexey Kardashevskiy VirtIOSCSI *virtio = CAST(VirtIOSCSI, bus->parent, TYPE_VIRTIO_SCSI); 239371461b0fSAlexey Kardashevskiy USBDevice *usb = CAST(USBDevice, bus->parent, TYPE_USB_DEVICE); 239471461b0fSAlexey Kardashevskiy 239571461b0fSAlexey Kardashevskiy if (spapr) { 239671461b0fSAlexey Kardashevskiy /* 239771461b0fSAlexey Kardashevskiy * Replace "channel@0/disk@0,0" with "disk@8000000000000000": 239871461b0fSAlexey Kardashevskiy * We use SRP luns of the form 8000 | (bus << 8) | (id << 5) | lun 239971461b0fSAlexey Kardashevskiy * in the top 16 bits of the 64-bit LUN 240071461b0fSAlexey Kardashevskiy */ 240171461b0fSAlexey Kardashevskiy unsigned id = 0x8000 | (d->id << 8) | d->lun; 240271461b0fSAlexey Kardashevskiy return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev), 240371461b0fSAlexey Kardashevskiy (uint64_t)id << 48); 240471461b0fSAlexey Kardashevskiy } else if (virtio) { 240571461b0fSAlexey Kardashevskiy /* 240671461b0fSAlexey Kardashevskiy * We use SRP luns of the form 01000000 | (target << 8) | lun 240771461b0fSAlexey Kardashevskiy * in the top 32 bits of the 64-bit LUN 240871461b0fSAlexey Kardashevskiy * Note: the quote above is from SLOF and it is wrong, 240971461b0fSAlexey Kardashevskiy * the actual binding is: 241071461b0fSAlexey Kardashevskiy * swap 0100 or 10 << or 20 << ( target lun-id -- srplun ) 241171461b0fSAlexey Kardashevskiy */ 241271461b0fSAlexey Kardashevskiy unsigned id = 0x1000000 | (d->id << 16) | d->lun; 241371461b0fSAlexey Kardashevskiy return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev), 241471461b0fSAlexey Kardashevskiy (uint64_t)id << 32); 241571461b0fSAlexey Kardashevskiy } else if (usb) { 241671461b0fSAlexey Kardashevskiy /* 241771461b0fSAlexey Kardashevskiy * We use SRP luns of the form 01000000 | (usb-port << 16) | lun 241871461b0fSAlexey Kardashevskiy * in the top 32 bits of the 64-bit LUN 241971461b0fSAlexey Kardashevskiy */ 242071461b0fSAlexey Kardashevskiy unsigned usb_port = atoi(usb->port->path); 242171461b0fSAlexey Kardashevskiy unsigned id = 0x1000000 | (usb_port << 16) | d->lun; 242271461b0fSAlexey Kardashevskiy return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev), 242371461b0fSAlexey Kardashevskiy (uint64_t)id << 32); 242471461b0fSAlexey Kardashevskiy } 242571461b0fSAlexey Kardashevskiy } 242671461b0fSAlexey Kardashevskiy 2427b99260ebSThomas Huth /* 2428b99260ebSThomas Huth * SLOF probes the USB devices, and if it recognizes that the device is a 2429b99260ebSThomas Huth * storage device, it changes its name to "storage" instead of "usb-host", 2430b99260ebSThomas Huth * and additionally adds a child node for the SCSI LUN, so the correct 2431b99260ebSThomas Huth * boot path in SLOF is something like .../storage@1/disk@xxx" instead. 2432b99260ebSThomas Huth */ 2433b99260ebSThomas Huth if (strcmp("usb-host", qdev_fw_name(dev)) == 0) { 2434b99260ebSThomas Huth USBDevice *usbdev = CAST(USBDevice, dev, TYPE_USB_DEVICE); 2435b99260ebSThomas Huth if (usb_host_dev_is_scsi_storage(usbdev)) { 2436b99260ebSThomas Huth return g_strdup_printf("storage@%s/disk", usbdev->port->path); 2437b99260ebSThomas Huth } 2438b99260ebSThomas Huth } 2439b99260ebSThomas Huth 244071461b0fSAlexey Kardashevskiy if (phb) { 244171461b0fSAlexey Kardashevskiy /* Replace "pci" with "pci@800000020000000" */ 244271461b0fSAlexey Kardashevskiy return g_strdup_printf("pci@%"PRIX64, phb->buid); 244371461b0fSAlexey Kardashevskiy } 244471461b0fSAlexey Kardashevskiy 244571461b0fSAlexey Kardashevskiy return NULL; 244671461b0fSAlexey Kardashevskiy } 244771461b0fSAlexey Kardashevskiy 244823825581SEduardo Habkost static char *spapr_get_kvm_type(Object *obj, Error **errp) 244923825581SEduardo Habkost { 245028e02042SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 245123825581SEduardo Habkost 245228e02042SDavid Gibson return g_strdup(spapr->kvm_type); 245323825581SEduardo Habkost } 245423825581SEduardo Habkost 245523825581SEduardo Habkost static void spapr_set_kvm_type(Object *obj, const char *value, Error **errp) 245623825581SEduardo Habkost { 245728e02042SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 245823825581SEduardo Habkost 245928e02042SDavid Gibson g_free(spapr->kvm_type); 246028e02042SDavid Gibson spapr->kvm_type = g_strdup(value); 246123825581SEduardo Habkost } 246223825581SEduardo Habkost 2463f6229214SMichael Roth static bool spapr_get_modern_hotplug_events(Object *obj, Error **errp) 2464f6229214SMichael Roth { 2465f6229214SMichael Roth sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 2466f6229214SMichael Roth 2467f6229214SMichael Roth return spapr->use_hotplug_event_source; 2468f6229214SMichael Roth } 2469f6229214SMichael Roth 2470f6229214SMichael Roth static void spapr_set_modern_hotplug_events(Object *obj, bool value, 2471f6229214SMichael Roth Error **errp) 2472f6229214SMichael Roth { 2473f6229214SMichael Roth sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 2474f6229214SMichael Roth 2475f6229214SMichael Roth spapr->use_hotplug_event_source = value; 2476f6229214SMichael Roth } 2477f6229214SMichael Roth 247823825581SEduardo Habkost static void spapr_machine_initfn(Object *obj) 247923825581SEduardo Habkost { 2480715c5407SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 2481715c5407SDavid Gibson 2482715c5407SDavid Gibson spapr->htab_fd = -1; 2483f6229214SMichael Roth spapr->use_hotplug_event_source = true; 248423825581SEduardo Habkost object_property_add_str(obj, "kvm-type", 248523825581SEduardo Habkost spapr_get_kvm_type, spapr_set_kvm_type, NULL); 248649d2e648SMarcel Apfelbaum object_property_set_description(obj, "kvm-type", 248749d2e648SMarcel Apfelbaum "Specifies the KVM virtualization mode (HV, PR)", 248849d2e648SMarcel Apfelbaum NULL); 2489f6229214SMichael Roth object_property_add_bool(obj, "modern-hotplug-events", 2490f6229214SMichael Roth spapr_get_modern_hotplug_events, 2491f6229214SMichael Roth spapr_set_modern_hotplug_events, 2492f6229214SMichael Roth NULL); 2493f6229214SMichael Roth object_property_set_description(obj, "modern-hotplug-events", 2494f6229214SMichael Roth "Use dedicated hotplug event mechanism in" 2495f6229214SMichael Roth " place of standard EPOW events when possible" 2496f6229214SMichael Roth " (required for memory hot-unplug support)", 2497f6229214SMichael Roth NULL); 249823825581SEduardo Habkost } 249923825581SEduardo Habkost 250087bbdd9cSDavid Gibson static void spapr_machine_finalizefn(Object *obj) 250187bbdd9cSDavid Gibson { 250287bbdd9cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 250387bbdd9cSDavid Gibson 250487bbdd9cSDavid Gibson g_free(spapr->kvm_type); 250587bbdd9cSDavid Gibson } 250687bbdd9cSDavid Gibson 25071c7ad77eSNicholas Piggin void spapr_do_system_reset_on_cpu(CPUState *cs, run_on_cpu_data arg) 250834316482SAlexey Kardashevskiy { 250934316482SAlexey Kardashevskiy cpu_synchronize_state(cs); 251034316482SAlexey Kardashevskiy ppc_cpu_do_system_reset(cs); 251134316482SAlexey Kardashevskiy } 251234316482SAlexey Kardashevskiy 251334316482SAlexey Kardashevskiy static void spapr_nmi(NMIState *n, int cpu_index, Error **errp) 251434316482SAlexey Kardashevskiy { 251534316482SAlexey Kardashevskiy CPUState *cs; 251634316482SAlexey Kardashevskiy 251734316482SAlexey Kardashevskiy CPU_FOREACH(cs) { 25181c7ad77eSNicholas Piggin async_run_on_cpu(cs, spapr_do_system_reset_on_cpu, RUN_ON_CPU_NULL); 251934316482SAlexey Kardashevskiy } 252034316482SAlexey Kardashevskiy } 252134316482SAlexey Kardashevskiy 252279b78a6bSMichael Roth static void spapr_add_lmbs(DeviceState *dev, uint64_t addr_start, uint64_t size, 252379b78a6bSMichael Roth uint32_t node, bool dedicated_hp_event_source, 252479b78a6bSMichael Roth Error **errp) 2525c20d332aSBharata B Rao { 2526c20d332aSBharata B Rao sPAPRDRConnector *drc; 2527c20d332aSBharata B Rao sPAPRDRConnectorClass *drck; 2528c20d332aSBharata B Rao uint32_t nr_lmbs = size/SPAPR_MEMORY_BLOCK_SIZE; 2529c20d332aSBharata B Rao int i, fdt_offset, fdt_size; 2530c20d332aSBharata B Rao void *fdt; 253179b78a6bSMichael Roth uint64_t addr = addr_start; 2532c20d332aSBharata B Rao 2533c20d332aSBharata B Rao for (i = 0; i < nr_lmbs; i++) { 2534c20d332aSBharata B Rao drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_LMB, 2535c20d332aSBharata B Rao addr/SPAPR_MEMORY_BLOCK_SIZE); 2536c20d332aSBharata B Rao g_assert(drc); 2537c20d332aSBharata B Rao 2538c20d332aSBharata B Rao fdt = create_device_tree(&fdt_size); 2539c20d332aSBharata B Rao fdt_offset = spapr_populate_memory_node(fdt, node, addr, 2540c20d332aSBharata B Rao SPAPR_MEMORY_BLOCK_SIZE); 2541c20d332aSBharata B Rao 2542c20d332aSBharata B Rao drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 2543c20d332aSBharata B Rao drck->attach(drc, dev, fdt, fdt_offset, !dev->hotplugged, errp); 2544c20d332aSBharata B Rao addr += SPAPR_MEMORY_BLOCK_SIZE; 25455c0139a8SMichael Roth if (!dev->hotplugged) { 25465c0139a8SMichael Roth /* guests expect coldplugged LMBs to be pre-allocated */ 25475c0139a8SMichael Roth drck->set_allocation_state(drc, SPAPR_DR_ALLOCATION_STATE_USABLE); 25485c0139a8SMichael Roth drck->set_isolation_state(drc, SPAPR_DR_ISOLATION_STATE_UNISOLATED); 25495c0139a8SMichael Roth } 2550c20d332aSBharata B Rao } 25515dd5238cSJianjun Duan /* send hotplug notification to the 25525dd5238cSJianjun Duan * guest only in case of hotplugged memory 25535dd5238cSJianjun Duan */ 25545dd5238cSJianjun Duan if (dev->hotplugged) { 255579b78a6bSMichael Roth if (dedicated_hp_event_source) { 255679b78a6bSMichael Roth drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_LMB, 255779b78a6bSMichael Roth addr_start / SPAPR_MEMORY_BLOCK_SIZE); 255879b78a6bSMichael Roth drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 255979b78a6bSMichael Roth spapr_hotplug_req_add_by_count_indexed(SPAPR_DR_CONNECTOR_TYPE_LMB, 256079b78a6bSMichael Roth nr_lmbs, 256179b78a6bSMichael Roth drck->get_index(drc)); 256279b78a6bSMichael Roth } else { 256379b78a6bSMichael Roth spapr_hotplug_req_add_by_count(SPAPR_DR_CONNECTOR_TYPE_LMB, 256479b78a6bSMichael Roth nr_lmbs); 256579b78a6bSMichael Roth } 2566c20d332aSBharata B Rao } 25675dd5238cSJianjun Duan } 2568c20d332aSBharata B Rao 2569c20d332aSBharata B Rao static void spapr_memory_plug(HotplugHandler *hotplug_dev, DeviceState *dev, 2570c20d332aSBharata B Rao uint32_t node, Error **errp) 2571c20d332aSBharata B Rao { 2572c20d332aSBharata B Rao Error *local_err = NULL; 2573c20d332aSBharata B Rao sPAPRMachineState *ms = SPAPR_MACHINE(hotplug_dev); 2574c20d332aSBharata B Rao PCDIMMDevice *dimm = PC_DIMM(dev); 2575c20d332aSBharata B Rao PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); 2576c20d332aSBharata B Rao MemoryRegion *mr = ddc->get_memory_region(dimm); 2577c20d332aSBharata B Rao uint64_t align = memory_region_get_alignment(mr); 2578c20d332aSBharata B Rao uint64_t size = memory_region_size(mr); 2579c20d332aSBharata B Rao uint64_t addr; 2580df587133SThomas Huth 2581d6a9b0b8SMichael S. Tsirkin pc_dimm_memory_plug(dev, &ms->hotplug_memory, mr, align, &local_err); 2582c20d332aSBharata B Rao if (local_err) { 2583c20d332aSBharata B Rao goto out; 2584c20d332aSBharata B Rao } 2585c20d332aSBharata B Rao 2586c20d332aSBharata B Rao addr = object_property_get_int(OBJECT(dimm), PC_DIMM_ADDR_PROP, &local_err); 2587c20d332aSBharata B Rao if (local_err) { 2588c20d332aSBharata B Rao pc_dimm_memory_unplug(dev, &ms->hotplug_memory, mr); 2589c20d332aSBharata B Rao goto out; 2590c20d332aSBharata B Rao } 2591c20d332aSBharata B Rao 259279b78a6bSMichael Roth spapr_add_lmbs(dev, addr, size, node, 259379b78a6bSMichael Roth spapr_ovec_test(ms->ov5_cas, OV5_HP_EVT), 259479b78a6bSMichael Roth &error_abort); 2595c20d332aSBharata B Rao 2596c20d332aSBharata B Rao out: 2597c20d332aSBharata B Rao error_propagate(errp, local_err); 2598c20d332aSBharata B Rao } 2599c20d332aSBharata B Rao 2600c871bc70SLaurent Vivier static void spapr_memory_pre_plug(HotplugHandler *hotplug_dev, DeviceState *dev, 2601c871bc70SLaurent Vivier Error **errp) 2602c871bc70SLaurent Vivier { 2603c871bc70SLaurent Vivier PCDIMMDevice *dimm = PC_DIMM(dev); 2604c871bc70SLaurent Vivier PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); 2605c871bc70SLaurent Vivier MemoryRegion *mr = ddc->get_memory_region(dimm); 2606c871bc70SLaurent Vivier uint64_t size = memory_region_size(mr); 2607c871bc70SLaurent Vivier char *mem_dev; 2608c871bc70SLaurent Vivier 2609c871bc70SLaurent Vivier if (size % SPAPR_MEMORY_BLOCK_SIZE) { 2610c871bc70SLaurent Vivier error_setg(errp, "Hotplugged memory size must be a multiple of " 2611c871bc70SLaurent Vivier "%lld MB", SPAPR_MEMORY_BLOCK_SIZE / M_BYTE); 2612c871bc70SLaurent Vivier return; 2613c871bc70SLaurent Vivier } 2614c871bc70SLaurent Vivier 2615c871bc70SLaurent Vivier mem_dev = object_property_get_str(OBJECT(dimm), PC_DIMM_MEMDEV_PROP, NULL); 2616c871bc70SLaurent Vivier if (mem_dev && !kvmppc_is_mem_backend_page_size_ok(mem_dev)) { 2617c871bc70SLaurent Vivier error_setg(errp, "Memory backend has bad page size. " 2618c871bc70SLaurent Vivier "Use 'memory-backend-file' with correct mem-path."); 2619c871bc70SLaurent Vivier return; 2620c871bc70SLaurent Vivier } 2621c871bc70SLaurent Vivier } 2622c871bc70SLaurent Vivier 26230cffce56SDavid Gibson struct sPAPRDIMMState { 26240cffce56SDavid Gibson PCDIMMDevice *dimm; 2625cf632463SBharata B Rao uint32_t nr_lmbs; 26260cffce56SDavid Gibson QTAILQ_ENTRY(sPAPRDIMMState) next; 26270cffce56SDavid Gibson }; 26280cffce56SDavid Gibson 26290cffce56SDavid Gibson static sPAPRDIMMState *spapr_pending_dimm_unplugs_find(sPAPRMachineState *s, 26300cffce56SDavid Gibson PCDIMMDevice *dimm) 26310cffce56SDavid Gibson { 26320cffce56SDavid Gibson sPAPRDIMMState *dimm_state = NULL; 26330cffce56SDavid Gibson 26340cffce56SDavid Gibson QTAILQ_FOREACH(dimm_state, &s->pending_dimm_unplugs, next) { 26350cffce56SDavid Gibson if (dimm_state->dimm == dimm) { 26360cffce56SDavid Gibson break; 26370cffce56SDavid Gibson } 26380cffce56SDavid Gibson } 26390cffce56SDavid Gibson return dimm_state; 26400cffce56SDavid Gibson } 26410cffce56SDavid Gibson 26420cffce56SDavid Gibson static void spapr_pending_dimm_unplugs_add(sPAPRMachineState *spapr, 26430cffce56SDavid Gibson sPAPRDIMMState *dimm_state) 26440cffce56SDavid Gibson { 26450cffce56SDavid Gibson g_assert(!spapr_pending_dimm_unplugs_find(spapr, dimm_state->dimm)); 26460cffce56SDavid Gibson QTAILQ_INSERT_HEAD(&spapr->pending_dimm_unplugs, dimm_state, next); 26470cffce56SDavid Gibson } 26480cffce56SDavid Gibson 26490cffce56SDavid Gibson static void spapr_pending_dimm_unplugs_remove(sPAPRMachineState *spapr, 26500cffce56SDavid Gibson sPAPRDIMMState *dimm_state) 26510cffce56SDavid Gibson { 26520cffce56SDavid Gibson QTAILQ_REMOVE(&spapr->pending_dimm_unplugs, dimm_state, next); 26530cffce56SDavid Gibson g_free(dimm_state); 26540cffce56SDavid Gibson } 2655cf632463SBharata B Rao 265616ee9980SDaniel Henrique Barboza static sPAPRDIMMState *spapr_recover_pending_dimm_state(sPAPRMachineState *ms, 265716ee9980SDaniel Henrique Barboza PCDIMMDevice *dimm) 265816ee9980SDaniel Henrique Barboza { 265916ee9980SDaniel Henrique Barboza sPAPRDRConnector *drc; 266016ee9980SDaniel Henrique Barboza PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); 266116ee9980SDaniel Henrique Barboza MemoryRegion *mr = ddc->get_memory_region(dimm); 266216ee9980SDaniel Henrique Barboza uint64_t size = memory_region_size(mr); 266316ee9980SDaniel Henrique Barboza uint32_t nr_lmbs = size / SPAPR_MEMORY_BLOCK_SIZE; 266416ee9980SDaniel Henrique Barboza uint32_t avail_lmbs = 0; 266516ee9980SDaniel Henrique Barboza uint64_t addr_start, addr; 266616ee9980SDaniel Henrique Barboza int i; 266716ee9980SDaniel Henrique Barboza sPAPRDIMMState *ds; 266816ee9980SDaniel Henrique Barboza 266916ee9980SDaniel Henrique Barboza addr_start = object_property_get_int(OBJECT(dimm), PC_DIMM_ADDR_PROP, 267016ee9980SDaniel Henrique Barboza &error_abort); 267116ee9980SDaniel Henrique Barboza 267216ee9980SDaniel Henrique Barboza addr = addr_start; 267316ee9980SDaniel Henrique Barboza for (i = 0; i < nr_lmbs; i++) { 267416ee9980SDaniel Henrique Barboza drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_LMB, 267516ee9980SDaniel Henrique Barboza addr / SPAPR_MEMORY_BLOCK_SIZE); 267616ee9980SDaniel Henrique Barboza g_assert(drc); 267716ee9980SDaniel Henrique Barboza if (drc->indicator_state != SPAPR_DR_INDICATOR_STATE_INACTIVE) { 267816ee9980SDaniel Henrique Barboza avail_lmbs++; 267916ee9980SDaniel Henrique Barboza } 268016ee9980SDaniel Henrique Barboza addr += SPAPR_MEMORY_BLOCK_SIZE; 268116ee9980SDaniel Henrique Barboza } 268216ee9980SDaniel Henrique Barboza 268316ee9980SDaniel Henrique Barboza ds = g_malloc0(sizeof(sPAPRDIMMState)); 268416ee9980SDaniel Henrique Barboza ds->nr_lmbs = avail_lmbs; 268516ee9980SDaniel Henrique Barboza ds->dimm = dimm; 268616ee9980SDaniel Henrique Barboza spapr_pending_dimm_unplugs_add(ms, ds); 268716ee9980SDaniel Henrique Barboza return ds; 268816ee9980SDaniel Henrique Barboza } 268916ee9980SDaniel Henrique Barboza 269031834723SDaniel Henrique Barboza /* Callback to be called during DRC release. */ 269131834723SDaniel Henrique Barboza void spapr_lmb_release(DeviceState *dev) 2692cf632463SBharata B Rao { 26930cffce56SDavid Gibson HotplugHandler *hotplug_ctrl = qdev_get_hotplug_handler(dev); 26940cffce56SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(hotplug_ctrl); 26950cffce56SDavid Gibson sPAPRDIMMState *ds = spapr_pending_dimm_unplugs_find(spapr, PC_DIMM(dev)); 2696cf632463SBharata B Rao 269716ee9980SDaniel Henrique Barboza /* This information will get lost if a migration occurs 269816ee9980SDaniel Henrique Barboza * during the unplug process. In this case recover it. */ 269916ee9980SDaniel Henrique Barboza if (ds == NULL) { 270016ee9980SDaniel Henrique Barboza ds = spapr_recover_pending_dimm_state(spapr, PC_DIMM(dev)); 270116ee9980SDaniel Henrique Barboza if (ds->nr_lmbs) { 270216ee9980SDaniel Henrique Barboza return; 270316ee9980SDaniel Henrique Barboza } 270416ee9980SDaniel Henrique Barboza } else if (--ds->nr_lmbs) { 2705cf632463SBharata B Rao return; 2706cf632463SBharata B Rao } 2707cf632463SBharata B Rao 27080cffce56SDavid Gibson spapr_pending_dimm_unplugs_remove(spapr, ds); 2709cf632463SBharata B Rao 2710cf632463SBharata B Rao /* 2711cf632463SBharata B Rao * Now that all the LMBs have been removed by the guest, call the 2712cf632463SBharata B Rao * pc-dimm unplug handler to cleanup up the pc-dimm device. 2713cf632463SBharata B Rao */ 2714cf632463SBharata B Rao hotplug_handler_unplug(hotplug_ctrl, dev, &error_abort); 2715cf632463SBharata B Rao } 2716cf632463SBharata B Rao 2717cf632463SBharata B Rao static void spapr_memory_unplug(HotplugHandler *hotplug_dev, DeviceState *dev, 2718cf632463SBharata B Rao Error **errp) 2719cf632463SBharata B Rao { 2720cf632463SBharata B Rao sPAPRMachineState *ms = SPAPR_MACHINE(hotplug_dev); 2721cf632463SBharata B Rao PCDIMMDevice *dimm = PC_DIMM(dev); 2722cf632463SBharata B Rao PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); 2723cf632463SBharata B Rao MemoryRegion *mr = ddc->get_memory_region(dimm); 2724cf632463SBharata B Rao 2725cf632463SBharata B Rao pc_dimm_memory_unplug(dev, &ms->hotplug_memory, mr); 2726cf632463SBharata B Rao object_unparent(OBJECT(dev)); 2727cf632463SBharata B Rao } 2728cf632463SBharata B Rao 2729cf632463SBharata B Rao static void spapr_memory_unplug_request(HotplugHandler *hotplug_dev, 2730cf632463SBharata B Rao DeviceState *dev, Error **errp) 2731cf632463SBharata B Rao { 27320cffce56SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(hotplug_dev); 2733cf632463SBharata B Rao Error *local_err = NULL; 2734cf632463SBharata B Rao PCDIMMDevice *dimm = PC_DIMM(dev); 2735cf632463SBharata B Rao PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); 2736cf632463SBharata B Rao MemoryRegion *mr = ddc->get_memory_region(dimm); 2737cf632463SBharata B Rao uint64_t size = memory_region_size(mr); 27380cffce56SDavid Gibson uint32_t nr_lmbs = size / SPAPR_MEMORY_BLOCK_SIZE; 27390cffce56SDavid Gibson uint64_t addr_start, addr; 27400cffce56SDavid Gibson int i; 27410cffce56SDavid Gibson sPAPRDRConnector *drc; 27420cffce56SDavid Gibson sPAPRDRConnectorClass *drck; 27430cffce56SDavid Gibson sPAPRDIMMState *ds; 2744cf632463SBharata B Rao 27450cffce56SDavid Gibson addr_start = object_property_get_int(OBJECT(dimm), PC_DIMM_ADDR_PROP, 27460cffce56SDavid Gibson &local_err); 2747cf632463SBharata B Rao if (local_err) { 2748cf632463SBharata B Rao goto out; 2749cf632463SBharata B Rao } 2750cf632463SBharata B Rao 27510cffce56SDavid Gibson ds = g_malloc0(sizeof(sPAPRDIMMState)); 27520cffce56SDavid Gibson ds->nr_lmbs = nr_lmbs; 27530cffce56SDavid Gibson ds->dimm = dimm; 27540cffce56SDavid Gibson spapr_pending_dimm_unplugs_add(spapr, ds); 27550cffce56SDavid Gibson 27560cffce56SDavid Gibson addr = addr_start; 27570cffce56SDavid Gibson for (i = 0; i < nr_lmbs; i++) { 27580cffce56SDavid Gibson drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_LMB, 27590cffce56SDavid Gibson addr / SPAPR_MEMORY_BLOCK_SIZE); 27600cffce56SDavid Gibson g_assert(drc); 27610cffce56SDavid Gibson 27620cffce56SDavid Gibson drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 276331834723SDaniel Henrique Barboza drck->detach(drc, dev, errp); 27640cffce56SDavid Gibson addr += SPAPR_MEMORY_BLOCK_SIZE; 27650cffce56SDavid Gibson } 27660cffce56SDavid Gibson 27670cffce56SDavid Gibson drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_LMB, 27680cffce56SDavid Gibson addr_start / SPAPR_MEMORY_BLOCK_SIZE); 27690cffce56SDavid Gibson drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 27700cffce56SDavid Gibson spapr_hotplug_req_remove_by_count_indexed(SPAPR_DR_CONNECTOR_TYPE_LMB, 27710cffce56SDavid Gibson nr_lmbs, 27720cffce56SDavid Gibson drck->get_index(drc)); 2773cf632463SBharata B Rao out: 2774cf632463SBharata B Rao error_propagate(errp, local_err); 2775cf632463SBharata B Rao } 2776cf632463SBharata B Rao 2777af81cf32SBharata B Rao void *spapr_populate_hotplug_cpu_dt(CPUState *cs, int *fdt_offset, 2778af81cf32SBharata B Rao sPAPRMachineState *spapr) 2779af81cf32SBharata B Rao { 2780af81cf32SBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(cs); 2781af81cf32SBharata B Rao DeviceClass *dc = DEVICE_GET_CLASS(cs); 2782af81cf32SBharata B Rao int id = ppc_get_vcpu_dt_id(cpu); 2783af81cf32SBharata B Rao void *fdt; 2784af81cf32SBharata B Rao int offset, fdt_size; 2785af81cf32SBharata B Rao char *nodename; 2786af81cf32SBharata B Rao 2787af81cf32SBharata B Rao fdt = create_device_tree(&fdt_size); 2788af81cf32SBharata B Rao nodename = g_strdup_printf("%s@%x", dc->fw_name, id); 2789af81cf32SBharata B Rao offset = fdt_add_subnode(fdt, 0, nodename); 2790af81cf32SBharata B Rao 2791af81cf32SBharata B Rao spapr_populate_cpu_dt(cs, fdt, offset, spapr); 2792af81cf32SBharata B Rao g_free(nodename); 2793af81cf32SBharata B Rao 2794af81cf32SBharata B Rao *fdt_offset = offset; 2795af81cf32SBharata B Rao return fdt; 2796af81cf32SBharata B Rao } 2797af81cf32SBharata B Rao 2798115debf2SIgor Mammedov static void spapr_core_unplug(HotplugHandler *hotplug_dev, DeviceState *dev, 2799115debf2SIgor Mammedov Error **errp) 2800ff9006ddSIgor Mammedov { 2801535455fdSIgor Mammedov MachineState *ms = MACHINE(qdev_get_machine()); 2802ff9006ddSIgor Mammedov CPUCore *cc = CPU_CORE(dev); 2803535455fdSIgor Mammedov CPUArchId *core_slot = spapr_find_cpu_slot(ms, cc->core_id, NULL); 2804ff9006ddSIgor Mammedov 280507572c06SGreg Kurz assert(core_slot); 2806535455fdSIgor Mammedov core_slot->cpu = NULL; 2807ff9006ddSIgor Mammedov object_unparent(OBJECT(dev)); 2808ff9006ddSIgor Mammedov } 2809ff9006ddSIgor Mammedov 281031834723SDaniel Henrique Barboza /* Callback to be called during DRC release. */ 281131834723SDaniel Henrique Barboza void spapr_core_release(DeviceState *dev) 2812115debf2SIgor Mammedov { 2813115debf2SIgor Mammedov HotplugHandler *hotplug_ctrl; 2814115debf2SIgor Mammedov 2815115debf2SIgor Mammedov hotplug_ctrl = qdev_get_hotplug_handler(dev); 2816115debf2SIgor Mammedov hotplug_handler_unplug(hotplug_ctrl, dev, &error_abort); 2817115debf2SIgor Mammedov } 2818115debf2SIgor Mammedov 2819115debf2SIgor Mammedov static 2820115debf2SIgor Mammedov void spapr_core_unplug_request(HotplugHandler *hotplug_dev, DeviceState *dev, 2821ff9006ddSIgor Mammedov Error **errp) 2822ff9006ddSIgor Mammedov { 2823535455fdSIgor Mammedov int index; 2824535455fdSIgor Mammedov sPAPRDRConnector *drc; 2825ff9006ddSIgor Mammedov sPAPRDRConnectorClass *drck; 2826ff9006ddSIgor Mammedov Error *local_err = NULL; 2827535455fdSIgor Mammedov CPUCore *cc = CPU_CORE(dev); 2828535455fdSIgor Mammedov int smt = kvmppc_smt_threads(); 2829ff9006ddSIgor Mammedov 2830535455fdSIgor Mammedov if (!spapr_find_cpu_slot(MACHINE(hotplug_dev), cc->core_id, &index)) { 2831535455fdSIgor Mammedov error_setg(errp, "Unable to find CPU core with core-id: %d", 2832535455fdSIgor Mammedov cc->core_id); 2833535455fdSIgor Mammedov return; 2834535455fdSIgor Mammedov } 2835ff9006ddSIgor Mammedov if (index == 0) { 2836ff9006ddSIgor Mammedov error_setg(errp, "Boot CPU core may not be unplugged"); 2837ff9006ddSIgor Mammedov return; 2838ff9006ddSIgor Mammedov } 2839ff9006ddSIgor Mammedov 2840535455fdSIgor Mammedov drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_CPU, index * smt); 2841ff9006ddSIgor Mammedov g_assert(drc); 2842ff9006ddSIgor Mammedov 2843ff9006ddSIgor Mammedov drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 284431834723SDaniel Henrique Barboza drck->detach(drc, dev, &local_err); 2845ff9006ddSIgor Mammedov if (local_err) { 2846ff9006ddSIgor Mammedov error_propagate(errp, local_err); 2847ff9006ddSIgor Mammedov return; 2848ff9006ddSIgor Mammedov } 2849ff9006ddSIgor Mammedov 2850ff9006ddSIgor Mammedov spapr_hotplug_req_remove_by_index(drc); 2851ff9006ddSIgor Mammedov } 2852ff9006ddSIgor Mammedov 2853ff9006ddSIgor Mammedov static void spapr_core_plug(HotplugHandler *hotplug_dev, DeviceState *dev, 2854ff9006ddSIgor Mammedov Error **errp) 2855ff9006ddSIgor Mammedov { 2856ff9006ddSIgor Mammedov sPAPRMachineState *spapr = SPAPR_MACHINE(OBJECT(hotplug_dev)); 2857ff9006ddSIgor Mammedov MachineClass *mc = MACHINE_GET_CLASS(spapr); 2858ff9006ddSIgor Mammedov sPAPRCPUCore *core = SPAPR_CPU_CORE(OBJECT(dev)); 2859ff9006ddSIgor Mammedov CPUCore *cc = CPU_CORE(dev); 2860ff9006ddSIgor Mammedov CPUState *cs = CPU(core->threads); 2861ff9006ddSIgor Mammedov sPAPRDRConnector *drc; 2862ff9006ddSIgor Mammedov Error *local_err = NULL; 2863ff9006ddSIgor Mammedov void *fdt = NULL; 2864ff9006ddSIgor Mammedov int fdt_offset = 0; 2865ff9006ddSIgor Mammedov int smt = kvmppc_smt_threads(); 2866535455fdSIgor Mammedov CPUArchId *core_slot; 2867535455fdSIgor Mammedov int index; 2868ff9006ddSIgor Mammedov 2869535455fdSIgor Mammedov core_slot = spapr_find_cpu_slot(MACHINE(hotplug_dev), cc->core_id, &index); 2870535455fdSIgor Mammedov if (!core_slot) { 2871535455fdSIgor Mammedov error_setg(errp, "Unable to find CPU core with core-id: %d", 2872535455fdSIgor Mammedov cc->core_id); 2873535455fdSIgor Mammedov return; 2874535455fdSIgor Mammedov } 2875ff9006ddSIgor Mammedov drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_CPU, index * smt); 2876ff9006ddSIgor Mammedov 2877c5514d0eSIgor Mammedov g_assert(drc || !mc->has_hotpluggable_cpus); 2878ff9006ddSIgor Mammedov 2879ff9006ddSIgor Mammedov /* 2880ff9006ddSIgor Mammedov * Setup CPU DT entries only for hotplugged CPUs. For boot time or 2881ff9006ddSIgor Mammedov * coldplugged CPUs DT entries are setup in spapr_build_fdt(). 2882ff9006ddSIgor Mammedov */ 2883ff9006ddSIgor Mammedov if (dev->hotplugged) { 2884ff9006ddSIgor Mammedov fdt = spapr_populate_hotplug_cpu_dt(cs, &fdt_offset, spapr); 2885ff9006ddSIgor Mammedov } 2886ff9006ddSIgor Mammedov 2887ff9006ddSIgor Mammedov if (drc) { 2888ff9006ddSIgor Mammedov sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 2889ff9006ddSIgor Mammedov drck->attach(drc, dev, fdt, fdt_offset, !dev->hotplugged, &local_err); 2890ff9006ddSIgor Mammedov if (local_err) { 2891ff9006ddSIgor Mammedov g_free(fdt); 2892ff9006ddSIgor Mammedov error_propagate(errp, local_err); 2893ff9006ddSIgor Mammedov return; 2894ff9006ddSIgor Mammedov } 2895ff9006ddSIgor Mammedov } 2896ff9006ddSIgor Mammedov 2897ff9006ddSIgor Mammedov if (dev->hotplugged) { 2898ff9006ddSIgor Mammedov /* 2899ff9006ddSIgor Mammedov * Send hotplug notification interrupt to the guest only in case 2900ff9006ddSIgor Mammedov * of hotplugged CPUs. 2901ff9006ddSIgor Mammedov */ 2902ff9006ddSIgor Mammedov spapr_hotplug_req_add_by_index(drc); 2903ff9006ddSIgor Mammedov } else { 2904ff9006ddSIgor Mammedov /* 2905ff9006ddSIgor Mammedov * Set the right DRC states for cold plugged CPU. 2906ff9006ddSIgor Mammedov */ 2907ff9006ddSIgor Mammedov if (drc) { 2908ff9006ddSIgor Mammedov sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 2909ff9006ddSIgor Mammedov drck->set_allocation_state(drc, SPAPR_DR_ALLOCATION_STATE_USABLE); 2910ff9006ddSIgor Mammedov drck->set_isolation_state(drc, SPAPR_DR_ISOLATION_STATE_UNISOLATED); 2911ff9006ddSIgor Mammedov } 2912ff9006ddSIgor Mammedov } 2913535455fdSIgor Mammedov core_slot->cpu = OBJECT(dev); 2914ff9006ddSIgor Mammedov } 2915ff9006ddSIgor Mammedov 2916ff9006ddSIgor Mammedov static void spapr_core_pre_plug(HotplugHandler *hotplug_dev, DeviceState *dev, 2917ff9006ddSIgor Mammedov Error **errp) 2918ff9006ddSIgor Mammedov { 2919ff9006ddSIgor Mammedov MachineState *machine = MACHINE(OBJECT(hotplug_dev)); 2920ff9006ddSIgor Mammedov MachineClass *mc = MACHINE_GET_CLASS(hotplug_dev); 2921ff9006ddSIgor Mammedov Error *local_err = NULL; 2922ff9006ddSIgor Mammedov CPUCore *cc = CPU_CORE(dev); 2923ff9006ddSIgor Mammedov char *base_core_type = spapr_get_cpu_core_type(machine->cpu_model); 2924ff9006ddSIgor Mammedov const char *type = object_get_typename(OBJECT(dev)); 2925535455fdSIgor Mammedov CPUArchId *core_slot; 2926535455fdSIgor Mammedov int index; 2927ff9006ddSIgor Mammedov 2928c5514d0eSIgor Mammedov if (dev->hotplugged && !mc->has_hotpluggable_cpus) { 2929ff9006ddSIgor Mammedov error_setg(&local_err, "CPU hotplug not supported for this machine"); 2930ff9006ddSIgor Mammedov goto out; 2931ff9006ddSIgor Mammedov } 2932ff9006ddSIgor Mammedov 2933ff9006ddSIgor Mammedov if (strcmp(base_core_type, type)) { 2934ff9006ddSIgor Mammedov error_setg(&local_err, "CPU core type should be %s", base_core_type); 2935ff9006ddSIgor Mammedov goto out; 2936ff9006ddSIgor Mammedov } 2937ff9006ddSIgor Mammedov 2938ff9006ddSIgor Mammedov if (cc->core_id % smp_threads) { 2939ff9006ddSIgor Mammedov error_setg(&local_err, "invalid core id %d", cc->core_id); 2940ff9006ddSIgor Mammedov goto out; 2941ff9006ddSIgor Mammedov } 2942ff9006ddSIgor Mammedov 2943459264efSDavid Gibson /* 2944459264efSDavid Gibson * In general we should have homogeneous threads-per-core, but old 2945459264efSDavid Gibson * (pre hotplug support) machine types allow the last core to have 2946459264efSDavid Gibson * reduced threads as a compatibility hack for when we allowed 2947459264efSDavid Gibson * total vcpus not a multiple of threads-per-core. 2948459264efSDavid Gibson */ 2949459264efSDavid Gibson if (mc->has_hotpluggable_cpus && (cc->nr_threads != smp_threads)) { 29508149e299SDavid Gibson error_setg(errp, "invalid nr-threads %d, must be %d", 29518149e299SDavid Gibson cc->nr_threads, smp_threads); 29528149e299SDavid Gibson return; 29538149e299SDavid Gibson } 29548149e299SDavid Gibson 2955535455fdSIgor Mammedov core_slot = spapr_find_cpu_slot(MACHINE(hotplug_dev), cc->core_id, &index); 2956535455fdSIgor Mammedov if (!core_slot) { 2957ff9006ddSIgor Mammedov error_setg(&local_err, "core id %d out of range", cc->core_id); 2958ff9006ddSIgor Mammedov goto out; 2959ff9006ddSIgor Mammedov } 2960ff9006ddSIgor Mammedov 2961535455fdSIgor Mammedov if (core_slot->cpu) { 2962ff9006ddSIgor Mammedov error_setg(&local_err, "core %d already populated", cc->core_id); 2963ff9006ddSIgor Mammedov goto out; 2964ff9006ddSIgor Mammedov } 2965ff9006ddSIgor Mammedov 2966a0ceb640SIgor Mammedov numa_cpu_pre_plug(core_slot, dev, &local_err); 29670b8497f0SIgor Mammedov 2968ff9006ddSIgor Mammedov out: 2969ff9006ddSIgor Mammedov g_free(base_core_type); 2970ff9006ddSIgor Mammedov error_propagate(errp, local_err); 2971ff9006ddSIgor Mammedov } 2972ff9006ddSIgor Mammedov 2973c20d332aSBharata B Rao static void spapr_machine_device_plug(HotplugHandler *hotplug_dev, 2974c20d332aSBharata B Rao DeviceState *dev, Error **errp) 2975c20d332aSBharata B Rao { 2976c20d332aSBharata B Rao sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(qdev_get_machine()); 2977c20d332aSBharata B Rao 2978c20d332aSBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { 2979b556854bSBharata B Rao int node; 2980c20d332aSBharata B Rao 2981c20d332aSBharata B Rao if (!smc->dr_lmb_enabled) { 2982c20d332aSBharata B Rao error_setg(errp, "Memory hotplug not supported for this machine"); 2983c20d332aSBharata B Rao return; 2984c20d332aSBharata B Rao } 2985c20d332aSBharata B Rao node = object_property_get_int(OBJECT(dev), PC_DIMM_NODE_PROP, errp); 2986c20d332aSBharata B Rao if (*errp) { 2987c20d332aSBharata B Rao return; 2988c20d332aSBharata B Rao } 29891a5512bbSGonglei if (node < 0 || node >= MAX_NODES) { 29901a5512bbSGonglei error_setg(errp, "Invaild node %d", node); 29911a5512bbSGonglei return; 29921a5512bbSGonglei } 2993c20d332aSBharata B Rao 2994b556854bSBharata B Rao /* 2995b556854bSBharata B Rao * Currently PowerPC kernel doesn't allow hot-adding memory to 2996b556854bSBharata B Rao * memory-less node, but instead will silently add the memory 2997b556854bSBharata B Rao * to the first node that has some memory. This causes two 2998b556854bSBharata B Rao * unexpected behaviours for the user. 2999b556854bSBharata B Rao * 3000b556854bSBharata B Rao * - Memory gets hotplugged to a different node than what the user 3001b556854bSBharata B Rao * specified. 3002b556854bSBharata B Rao * - Since pc-dimm subsystem in QEMU still thinks that memory belongs 3003b556854bSBharata B Rao * to memory-less node, a reboot will set things accordingly 3004b556854bSBharata B Rao * and the previously hotplugged memory now ends in the right node. 3005b556854bSBharata B Rao * This appears as if some memory moved from one node to another. 3006b556854bSBharata B Rao * 3007b556854bSBharata B Rao * So until kernel starts supporting memory hotplug to memory-less 3008b556854bSBharata B Rao * nodes, just prevent such attempts upfront in QEMU. 3009b556854bSBharata B Rao */ 3010b556854bSBharata B Rao if (nb_numa_nodes && !numa_info[node].node_mem) { 3011b556854bSBharata B Rao error_setg(errp, "Can't hotplug memory to memory-less node %d", 3012b556854bSBharata B Rao node); 3013b556854bSBharata B Rao return; 3014b556854bSBharata B Rao } 3015b556854bSBharata B Rao 3016c20d332aSBharata B Rao spapr_memory_plug(hotplug_dev, dev, node, errp); 3017af81cf32SBharata B Rao } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 3018af81cf32SBharata B Rao spapr_core_plug(hotplug_dev, dev, errp); 3019c20d332aSBharata B Rao } 3020c20d332aSBharata B Rao } 3021c20d332aSBharata B Rao 3022c20d332aSBharata B Rao static void spapr_machine_device_unplug(HotplugHandler *hotplug_dev, 3023c20d332aSBharata B Rao DeviceState *dev, Error **errp) 3024c20d332aSBharata B Rao { 3025cf632463SBharata B Rao sPAPRMachineState *sms = SPAPR_MACHINE(qdev_get_machine()); 30263c0c47e3SDavid Gibson MachineClass *mc = MACHINE_GET_CLASS(qdev_get_machine()); 30276f4b5c3eSBharata B Rao 3028c20d332aSBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { 3029cf632463SBharata B Rao if (spapr_ovec_test(sms->ov5_cas, OV5_HP_EVT)) { 3030cf632463SBharata B Rao spapr_memory_unplug(hotplug_dev, dev, errp); 3031cf632463SBharata B Rao } else { 3032cf632463SBharata B Rao error_setg(errp, "Memory hot unplug not supported for this guest"); 3033cf632463SBharata B Rao } 3034cf632463SBharata B Rao } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 3035c5514d0eSIgor Mammedov if (!mc->has_hotpluggable_cpus) { 3036cf632463SBharata B Rao error_setg(errp, "CPU hot unplug not supported on this machine"); 3037cf632463SBharata B Rao return; 3038cf632463SBharata B Rao } 3039cf632463SBharata B Rao spapr_core_unplug(hotplug_dev, dev, errp); 3040cf632463SBharata B Rao } 3041cf632463SBharata B Rao } 3042cf632463SBharata B Rao 3043cf632463SBharata B Rao static void spapr_machine_device_unplug_request(HotplugHandler *hotplug_dev, 3044cf632463SBharata B Rao DeviceState *dev, Error **errp) 3045cf632463SBharata B Rao { 3046cf632463SBharata B Rao sPAPRMachineState *sms = SPAPR_MACHINE(qdev_get_machine()); 3047cf632463SBharata B Rao MachineClass *mc = MACHINE_GET_CLASS(qdev_get_machine()); 3048cf632463SBharata B Rao 3049cf632463SBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { 3050cf632463SBharata B Rao if (spapr_ovec_test(sms->ov5_cas, OV5_HP_EVT)) { 3051cf632463SBharata B Rao spapr_memory_unplug_request(hotplug_dev, dev, errp); 3052cf632463SBharata B Rao } else { 3053cf632463SBharata B Rao /* NOTE: this means there is a window after guest reset, prior to 3054cf632463SBharata B Rao * CAS negotiation, where unplug requests will fail due to the 3055cf632463SBharata B Rao * capability not being detected yet. This is a bit different than 3056cf632463SBharata B Rao * the case with PCI unplug, where the events will be queued and 3057cf632463SBharata B Rao * eventually handled by the guest after boot 3058cf632463SBharata B Rao */ 3059cf632463SBharata B Rao error_setg(errp, "Memory hot unplug not supported for this guest"); 3060cf632463SBharata B Rao } 30616f4b5c3eSBharata B Rao } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 3062c5514d0eSIgor Mammedov if (!mc->has_hotpluggable_cpus) { 30636f4b5c3eSBharata B Rao error_setg(errp, "CPU hot unplug not supported on this machine"); 30646f4b5c3eSBharata B Rao return; 30656f4b5c3eSBharata B Rao } 3066115debf2SIgor Mammedov spapr_core_unplug_request(hotplug_dev, dev, errp); 3067c20d332aSBharata B Rao } 3068c20d332aSBharata B Rao } 3069c20d332aSBharata B Rao 307094a94e4cSBharata B Rao static void spapr_machine_device_pre_plug(HotplugHandler *hotplug_dev, 307194a94e4cSBharata B Rao DeviceState *dev, Error **errp) 307294a94e4cSBharata B Rao { 3073c871bc70SLaurent Vivier if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { 3074c871bc70SLaurent Vivier spapr_memory_pre_plug(hotplug_dev, dev, errp); 3075c871bc70SLaurent Vivier } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 307694a94e4cSBharata B Rao spapr_core_pre_plug(hotplug_dev, dev, errp); 307794a94e4cSBharata B Rao } 307894a94e4cSBharata B Rao } 307994a94e4cSBharata B Rao 30807ebaf795SBharata B Rao static HotplugHandler *spapr_get_hotplug_handler(MachineState *machine, 3081c20d332aSBharata B Rao DeviceState *dev) 3082c20d332aSBharata B Rao { 308394a94e4cSBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM) || 308494a94e4cSBharata B Rao object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 3085c20d332aSBharata B Rao return HOTPLUG_HANDLER(machine); 3086c20d332aSBharata B Rao } 3087c20d332aSBharata B Rao return NULL; 3088c20d332aSBharata B Rao } 3089c20d332aSBharata B Rao 3090ea089eebSIgor Mammedov static CpuInstanceProperties 3091ea089eebSIgor Mammedov spapr_cpu_index_to_props(MachineState *machine, unsigned cpu_index) 309220bb648dSDavid Gibson { 3093ea089eebSIgor Mammedov CPUArchId *core_slot; 3094ea089eebSIgor Mammedov MachineClass *mc = MACHINE_GET_CLASS(machine); 3095ea089eebSIgor Mammedov 3096ea089eebSIgor Mammedov /* make sure possible_cpu are intialized */ 3097ea089eebSIgor Mammedov mc->possible_cpu_arch_ids(machine); 3098ea089eebSIgor Mammedov /* get CPU core slot containing thread that matches cpu_index */ 3099ea089eebSIgor Mammedov core_slot = spapr_find_cpu_slot(machine, cpu_index, NULL); 3100ea089eebSIgor Mammedov assert(core_slot); 3101ea089eebSIgor Mammedov return core_slot->props; 310220bb648dSDavid Gibson } 310320bb648dSDavid Gibson 3104535455fdSIgor Mammedov static const CPUArchIdList *spapr_possible_cpu_arch_ids(MachineState *machine) 3105535455fdSIgor Mammedov { 3106535455fdSIgor Mammedov int i; 3107535455fdSIgor Mammedov int spapr_max_cores = max_cpus / smp_threads; 3108535455fdSIgor Mammedov MachineClass *mc = MACHINE_GET_CLASS(machine); 3109535455fdSIgor Mammedov 3110c5514d0eSIgor Mammedov if (!mc->has_hotpluggable_cpus) { 3111535455fdSIgor Mammedov spapr_max_cores = QEMU_ALIGN_UP(smp_cpus, smp_threads) / smp_threads; 3112535455fdSIgor Mammedov } 3113535455fdSIgor Mammedov if (machine->possible_cpus) { 3114535455fdSIgor Mammedov assert(machine->possible_cpus->len == spapr_max_cores); 3115535455fdSIgor Mammedov return machine->possible_cpus; 3116535455fdSIgor Mammedov } 3117535455fdSIgor Mammedov 3118535455fdSIgor Mammedov machine->possible_cpus = g_malloc0(sizeof(CPUArchIdList) + 3119535455fdSIgor Mammedov sizeof(CPUArchId) * spapr_max_cores); 3120535455fdSIgor Mammedov machine->possible_cpus->len = spapr_max_cores; 3121535455fdSIgor Mammedov for (i = 0; i < machine->possible_cpus->len; i++) { 3122535455fdSIgor Mammedov int core_id = i * smp_threads; 3123535455fdSIgor Mammedov 3124f2d672c2SIgor Mammedov machine->possible_cpus->cpus[i].vcpus_count = smp_threads; 3125535455fdSIgor Mammedov machine->possible_cpus->cpus[i].arch_id = core_id; 3126535455fdSIgor Mammedov machine->possible_cpus->cpus[i].props.has_core_id = true; 3127535455fdSIgor Mammedov machine->possible_cpus->cpus[i].props.core_id = core_id; 3128ea089eebSIgor Mammedov 3129ea089eebSIgor Mammedov /* default distribution of CPUs over NUMA nodes */ 3130ea089eebSIgor Mammedov if (nb_numa_nodes) { 3131ea089eebSIgor Mammedov /* preset values but do not enable them i.e. 'has_node_id = false', 3132ea089eebSIgor Mammedov * numa init code will enable them later if manual mapping wasn't 3133ea089eebSIgor Mammedov * present on CLI */ 3134ea089eebSIgor Mammedov machine->possible_cpus->cpus[i].props.node_id = 3135ea089eebSIgor Mammedov core_id / smp_threads / smp_cores % nb_numa_nodes; 3136ea089eebSIgor Mammedov } 3137535455fdSIgor Mammedov } 3138535455fdSIgor Mammedov return machine->possible_cpus; 3139535455fdSIgor Mammedov } 3140535455fdSIgor Mammedov 31416737d9adSDavid Gibson static void spapr_phb_placement(sPAPRMachineState *spapr, uint32_t index, 3142daa23699SDavid Gibson uint64_t *buid, hwaddr *pio, 3143daa23699SDavid Gibson hwaddr *mmio32, hwaddr *mmio64, 31446737d9adSDavid Gibson unsigned n_dma, uint32_t *liobns, Error **errp) 31456737d9adSDavid Gibson { 3146357d1e3bSDavid Gibson /* 3147357d1e3bSDavid Gibson * New-style PHB window placement. 3148357d1e3bSDavid Gibson * 3149357d1e3bSDavid Gibson * Goals: Gives large (1TiB), naturally aligned 64-bit MMIO window 3150357d1e3bSDavid Gibson * for each PHB, in addition to 2GiB 32-bit MMIO and 64kiB PIO 3151357d1e3bSDavid Gibson * windows. 3152357d1e3bSDavid Gibson * 3153357d1e3bSDavid Gibson * Some guest kernels can't work with MMIO windows above 1<<46 3154357d1e3bSDavid Gibson * (64TiB), so we place up to 31 PHBs in the area 32TiB..64TiB 3155357d1e3bSDavid Gibson * 3156357d1e3bSDavid Gibson * 32TiB..(33TiB+1984kiB) contains the 64kiB PIO windows for each 3157357d1e3bSDavid Gibson * PHB stacked together. (32TiB+2GiB)..(32TiB+64GiB) contains the 3158357d1e3bSDavid Gibson * 2GiB 32-bit MMIO windows for each PHB. Then 33..64TiB has the 3159357d1e3bSDavid Gibson * 1TiB 64-bit MMIO windows for each PHB. 3160357d1e3bSDavid Gibson */ 31616737d9adSDavid Gibson const uint64_t base_buid = 0x800000020000000ULL; 316225e6a118SMichael S. Tsirkin #define SPAPR_MAX_PHBS ((SPAPR_PCI_LIMIT - SPAPR_PCI_BASE) / \ 316325e6a118SMichael S. Tsirkin SPAPR_PCI_MEM64_WIN_SIZE - 1) 31646737d9adSDavid Gibson int i; 31656737d9adSDavid Gibson 3166357d1e3bSDavid Gibson /* Sanity check natural alignments */ 3167357d1e3bSDavid Gibson QEMU_BUILD_BUG_ON((SPAPR_PCI_BASE % SPAPR_PCI_MEM64_WIN_SIZE) != 0); 3168357d1e3bSDavid Gibson QEMU_BUILD_BUG_ON((SPAPR_PCI_LIMIT % SPAPR_PCI_MEM64_WIN_SIZE) != 0); 3169357d1e3bSDavid Gibson QEMU_BUILD_BUG_ON((SPAPR_PCI_MEM64_WIN_SIZE % SPAPR_PCI_MEM32_WIN_SIZE) != 0); 3170357d1e3bSDavid Gibson QEMU_BUILD_BUG_ON((SPAPR_PCI_MEM32_WIN_SIZE % SPAPR_PCI_IO_WIN_SIZE) != 0); 3171357d1e3bSDavid Gibson /* Sanity check bounds */ 317225e6a118SMichael S. Tsirkin QEMU_BUILD_BUG_ON((SPAPR_MAX_PHBS * SPAPR_PCI_IO_WIN_SIZE) > 317325e6a118SMichael S. Tsirkin SPAPR_PCI_MEM32_WIN_SIZE); 317425e6a118SMichael S. Tsirkin QEMU_BUILD_BUG_ON((SPAPR_MAX_PHBS * SPAPR_PCI_MEM32_WIN_SIZE) > 317525e6a118SMichael S. Tsirkin SPAPR_PCI_MEM64_WIN_SIZE); 31762efff1c0SDavid Gibson 317725e6a118SMichael S. Tsirkin if (index >= SPAPR_MAX_PHBS) { 317825e6a118SMichael S. Tsirkin error_setg(errp, "\"index\" for PAPR PHB is too large (max %llu)", 317925e6a118SMichael S. Tsirkin SPAPR_MAX_PHBS - 1); 31806737d9adSDavid Gibson return; 31816737d9adSDavid Gibson } 31826737d9adSDavid Gibson 31836737d9adSDavid Gibson *buid = base_buid + index; 31846737d9adSDavid Gibson for (i = 0; i < n_dma; ++i) { 31856737d9adSDavid Gibson liobns[i] = SPAPR_PCI_LIOBN(index, i); 31866737d9adSDavid Gibson } 31876737d9adSDavid Gibson 3188357d1e3bSDavid Gibson *pio = SPAPR_PCI_BASE + index * SPAPR_PCI_IO_WIN_SIZE; 3189357d1e3bSDavid Gibson *mmio32 = SPAPR_PCI_BASE + (index + 1) * SPAPR_PCI_MEM32_WIN_SIZE; 3190357d1e3bSDavid Gibson *mmio64 = SPAPR_PCI_BASE + (index + 1) * SPAPR_PCI_MEM64_WIN_SIZE; 31916737d9adSDavid Gibson } 31926737d9adSDavid Gibson 31937844e12bSCédric Le Goater static ICSState *spapr_ics_get(XICSFabric *dev, int irq) 31947844e12bSCédric Le Goater { 31957844e12bSCédric Le Goater sPAPRMachineState *spapr = SPAPR_MACHINE(dev); 31967844e12bSCédric Le Goater 31977844e12bSCédric Le Goater return ics_valid_irq(spapr->ics, irq) ? spapr->ics : NULL; 31987844e12bSCédric Le Goater } 31997844e12bSCédric Le Goater 32007844e12bSCédric Le Goater static void spapr_ics_resend(XICSFabric *dev) 32017844e12bSCédric Le Goater { 32027844e12bSCédric Le Goater sPAPRMachineState *spapr = SPAPR_MACHINE(dev); 32037844e12bSCédric Le Goater 32047844e12bSCédric Le Goater ics_resend(spapr->ics); 32057844e12bSCédric Le Goater } 32067844e12bSCédric Le Goater 320706747ba6SCédric Le Goater static ICPState *spapr_icp_get(XICSFabric *xi, int cpu_dt_id) 3208b2fc59aaSCédric Le Goater { 32095bc8d26dSCédric Le Goater PowerPCCPU *cpu = ppc_get_vcpu_by_dt_id(cpu_dt_id); 3210b2fc59aaSCédric Le Goater 32115bc8d26dSCédric Le Goater return cpu ? ICP(cpu->intc) : NULL; 3212b2fc59aaSCédric Le Goater } 3213b2fc59aaSCédric Le Goater 32146449da45SCédric Le Goater static void spapr_pic_print_info(InterruptStatsProvider *obj, 32156449da45SCédric Le Goater Monitor *mon) 32166449da45SCédric Le Goater { 32176449da45SCédric Le Goater sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 32185bc8d26dSCédric Le Goater CPUState *cs; 32196449da45SCédric Le Goater 32205bc8d26dSCédric Le Goater CPU_FOREACH(cs) { 32215bc8d26dSCédric Le Goater PowerPCCPU *cpu = POWERPC_CPU(cs); 32225bc8d26dSCédric Le Goater 32235bc8d26dSCédric Le Goater icp_pic_print_info(ICP(cpu->intc), mon); 32246449da45SCédric Le Goater } 32256449da45SCédric Le Goater 32266449da45SCédric Le Goater ics_pic_print_info(spapr->ics, mon); 32276449da45SCédric Le Goater } 32286449da45SCédric Le Goater 322929ee3247SAlexey Kardashevskiy static void spapr_machine_class_init(ObjectClass *oc, void *data) 323053018216SPaolo Bonzini { 323129ee3247SAlexey Kardashevskiy MachineClass *mc = MACHINE_CLASS(oc); 3232224245bfSDavid Gibson sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(oc); 323371461b0fSAlexey Kardashevskiy FWPathProviderClass *fwc = FW_PATH_PROVIDER_CLASS(oc); 323434316482SAlexey Kardashevskiy NMIClass *nc = NMI_CLASS(oc); 3235c20d332aSBharata B Rao HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(oc); 32361d1be34dSDavid Gibson PPCVirtualHypervisorClass *vhc = PPC_VIRTUAL_HYPERVISOR_CLASS(oc); 32377844e12bSCédric Le Goater XICSFabricClass *xic = XICS_FABRIC_CLASS(oc); 32386449da45SCédric Le Goater InterruptStatsProviderClass *ispc = INTERRUPT_STATS_PROVIDER_CLASS(oc); 323929ee3247SAlexey Kardashevskiy 32400eb9054cSDavid Gibson mc->desc = "pSeries Logical Partition (PAPR compliant)"; 3241fc9f38c3SDavid Gibson 3242fc9f38c3SDavid Gibson /* 3243fc9f38c3SDavid Gibson * We set up the default / latest behaviour here. The class_init 3244fc9f38c3SDavid Gibson * functions for the specific versioned machine types can override 3245fc9f38c3SDavid Gibson * these details for backwards compatibility 3246fc9f38c3SDavid Gibson */ 3247958db90cSMarcel Apfelbaum mc->init = ppc_spapr_init; 3248958db90cSMarcel Apfelbaum mc->reset = ppc_spapr_reset; 3249958db90cSMarcel Apfelbaum mc->block_default_type = IF_SCSI; 32506244bb7eSGreg Kurz mc->max_cpus = 1024; 3251958db90cSMarcel Apfelbaum mc->no_parallel = 1; 32525b2128d2SAlexander Graf mc->default_boot_order = ""; 3253a34944feSNikunj A Dadhania mc->default_ram_size = 512 * M_BYTE; 3254958db90cSMarcel Apfelbaum mc->kvm_type = spapr_kvm_type; 32559e3f9733SAlexander Graf mc->has_dynamic_sysbus = true; 3256e4024630SLaurent Vivier mc->pci_allow_0_address = true; 32577ebaf795SBharata B Rao mc->get_hotplug_handler = spapr_get_hotplug_handler; 325894a94e4cSBharata B Rao hc->pre_plug = spapr_machine_device_pre_plug; 3259c20d332aSBharata B Rao hc->plug = spapr_machine_device_plug; 3260c20d332aSBharata B Rao hc->unplug = spapr_machine_device_unplug; 3261ea089eebSIgor Mammedov mc->cpu_index_to_instance_props = spapr_cpu_index_to_props; 3262535455fdSIgor Mammedov mc->possible_cpu_arch_ids = spapr_possible_cpu_arch_ids; 3263cf632463SBharata B Rao hc->unplug_request = spapr_machine_device_unplug_request; 326400b4fbe2SMarcel Apfelbaum 3265fc9f38c3SDavid Gibson smc->dr_lmb_enabled = true; 32663daa4a9fSThomas Huth smc->tcg_default_cpu = "POWER8"; 3267c5514d0eSIgor Mammedov mc->has_hotpluggable_cpus = true; 326871461b0fSAlexey Kardashevskiy fwc->get_dev_path = spapr_get_fw_dev_path; 326934316482SAlexey Kardashevskiy nc->nmi_monitor_handler = spapr_nmi; 32706737d9adSDavid Gibson smc->phb_placement = spapr_phb_placement; 32711d1be34dSDavid Gibson vhc->hypercall = emulate_spapr_hypercall; 3272e57ca75cSDavid Gibson vhc->hpt_mask = spapr_hpt_mask; 3273e57ca75cSDavid Gibson vhc->map_hptes = spapr_map_hptes; 3274e57ca75cSDavid Gibson vhc->unmap_hptes = spapr_unmap_hptes; 3275e57ca75cSDavid Gibson vhc->store_hpte = spapr_store_hpte; 32769861bb3eSSuraj Jitindar Singh vhc->get_patbe = spapr_get_patbe; 32777844e12bSCédric Le Goater xic->ics_get = spapr_ics_get; 32787844e12bSCédric Le Goater xic->ics_resend = spapr_ics_resend; 3279b2fc59aaSCédric Le Goater xic->icp_get = spapr_icp_get; 32806449da45SCédric Le Goater ispc->print_info = spapr_pic_print_info; 328155641213SLaurent Vivier /* Force NUMA node memory size to be a multiple of 328255641213SLaurent Vivier * SPAPR_MEMORY_BLOCK_SIZE (256M) since that's the granularity 328355641213SLaurent Vivier * in which LMBs are represented and hot-added 328455641213SLaurent Vivier */ 328555641213SLaurent Vivier mc->numa_mem_align_shift = 28; 328653018216SPaolo Bonzini } 328753018216SPaolo Bonzini 328829ee3247SAlexey Kardashevskiy static const TypeInfo spapr_machine_info = { 328929ee3247SAlexey Kardashevskiy .name = TYPE_SPAPR_MACHINE, 329029ee3247SAlexey Kardashevskiy .parent = TYPE_MACHINE, 32914aee7362SDavid Gibson .abstract = true, 32926ca1502eSAlexey Kardashevskiy .instance_size = sizeof(sPAPRMachineState), 329323825581SEduardo Habkost .instance_init = spapr_machine_initfn, 329487bbdd9cSDavid Gibson .instance_finalize = spapr_machine_finalizefn, 3295183930c0SDavid Gibson .class_size = sizeof(sPAPRMachineClass), 329629ee3247SAlexey Kardashevskiy .class_init = spapr_machine_class_init, 329771461b0fSAlexey Kardashevskiy .interfaces = (InterfaceInfo[]) { 329871461b0fSAlexey Kardashevskiy { TYPE_FW_PATH_PROVIDER }, 329934316482SAlexey Kardashevskiy { TYPE_NMI }, 3300c20d332aSBharata B Rao { TYPE_HOTPLUG_HANDLER }, 33011d1be34dSDavid Gibson { TYPE_PPC_VIRTUAL_HYPERVISOR }, 33027844e12bSCédric Le Goater { TYPE_XICS_FABRIC }, 33036449da45SCédric Le Goater { TYPE_INTERRUPT_STATS_PROVIDER }, 330471461b0fSAlexey Kardashevskiy { } 330571461b0fSAlexey Kardashevskiy }, 330629ee3247SAlexey Kardashevskiy }; 330729ee3247SAlexey Kardashevskiy 3308fccbc785SDavid Gibson #define DEFINE_SPAPR_MACHINE(suffix, verstr, latest) \ 33095013c547SDavid Gibson static void spapr_machine_##suffix##_class_init(ObjectClass *oc, \ 33105013c547SDavid Gibson void *data) \ 33115013c547SDavid Gibson { \ 33125013c547SDavid Gibson MachineClass *mc = MACHINE_CLASS(oc); \ 33135013c547SDavid Gibson spapr_machine_##suffix##_class_options(mc); \ 3314fccbc785SDavid Gibson if (latest) { \ 3315fccbc785SDavid Gibson mc->alias = "pseries"; \ 3316fccbc785SDavid Gibson mc->is_default = 1; \ 3317fccbc785SDavid Gibson } \ 33185013c547SDavid Gibson } \ 33195013c547SDavid Gibson static void spapr_machine_##suffix##_instance_init(Object *obj) \ 33205013c547SDavid Gibson { \ 33215013c547SDavid Gibson MachineState *machine = MACHINE(obj); \ 33225013c547SDavid Gibson spapr_machine_##suffix##_instance_options(machine); \ 33235013c547SDavid Gibson } \ 33245013c547SDavid Gibson static const TypeInfo spapr_machine_##suffix##_info = { \ 33255013c547SDavid Gibson .name = MACHINE_TYPE_NAME("pseries-" verstr), \ 33265013c547SDavid Gibson .parent = TYPE_SPAPR_MACHINE, \ 33275013c547SDavid Gibson .class_init = spapr_machine_##suffix##_class_init, \ 33285013c547SDavid Gibson .instance_init = spapr_machine_##suffix##_instance_init, \ 33295013c547SDavid Gibson }; \ 33305013c547SDavid Gibson static void spapr_machine_register_##suffix(void) \ 33315013c547SDavid Gibson { \ 33325013c547SDavid Gibson type_register(&spapr_machine_##suffix##_info); \ 33335013c547SDavid Gibson } \ 33340e6aac87SEduardo Habkost type_init(spapr_machine_register_##suffix) 33355013c547SDavid Gibson 33361c5f29bbSDavid Gibson /* 33373fa14fbeSDavid Gibson * pseries-2.10 3338db800b21SDavid Gibson */ 33393fa14fbeSDavid Gibson static void spapr_machine_2_10_instance_options(MachineState *machine) 3340db800b21SDavid Gibson { 3341db800b21SDavid Gibson } 3342db800b21SDavid Gibson 33433fa14fbeSDavid Gibson static void spapr_machine_2_10_class_options(MachineClass *mc) 3344db800b21SDavid Gibson { 3345db800b21SDavid Gibson /* Defaults for the latest behaviour inherited from the base class */ 3346db800b21SDavid Gibson } 3347db800b21SDavid Gibson 33483fa14fbeSDavid Gibson DEFINE_SPAPR_MACHINE(2_10, "2.10", true); 33493fa14fbeSDavid Gibson 33503fa14fbeSDavid Gibson /* 33513fa14fbeSDavid Gibson * pseries-2.9 33523fa14fbeSDavid Gibson */ 33533fa14fbeSDavid Gibson #define SPAPR_COMPAT_2_9 \ 33543fa14fbeSDavid Gibson HW_COMPAT_2_9 33553fa14fbeSDavid Gibson 33563fa14fbeSDavid Gibson static void spapr_machine_2_9_instance_options(MachineState *machine) 33573fa14fbeSDavid Gibson { 33583fa14fbeSDavid Gibson spapr_machine_2_10_instance_options(machine); 33593fa14fbeSDavid Gibson } 33603fa14fbeSDavid Gibson 33613fa14fbeSDavid Gibson static void spapr_machine_2_9_class_options(MachineClass *mc) 33623fa14fbeSDavid Gibson { 33633fa14fbeSDavid Gibson spapr_machine_2_10_class_options(mc); 33643fa14fbeSDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_9); 33653bfe5716SLaurent Vivier mc->numa_auto_assign_ram = numa_legacy_auto_assign_ram; 33663fa14fbeSDavid Gibson } 33673fa14fbeSDavid Gibson 33683fa14fbeSDavid Gibson DEFINE_SPAPR_MACHINE(2_9, "2.9", false); 3369fa325e6cSDavid Gibson 3370fa325e6cSDavid Gibson /* 3371fa325e6cSDavid Gibson * pseries-2.8 3372fa325e6cSDavid Gibson */ 3373fa325e6cSDavid Gibson #define SPAPR_COMPAT_2_8 \ 337482516263SDavid Gibson HW_COMPAT_2_8 \ 337582516263SDavid Gibson { \ 337682516263SDavid Gibson .driver = TYPE_SPAPR_PCI_HOST_BRIDGE, \ 337782516263SDavid Gibson .property = "pcie-extended-configuration-space", \ 337882516263SDavid Gibson .value = "off", \ 337982516263SDavid Gibson }, 3380fa325e6cSDavid Gibson 3381fa325e6cSDavid Gibson static void spapr_machine_2_8_instance_options(MachineState *machine) 3382fa325e6cSDavid Gibson { 3383fa325e6cSDavid Gibson spapr_machine_2_9_instance_options(machine); 3384fa325e6cSDavid Gibson } 3385fa325e6cSDavid Gibson 3386fa325e6cSDavid Gibson static void spapr_machine_2_8_class_options(MachineClass *mc) 3387fa325e6cSDavid Gibson { 3388fa325e6cSDavid Gibson spapr_machine_2_9_class_options(mc); 3389fa325e6cSDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_8); 339055641213SLaurent Vivier mc->numa_mem_align_shift = 23; 3391fa325e6cSDavid Gibson } 3392fa325e6cSDavid Gibson 3393fa325e6cSDavid Gibson DEFINE_SPAPR_MACHINE(2_8, "2.8", false); 3394db800b21SDavid Gibson 3395db800b21SDavid Gibson /* 33961ea1eefcSBharata B Rao * pseries-2.7 33971ea1eefcSBharata B Rao */ 3398db800b21SDavid Gibson #define SPAPR_COMPAT_2_7 \ 3399db800b21SDavid Gibson HW_COMPAT_2_7 \ 3400357d1e3bSDavid Gibson { \ 3401357d1e3bSDavid Gibson .driver = TYPE_SPAPR_PCI_HOST_BRIDGE, \ 3402357d1e3bSDavid Gibson .property = "mem_win_size", \ 3403357d1e3bSDavid Gibson .value = stringify(SPAPR_PCI_2_7_MMIO_WIN_SIZE),\ 3404357d1e3bSDavid Gibson }, \ 3405357d1e3bSDavid Gibson { \ 3406357d1e3bSDavid Gibson .driver = TYPE_SPAPR_PCI_HOST_BRIDGE, \ 3407357d1e3bSDavid Gibson .property = "mem64_win_size", \ 3408357d1e3bSDavid Gibson .value = "0", \ 3409146c11f1SDavid Gibson }, \ 3410146c11f1SDavid Gibson { \ 3411146c11f1SDavid Gibson .driver = TYPE_POWERPC_CPU, \ 3412146c11f1SDavid Gibson .property = "pre-2.8-migration", \ 3413146c11f1SDavid Gibson .value = "on", \ 34145c4537bdSDavid Gibson }, \ 34155c4537bdSDavid Gibson { \ 34165c4537bdSDavid Gibson .driver = TYPE_SPAPR_PCI_HOST_BRIDGE, \ 34175c4537bdSDavid Gibson .property = "pre-2.8-migration", \ 34185c4537bdSDavid Gibson .value = "on", \ 3419357d1e3bSDavid Gibson }, 3420357d1e3bSDavid Gibson 3421357d1e3bSDavid Gibson static void phb_placement_2_7(sPAPRMachineState *spapr, uint32_t index, 3422357d1e3bSDavid Gibson uint64_t *buid, hwaddr *pio, 3423357d1e3bSDavid Gibson hwaddr *mmio32, hwaddr *mmio64, 3424357d1e3bSDavid Gibson unsigned n_dma, uint32_t *liobns, Error **errp) 3425357d1e3bSDavid Gibson { 3426357d1e3bSDavid Gibson /* Legacy PHB placement for pseries-2.7 and earlier machine types */ 3427357d1e3bSDavid Gibson const uint64_t base_buid = 0x800000020000000ULL; 3428357d1e3bSDavid Gibson const hwaddr phb_spacing = 0x1000000000ULL; /* 64 GiB */ 3429357d1e3bSDavid Gibson const hwaddr mmio_offset = 0xa0000000; /* 2 GiB + 512 MiB */ 3430357d1e3bSDavid Gibson const hwaddr pio_offset = 0x80000000; /* 2 GiB */ 3431357d1e3bSDavid Gibson const uint32_t max_index = 255; 3432357d1e3bSDavid Gibson const hwaddr phb0_alignment = 0x10000000000ULL; /* 1 TiB */ 3433357d1e3bSDavid Gibson 3434357d1e3bSDavid Gibson uint64_t ram_top = MACHINE(spapr)->ram_size; 3435357d1e3bSDavid Gibson hwaddr phb0_base, phb_base; 3436357d1e3bSDavid Gibson int i; 3437357d1e3bSDavid Gibson 3438357d1e3bSDavid Gibson /* Do we have hotpluggable memory? */ 3439357d1e3bSDavid Gibson if (MACHINE(spapr)->maxram_size > ram_top) { 3440357d1e3bSDavid Gibson /* Can't just use maxram_size, because there may be an 3441357d1e3bSDavid Gibson * alignment gap between normal and hotpluggable memory 3442357d1e3bSDavid Gibson * regions */ 3443357d1e3bSDavid Gibson ram_top = spapr->hotplug_memory.base + 3444357d1e3bSDavid Gibson memory_region_size(&spapr->hotplug_memory.mr); 3445357d1e3bSDavid Gibson } 3446357d1e3bSDavid Gibson 3447357d1e3bSDavid Gibson phb0_base = QEMU_ALIGN_UP(ram_top, phb0_alignment); 3448357d1e3bSDavid Gibson 3449357d1e3bSDavid Gibson if (index > max_index) { 3450357d1e3bSDavid Gibson error_setg(errp, "\"index\" for PAPR PHB is too large (max %u)", 3451357d1e3bSDavid Gibson max_index); 3452357d1e3bSDavid Gibson return; 3453357d1e3bSDavid Gibson } 3454357d1e3bSDavid Gibson 3455357d1e3bSDavid Gibson *buid = base_buid + index; 3456357d1e3bSDavid Gibson for (i = 0; i < n_dma; ++i) { 3457357d1e3bSDavid Gibson liobns[i] = SPAPR_PCI_LIOBN(index, i); 3458357d1e3bSDavid Gibson } 3459357d1e3bSDavid Gibson 3460357d1e3bSDavid Gibson phb_base = phb0_base + index * phb_spacing; 3461357d1e3bSDavid Gibson *pio = phb_base + pio_offset; 3462357d1e3bSDavid Gibson *mmio32 = phb_base + mmio_offset; 3463357d1e3bSDavid Gibson /* 3464357d1e3bSDavid Gibson * We don't set the 64-bit MMIO window, relying on the PHB's 3465357d1e3bSDavid Gibson * fallback behaviour of automatically splitting a large "32-bit" 3466357d1e3bSDavid Gibson * window into contiguous 32-bit and 64-bit windows 3467357d1e3bSDavid Gibson */ 3468357d1e3bSDavid Gibson } 3469db800b21SDavid Gibson 34701ea1eefcSBharata B Rao static void spapr_machine_2_7_instance_options(MachineState *machine) 34711ea1eefcSBharata B Rao { 3472f6229214SMichael Roth sPAPRMachineState *spapr = SPAPR_MACHINE(machine); 3473f6229214SMichael Roth 3474672de881SMichael Roth spapr_machine_2_8_instance_options(machine); 3475f6229214SMichael Roth spapr->use_hotplug_event_source = false; 34761ea1eefcSBharata B Rao } 34771ea1eefcSBharata B Rao 34781ea1eefcSBharata B Rao static void spapr_machine_2_7_class_options(MachineClass *mc) 34791ea1eefcSBharata B Rao { 34803daa4a9fSThomas Huth sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); 34813daa4a9fSThomas Huth 3482db800b21SDavid Gibson spapr_machine_2_8_class_options(mc); 34833daa4a9fSThomas Huth smc->tcg_default_cpu = "POWER7"; 3484db800b21SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_7); 3485357d1e3bSDavid Gibson smc->phb_placement = phb_placement_2_7; 34861ea1eefcSBharata B Rao } 34871ea1eefcSBharata B Rao 3488db800b21SDavid Gibson DEFINE_SPAPR_MACHINE(2_7, "2.7", false); 34891ea1eefcSBharata B Rao 34901ea1eefcSBharata B Rao /* 34914b23699cSDavid Gibson * pseries-2.6 34924b23699cSDavid Gibson */ 34931ea1eefcSBharata B Rao #define SPAPR_COMPAT_2_6 \ 3494ae4de14cSAlexey Kardashevskiy HW_COMPAT_2_6 \ 3495ae4de14cSAlexey Kardashevskiy { \ 3496ae4de14cSAlexey Kardashevskiy .driver = TYPE_SPAPR_PCI_HOST_BRIDGE,\ 3497ae4de14cSAlexey Kardashevskiy .property = "ddw",\ 3498ae4de14cSAlexey Kardashevskiy .value = stringify(off),\ 3499ae4de14cSAlexey Kardashevskiy }, 35001ea1eefcSBharata B Rao 35014b23699cSDavid Gibson static void spapr_machine_2_6_instance_options(MachineState *machine) 35024b23699cSDavid Gibson { 3503672de881SMichael Roth spapr_machine_2_7_instance_options(machine); 35044b23699cSDavid Gibson } 35054b23699cSDavid Gibson 35064b23699cSDavid Gibson static void spapr_machine_2_6_class_options(MachineClass *mc) 35074b23699cSDavid Gibson { 35081ea1eefcSBharata B Rao spapr_machine_2_7_class_options(mc); 3509c5514d0eSIgor Mammedov mc->has_hotpluggable_cpus = false; 35101ea1eefcSBharata B Rao SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_6); 35114b23699cSDavid Gibson } 35124b23699cSDavid Gibson 35131ea1eefcSBharata B Rao DEFINE_SPAPR_MACHINE(2_6, "2.6", false); 35144b23699cSDavid Gibson 35154b23699cSDavid Gibson /* 35161c5f29bbSDavid Gibson * pseries-2.5 35171c5f29bbSDavid Gibson */ 35184b23699cSDavid Gibson #define SPAPR_COMPAT_2_5 \ 351957c522f4SThomas Huth HW_COMPAT_2_5 \ 352057c522f4SThomas Huth { \ 352157c522f4SThomas Huth .driver = "spapr-vlan", \ 352257c522f4SThomas Huth .property = "use-rx-buffer-pools", \ 352357c522f4SThomas Huth .value = "off", \ 352457c522f4SThomas Huth }, 35254b23699cSDavid Gibson 35265013c547SDavid Gibson static void spapr_machine_2_5_instance_options(MachineState *machine) 35271c5f29bbSDavid Gibson { 3528672de881SMichael Roth spapr_machine_2_6_instance_options(machine); 35295013c547SDavid Gibson } 35305013c547SDavid Gibson 35315013c547SDavid Gibson static void spapr_machine_2_5_class_options(MachineClass *mc) 35325013c547SDavid Gibson { 353357040d45SThomas Huth sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); 353457040d45SThomas Huth 35354b23699cSDavid Gibson spapr_machine_2_6_class_options(mc); 353657040d45SThomas Huth smc->use_ohci_by_default = true; 35374b23699cSDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_5); 35381c5f29bbSDavid Gibson } 35391c5f29bbSDavid Gibson 35404b23699cSDavid Gibson DEFINE_SPAPR_MACHINE(2_5, "2.5", false); 35411c5f29bbSDavid Gibson 35421c5f29bbSDavid Gibson /* 35431c5f29bbSDavid Gibson * pseries-2.4 35441c5f29bbSDavid Gibson */ 354580fd50f9SCornelia Huck #define SPAPR_COMPAT_2_4 \ 354680fd50f9SCornelia Huck HW_COMPAT_2_4 354780fd50f9SCornelia Huck 35485013c547SDavid Gibson static void spapr_machine_2_4_instance_options(MachineState *machine) 35491c5f29bbSDavid Gibson { 35505013c547SDavid Gibson spapr_machine_2_5_instance_options(machine); 35515013c547SDavid Gibson } 35521c5f29bbSDavid Gibson 35535013c547SDavid Gibson static void spapr_machine_2_4_class_options(MachineClass *mc) 35545013c547SDavid Gibson { 3555fc9f38c3SDavid Gibson sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); 3556fc9f38c3SDavid Gibson 3557fc9f38c3SDavid Gibson spapr_machine_2_5_class_options(mc); 3558fc9f38c3SDavid Gibson smc->dr_lmb_enabled = false; 3559f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_4); 35601c5f29bbSDavid Gibson } 35611c5f29bbSDavid Gibson 3562fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_4, "2.4", false); 35631c5f29bbSDavid Gibson 35641c5f29bbSDavid Gibson /* 35651c5f29bbSDavid Gibson * pseries-2.3 35661c5f29bbSDavid Gibson */ 356738ff32c6SEduardo Habkost #define SPAPR_COMPAT_2_3 \ 35687619c7b0SMichael Roth HW_COMPAT_2_3 \ 35697619c7b0SMichael Roth {\ 35707619c7b0SMichael Roth .driver = "spapr-pci-host-bridge",\ 35717619c7b0SMichael Roth .property = "dynamic-reconfiguration",\ 35727619c7b0SMichael Roth .value = "off",\ 35737619c7b0SMichael Roth }, 357438ff32c6SEduardo Habkost 35755013c547SDavid Gibson static void spapr_machine_2_3_instance_options(MachineState *machine) 35761c5f29bbSDavid Gibson { 35775013c547SDavid Gibson spapr_machine_2_4_instance_options(machine); 35781c5f29bbSDavid Gibson savevm_skip_section_footers(); 35791c5f29bbSDavid Gibson global_state_set_optional(); 358009b5e30dSGreg Kurz savevm_skip_configuration(); 35811c5f29bbSDavid Gibson } 35821c5f29bbSDavid Gibson 35835013c547SDavid Gibson static void spapr_machine_2_3_class_options(MachineClass *mc) 35841c5f29bbSDavid Gibson { 3585fc9f38c3SDavid Gibson spapr_machine_2_4_class_options(mc); 3586f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_3); 35871c5f29bbSDavid Gibson } 3588fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_3, "2.3", false); 35891c5f29bbSDavid Gibson 35901c5f29bbSDavid Gibson /* 35911c5f29bbSDavid Gibson * pseries-2.2 35921c5f29bbSDavid Gibson */ 35931c5f29bbSDavid Gibson 3594b194df47SAlexey Kardashevskiy #define SPAPR_COMPAT_2_2 \ 35954dfd8eaaSEduardo Habkost HW_COMPAT_2_2 \ 3596b194df47SAlexey Kardashevskiy {\ 3597b194df47SAlexey Kardashevskiy .driver = TYPE_SPAPR_PCI_HOST_BRIDGE,\ 3598b194df47SAlexey Kardashevskiy .property = "mem_win_size",\ 3599b194df47SAlexey Kardashevskiy .value = "0x20000000",\ 3600dd754bafSEduardo Habkost }, 3601b194df47SAlexey Kardashevskiy 36025013c547SDavid Gibson static void spapr_machine_2_2_instance_options(MachineState *machine) 3603b0e966d0SJason Wang { 36045013c547SDavid Gibson spapr_machine_2_3_instance_options(machine); 3605cba0e779SGreg Kurz machine->suppress_vmdesc = true; 3606b0e966d0SJason Wang } 3607b0e966d0SJason Wang 36085013c547SDavid Gibson static void spapr_machine_2_2_class_options(MachineClass *mc) 3609b0e966d0SJason Wang { 3610fc9f38c3SDavid Gibson spapr_machine_2_3_class_options(mc); 3611f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_2); 36121c5f29bbSDavid Gibson } 3613fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_2, "2.2", false); 36141c5f29bbSDavid Gibson 36151c5f29bbSDavid Gibson /* 36161c5f29bbSDavid Gibson * pseries-2.1 36171c5f29bbSDavid Gibson */ 36181c5f29bbSDavid Gibson #define SPAPR_COMPAT_2_1 \ 36191c5f29bbSDavid Gibson HW_COMPAT_2_1 36201c5f29bbSDavid Gibson 36215013c547SDavid Gibson static void spapr_machine_2_1_instance_options(MachineState *machine) 36221c5f29bbSDavid Gibson { 36235013c547SDavid Gibson spapr_machine_2_2_instance_options(machine); 36241c5f29bbSDavid Gibson } 36251c5f29bbSDavid Gibson 36265013c547SDavid Gibson static void spapr_machine_2_1_class_options(MachineClass *mc) 3627b0e966d0SJason Wang { 3628fc9f38c3SDavid Gibson spapr_machine_2_2_class_options(mc); 3629f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_1); 36306026db45SAlexey Kardashevskiy } 3631fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_1, "2.1", false); 36326026db45SAlexey Kardashevskiy 363329ee3247SAlexey Kardashevskiy static void spapr_machine_register_types(void) 363429ee3247SAlexey Kardashevskiy { 363529ee3247SAlexey Kardashevskiy type_register_static(&spapr_machine_info); 363629ee3247SAlexey Kardashevskiy } 363729ee3247SAlexey Kardashevskiy 363829ee3247SAlexey Kardashevskiy type_init(spapr_machine_register_types) 3639