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 { 1044e4169f7SCédric Le Goater Error *err = NULL, *local_err = NULL; 10571cd4dacSCédric Le Goater Object *obj; 106c04d6cfaSAnthony Liguori 10771cd4dacSCédric Le Goater obj = object_new(type_ics); 10871cd4dacSCédric Le Goater object_property_add_child(OBJECT(spapr), "ics", obj, NULL); 10971cd4dacSCédric Le Goater object_property_add_const_link(obj, "xics", OBJECT(spapr), &error_abort); 11071cd4dacSCédric Le Goater object_property_set_int(obj, nr_irqs, "nr-irqs", &err); 11171cd4dacSCédric Le Goater object_property_set_bool(obj, true, "realized", &local_err); 1124e4169f7SCédric Le Goater error_propagate(&err, local_err); 1134e4169f7SCédric Le Goater if (err) { 1144e4169f7SCédric Le Goater error_propagate(errp, err); 11571cd4dacSCédric Le Goater return NULL; 116c04d6cfaSAnthony Liguori } 117c04d6cfaSAnthony Liguori 11871cd4dacSCédric Le Goater return ICS_SIMPLE(obj); 1195bc8d26dSCédric Le Goater } 1205bc8d26dSCédric Le Goater 12171cd4dacSCédric Le Goater static void xics_system_init(MachineState *machine, int nr_irqs, Error **errp) 122c04d6cfaSAnthony Liguori { 12371cd4dacSCédric Le Goater sPAPRMachineState *spapr = SPAPR_MACHINE(machine); 124c04d6cfaSAnthony Liguori 12511ad93f6SDavid Gibson if (kvm_enabled()) { 12634f2af3dSMarkus Armbruster Error *err = NULL; 12734f2af3dSMarkus Armbruster 1282192a930SCédric Le Goater if (machine_kernel_irqchip_allowed(machine) && 12971cd4dacSCédric Le Goater !xics_kvm_init(spapr, errp)) { 13071cd4dacSCédric Le Goater spapr->icp_type = TYPE_KVM_ICP; 13171cd4dacSCédric Le Goater spapr->ics = spapr_ics_create(spapr, TYPE_ICS_KVM, nr_irqs, &err); 13211ad93f6SDavid Gibson } 13371cd4dacSCédric Le Goater if (machine_kernel_irqchip_required(machine) && !spapr->ics) { 134b83baa60SMarkus Armbruster error_reportf_err(err, 135b83baa60SMarkus Armbruster "kernel_irqchip requested but unavailable: "); 136b83baa60SMarkus Armbruster } else { 137903a41d3SStefano Dong (董兴水) error_free(err); 13811ad93f6SDavid Gibson } 139b83baa60SMarkus Armbruster } 14011ad93f6SDavid Gibson 14171cd4dacSCédric Le Goater if (!spapr->ics) { 14271cd4dacSCédric Le Goater xics_spapr_init(spapr, errp); 14371cd4dacSCédric Le Goater spapr->icp_type = TYPE_ICP; 14471cd4dacSCédric Le Goater spapr->ics = spapr_ics_create(spapr, TYPE_ICS_SIMPLE, nr_irqs, errp); 145c04d6cfaSAnthony Liguori } 146c04d6cfaSAnthony Liguori } 147c04d6cfaSAnthony Liguori 148833d4668SAlexey Kardashevskiy static int spapr_fixup_cpu_smt_dt(void *fdt, int offset, PowerPCCPU *cpu, 149833d4668SAlexey Kardashevskiy int smt_threads) 150833d4668SAlexey Kardashevskiy { 151833d4668SAlexey Kardashevskiy int i, ret = 0; 152833d4668SAlexey Kardashevskiy uint32_t servers_prop[smt_threads]; 153833d4668SAlexey Kardashevskiy uint32_t gservers_prop[smt_threads * 2]; 154833d4668SAlexey Kardashevskiy int index = ppc_get_vcpu_dt_id(cpu); 155833d4668SAlexey Kardashevskiy 156d6e166c0SDavid Gibson if (cpu->compat_pvr) { 157d6e166c0SDavid Gibson ret = fdt_setprop_cell(fdt, offset, "cpu-version", cpu->compat_pvr); 1586d9412eaSAlexey Kardashevskiy if (ret < 0) { 1596d9412eaSAlexey Kardashevskiy return ret; 1606d9412eaSAlexey Kardashevskiy } 1616d9412eaSAlexey Kardashevskiy } 1626d9412eaSAlexey Kardashevskiy 163833d4668SAlexey Kardashevskiy /* Build interrupt servers and gservers properties */ 164833d4668SAlexey Kardashevskiy for (i = 0; i < smt_threads; i++) { 165833d4668SAlexey Kardashevskiy servers_prop[i] = cpu_to_be32(index + i); 166833d4668SAlexey Kardashevskiy /* Hack, direct the group queues back to cpu 0 */ 167833d4668SAlexey Kardashevskiy gservers_prop[i*2] = cpu_to_be32(index + i); 168833d4668SAlexey Kardashevskiy gservers_prop[i*2 + 1] = 0; 169833d4668SAlexey Kardashevskiy } 170833d4668SAlexey Kardashevskiy ret = fdt_setprop(fdt, offset, "ibm,ppc-interrupt-server#s", 171833d4668SAlexey Kardashevskiy servers_prop, sizeof(servers_prop)); 172833d4668SAlexey Kardashevskiy if (ret < 0) { 173833d4668SAlexey Kardashevskiy return ret; 174833d4668SAlexey Kardashevskiy } 175833d4668SAlexey Kardashevskiy ret = fdt_setprop(fdt, offset, "ibm,ppc-interrupt-gserver#s", 176833d4668SAlexey Kardashevskiy gservers_prop, sizeof(gservers_prop)); 177833d4668SAlexey Kardashevskiy 178833d4668SAlexey Kardashevskiy return ret; 179833d4668SAlexey Kardashevskiy } 180833d4668SAlexey Kardashevskiy 1810da6f3feSBharata B Rao static int spapr_fixup_cpu_numa_dt(void *fdt, int offset, CPUState *cs) 1820da6f3feSBharata B Rao { 1830da6f3feSBharata B Rao int ret = 0; 1840da6f3feSBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(cs); 1850da6f3feSBharata B Rao int index = ppc_get_vcpu_dt_id(cpu); 1860da6f3feSBharata B Rao uint32_t associativity[] = {cpu_to_be32(0x5), 1870da6f3feSBharata B Rao cpu_to_be32(0x0), 1880da6f3feSBharata B Rao cpu_to_be32(0x0), 1890da6f3feSBharata B Rao cpu_to_be32(0x0), 1900da6f3feSBharata B Rao cpu_to_be32(cs->numa_node), 1910da6f3feSBharata B Rao cpu_to_be32(index)}; 1920da6f3feSBharata B Rao 1930da6f3feSBharata B Rao /* Advertise NUMA via ibm,associativity */ 1940da6f3feSBharata B Rao if (nb_numa_nodes > 1) { 1950da6f3feSBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,associativity", associativity, 1960da6f3feSBharata B Rao sizeof(associativity)); 1970da6f3feSBharata B Rao } 1980da6f3feSBharata B Rao 1990da6f3feSBharata B Rao return ret; 2000da6f3feSBharata B Rao } 2010da6f3feSBharata B Rao 20286d5771aSSam Bobroff /* Populate the "ibm,pa-features" property */ 203e957f6a9SSam Bobroff static void spapr_populate_pa_features(CPUPPCState *env, void *fdt, int offset, 204e957f6a9SSam Bobroff bool legacy_guest) 20586d5771aSSam Bobroff { 20686d5771aSSam Bobroff uint8_t pa_features_206[] = { 6, 0, 20786d5771aSSam Bobroff 0xf6, 0x1f, 0xc7, 0x00, 0x80, 0xc0 }; 20886d5771aSSam Bobroff uint8_t pa_features_207[] = { 24, 0, 20986d5771aSSam Bobroff 0xf6, 0x1f, 0xc7, 0xc0, 0x80, 0xf0, 21086d5771aSSam Bobroff 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 21186d5771aSSam Bobroff 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 21286d5771aSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x00, 0x00 }; 2139fb4541fSSam Bobroff uint8_t pa_features_300[] = { 66, 0, 2149fb4541fSSam Bobroff /* 0: MMU|FPU|SLB|RUN|DABR|NX, 1: fri[nzpm]|DABRX|SPRG3|SLB0|PP110 */ 2159fb4541fSSam Bobroff /* 2: VPM|DS205|PPR|DS202|DS206, 3: LSD|URG, SSO, 5: LE|CFAR|EB|LSQ */ 21686d5771aSSam Bobroff 0xf6, 0x1f, 0xc7, 0xc0, 0x80, 0xf0, /* 0 - 5 */ 2179fb4541fSSam Bobroff /* 6: DS207 */ 21886d5771aSSam Bobroff 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, /* 6 - 11 */ 2199fb4541fSSam Bobroff /* 16: Vector */ 22086d5771aSSam Bobroff 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, /* 12 - 17 */ 2219fb4541fSSam Bobroff /* 18: Vec. Scalar, 20: Vec. XOR, 22: HTM */ 2229fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, /* 18 - 23 */ 2239fb4541fSSam Bobroff /* 24: Ext. Dec, 26: 64 bit ftrs, 28: PM ftrs */ 2249fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, /* 24 - 29 */ 2259fb4541fSSam Bobroff /* 30: MMR, 32: LE atomic, 34: EBB + ext EBB */ 2269fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0xC0, 0x00, /* 30 - 35 */ 2279fb4541fSSam Bobroff /* 36: SPR SO, 38: Copy/Paste, 40: Radix MMU */ 2289fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, /* 36 - 41 */ 2299fb4541fSSam Bobroff /* 42: PM, 44: PC RA, 46: SC vec'd */ 2309fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, /* 42 - 47 */ 2319fb4541fSSam Bobroff /* 48: SIMD, 50: QP BFP, 52: String */ 2329fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, /* 48 - 53 */ 2339fb4541fSSam Bobroff /* 54: DecFP, 56: DecI, 58: SHA */ 2349fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, /* 54 - 59 */ 2359fb4541fSSam Bobroff /* 60: NM atomic, 62: RNG */ 2369fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x00, 0x00, /* 60 - 65 */ 2379fb4541fSSam Bobroff }; 23886d5771aSSam Bobroff uint8_t *pa_features; 23986d5771aSSam Bobroff size_t pa_size; 24086d5771aSSam Bobroff 24186d5771aSSam Bobroff switch (POWERPC_MMU_VER(env->mmu_model)) { 24286d5771aSSam Bobroff case POWERPC_MMU_VER_2_06: 24386d5771aSSam Bobroff pa_features = pa_features_206; 24486d5771aSSam Bobroff pa_size = sizeof(pa_features_206); 24586d5771aSSam Bobroff break; 24686d5771aSSam Bobroff case POWERPC_MMU_VER_2_07: 24786d5771aSSam Bobroff pa_features = pa_features_207; 24886d5771aSSam Bobroff pa_size = sizeof(pa_features_207); 24986d5771aSSam Bobroff break; 25086d5771aSSam Bobroff case POWERPC_MMU_VER_3_00: 25186d5771aSSam Bobroff pa_features = pa_features_300; 25286d5771aSSam Bobroff pa_size = sizeof(pa_features_300); 25386d5771aSSam Bobroff break; 25486d5771aSSam Bobroff default: 25586d5771aSSam Bobroff return; 25686d5771aSSam Bobroff } 25786d5771aSSam Bobroff 25886d5771aSSam Bobroff if (env->ci_large_pages) { 25986d5771aSSam Bobroff /* 26086d5771aSSam Bobroff * Note: we keep CI large pages off by default because a 64K capable 26186d5771aSSam Bobroff * guest provisioned with large pages might otherwise try to map a qemu 26286d5771aSSam Bobroff * framebuffer (or other kind of memory mapped PCI BAR) using 64K pages 26386d5771aSSam Bobroff * even if that qemu runs on a 4k host. 26486d5771aSSam Bobroff * We dd this bit back here if we are confident this is not an issue 26586d5771aSSam Bobroff */ 26686d5771aSSam Bobroff pa_features[3] |= 0x20; 26786d5771aSSam Bobroff } 26886d5771aSSam Bobroff if (kvmppc_has_cap_htm() && pa_size > 24) { 26986d5771aSSam Bobroff pa_features[24] |= 0x80; /* Transactional memory support */ 27086d5771aSSam Bobroff } 271e957f6a9SSam Bobroff if (legacy_guest && pa_size > 40) { 272e957f6a9SSam Bobroff /* Workaround for broken kernels that attempt (guest) radix 273e957f6a9SSam Bobroff * mode when they can't handle it, if they see the radix bit set 274e957f6a9SSam Bobroff * in pa-features. So hide it from them. */ 275e957f6a9SSam Bobroff pa_features[40 + 2] &= ~0x80; /* Radix MMU */ 276e957f6a9SSam Bobroff } 27786d5771aSSam Bobroff 27886d5771aSSam Bobroff _FDT((fdt_setprop(fdt, offset, "ibm,pa-features", pa_features, pa_size))); 27986d5771aSSam Bobroff } 28086d5771aSSam Bobroff 28128e02042SDavid Gibson static int spapr_fixup_cpu_dt(void *fdt, sPAPRMachineState *spapr) 28253018216SPaolo Bonzini { 28382677ed2SAlexey Kardashevskiy int ret = 0, offset, cpus_offset; 28482677ed2SAlexey Kardashevskiy CPUState *cs; 28553018216SPaolo Bonzini char cpu_model[32]; 28653018216SPaolo Bonzini int smt = kvmppc_smt_threads(); 28753018216SPaolo Bonzini uint32_t pft_size_prop[] = {0, cpu_to_be32(spapr->htab_shift)}; 28853018216SPaolo Bonzini 28982677ed2SAlexey Kardashevskiy CPU_FOREACH(cs) { 29082677ed2SAlexey Kardashevskiy PowerPCCPU *cpu = POWERPC_CPU(cs); 291e957f6a9SSam Bobroff CPUPPCState *env = &cpu->env; 29282677ed2SAlexey Kardashevskiy DeviceClass *dc = DEVICE_GET_CLASS(cs); 29382677ed2SAlexey Kardashevskiy int index = ppc_get_vcpu_dt_id(cpu); 29412dbeb16SDavid Gibson int compat_smt = MIN(smp_threads, ppc_compat_max_threads(cpu)); 29553018216SPaolo Bonzini 2960f20ba62SAlexey Kardashevskiy if ((index % smt) != 0) { 29753018216SPaolo Bonzini continue; 29853018216SPaolo Bonzini } 29953018216SPaolo Bonzini 30082677ed2SAlexey Kardashevskiy snprintf(cpu_model, 32, "%s@%x", dc->fw_name, index); 30153018216SPaolo Bonzini 30282677ed2SAlexey Kardashevskiy cpus_offset = fdt_path_offset(fdt, "/cpus"); 30382677ed2SAlexey Kardashevskiy if (cpus_offset < 0) { 30482677ed2SAlexey Kardashevskiy cpus_offset = fdt_add_subnode(fdt, fdt_path_offset(fdt, "/"), 30582677ed2SAlexey Kardashevskiy "cpus"); 30682677ed2SAlexey Kardashevskiy if (cpus_offset < 0) { 30782677ed2SAlexey Kardashevskiy return cpus_offset; 30882677ed2SAlexey Kardashevskiy } 30982677ed2SAlexey Kardashevskiy } 31082677ed2SAlexey Kardashevskiy offset = fdt_subnode_offset(fdt, cpus_offset, cpu_model); 31182677ed2SAlexey Kardashevskiy if (offset < 0) { 31282677ed2SAlexey Kardashevskiy offset = fdt_add_subnode(fdt, cpus_offset, cpu_model); 31353018216SPaolo Bonzini if (offset < 0) { 31453018216SPaolo Bonzini return offset; 31553018216SPaolo Bonzini } 31682677ed2SAlexey Kardashevskiy } 31753018216SPaolo Bonzini 3180da6f3feSBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,pft-size", 3190da6f3feSBharata B Rao pft_size_prop, sizeof(pft_size_prop)); 32053018216SPaolo Bonzini if (ret < 0) { 32153018216SPaolo Bonzini return ret; 32253018216SPaolo Bonzini } 32353018216SPaolo Bonzini 3240da6f3feSBharata B Rao ret = spapr_fixup_cpu_numa_dt(fdt, offset, cs); 32553018216SPaolo Bonzini if (ret < 0) { 32653018216SPaolo Bonzini return ret; 32753018216SPaolo Bonzini } 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 5410da6f3feSBharata B Rao _FDT(spapr_fixup_cpu_numa_dt(fdt, offset, cs)); 5420da6f3feSBharata B Rao 54312dbeb16SDavid Gibson _FDT(spapr_fixup_cpu_smt_dt(fdt, offset, cpu, compat_smt)); 544c64abd1fSSam Bobroff 545c64abd1fSSam Bobroff if (pcc->radix_page_info) { 546c64abd1fSSam Bobroff for (i = 0; i < pcc->radix_page_info->count; i++) { 547c64abd1fSSam Bobroff radix_AP_encodings[i] = 548c64abd1fSSam Bobroff cpu_to_be32(pcc->radix_page_info->entries[i]); 549c64abd1fSSam Bobroff } 550c64abd1fSSam Bobroff _FDT((fdt_setprop(fdt, offset, "ibm,processor-radix-AP-encodings", 551c64abd1fSSam Bobroff radix_AP_encodings, 552c64abd1fSSam Bobroff pcc->radix_page_info->count * 553c64abd1fSSam Bobroff sizeof(radix_AP_encodings[0])))); 554c64abd1fSSam Bobroff } 5550da6f3feSBharata B Rao } 5560da6f3feSBharata B Rao 5570da6f3feSBharata B Rao static void spapr_populate_cpus_dt_node(void *fdt, sPAPRMachineState *spapr) 5580da6f3feSBharata B Rao { 5590da6f3feSBharata B Rao CPUState *cs; 5600da6f3feSBharata B Rao int cpus_offset; 5610da6f3feSBharata B Rao char *nodename; 5620da6f3feSBharata B Rao int smt = kvmppc_smt_threads(); 5630da6f3feSBharata B Rao 5640da6f3feSBharata B Rao cpus_offset = fdt_add_subnode(fdt, 0, "cpus"); 5650da6f3feSBharata B Rao _FDT(cpus_offset); 5660da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, cpus_offset, "#address-cells", 0x1))); 5670da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, cpus_offset, "#size-cells", 0x0))); 5680da6f3feSBharata B Rao 5690da6f3feSBharata B Rao /* 5700da6f3feSBharata B Rao * We walk the CPUs in reverse order to ensure that CPU DT nodes 5710da6f3feSBharata B Rao * created by fdt_add_subnode() end up in the right order in FDT 5720da6f3feSBharata B Rao * for the guest kernel the enumerate the CPUs correctly. 5730da6f3feSBharata B Rao */ 5740da6f3feSBharata B Rao CPU_FOREACH_REVERSE(cs) { 5750da6f3feSBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(cs); 5760da6f3feSBharata B Rao int index = ppc_get_vcpu_dt_id(cpu); 5770da6f3feSBharata B Rao DeviceClass *dc = DEVICE_GET_CLASS(cs); 5780da6f3feSBharata B Rao int offset; 5790da6f3feSBharata B Rao 5800da6f3feSBharata B Rao if ((index % smt) != 0) { 5810da6f3feSBharata B Rao continue; 5820da6f3feSBharata B Rao } 5830da6f3feSBharata B Rao 5840da6f3feSBharata B Rao nodename = g_strdup_printf("%s@%x", dc->fw_name, index); 5850da6f3feSBharata B Rao offset = fdt_add_subnode(fdt, cpus_offset, nodename); 5860da6f3feSBharata B Rao g_free(nodename); 5870da6f3feSBharata B Rao _FDT(offset); 5880da6f3feSBharata B Rao spapr_populate_cpu_dt(cs, fdt, offset, spapr); 5890da6f3feSBharata B Rao } 5900da6f3feSBharata B Rao 5910da6f3feSBharata B Rao } 5920da6f3feSBharata B Rao 59303d196b7SBharata B Rao /* 59403d196b7SBharata B Rao * Adds ibm,dynamic-reconfiguration-memory node. 59503d196b7SBharata B Rao * Refer to docs/specs/ppc-spapr-hotplug.txt for the documentation 59603d196b7SBharata B Rao * of this device tree node. 59703d196b7SBharata B Rao */ 59803d196b7SBharata B Rao static int spapr_populate_drconf_memory(sPAPRMachineState *spapr, void *fdt) 59903d196b7SBharata B Rao { 60003d196b7SBharata B Rao MachineState *machine = MACHINE(spapr); 60103d196b7SBharata B Rao int ret, i, offset; 60203d196b7SBharata B Rao uint64_t lmb_size = SPAPR_MEMORY_BLOCK_SIZE; 60303d196b7SBharata B Rao uint32_t prop_lmb_size[] = {0, cpu_to_be32(lmb_size)}; 604d0e5a8f2SBharata B Rao uint32_t hotplug_lmb_start = spapr->hotplug_memory.base / lmb_size; 605d0e5a8f2SBharata B Rao uint32_t nr_lmbs = (spapr->hotplug_memory.base + 606d0e5a8f2SBharata B Rao memory_region_size(&spapr->hotplug_memory.mr)) / 607d0e5a8f2SBharata B Rao lmb_size; 60803d196b7SBharata B Rao uint32_t *int_buf, *cur_index, buf_len; 6096663864eSBharata B Rao int nr_nodes = nb_numa_nodes ? nb_numa_nodes : 1; 61003d196b7SBharata B Rao 611ef001f06SThomas Huth /* 612d0e5a8f2SBharata B Rao * Don't create the node if there is no hotpluggable memory 61316c25aefSBharata B Rao */ 614d0e5a8f2SBharata B Rao if (machine->ram_size == machine->maxram_size) { 61516c25aefSBharata B Rao return 0; 61616c25aefSBharata B Rao } 61716c25aefSBharata B Rao 61816c25aefSBharata B Rao /* 619ef001f06SThomas Huth * Allocate enough buffer size to fit in ibm,dynamic-memory 620ef001f06SThomas Huth * or ibm,associativity-lookup-arrays 621ef001f06SThomas Huth */ 622ef001f06SThomas Huth buf_len = MAX(nr_lmbs * SPAPR_DR_LMB_LIST_ENTRY_SIZE + 1, nr_nodes * 4 + 2) 623ef001f06SThomas Huth * sizeof(uint32_t); 62403d196b7SBharata B Rao cur_index = int_buf = g_malloc0(buf_len); 62503d196b7SBharata B Rao 62603d196b7SBharata B Rao offset = fdt_add_subnode(fdt, 0, "ibm,dynamic-reconfiguration-memory"); 62703d196b7SBharata B Rao 62803d196b7SBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,lmb-size", prop_lmb_size, 62903d196b7SBharata B Rao sizeof(prop_lmb_size)); 63003d196b7SBharata B Rao if (ret < 0) { 63103d196b7SBharata B Rao goto out; 63203d196b7SBharata B Rao } 63303d196b7SBharata B Rao 63403d196b7SBharata B Rao ret = fdt_setprop_cell(fdt, offset, "ibm,memory-flags-mask", 0xff); 63503d196b7SBharata B Rao if (ret < 0) { 63603d196b7SBharata B Rao goto out; 63703d196b7SBharata B Rao } 63803d196b7SBharata B Rao 63903d196b7SBharata B Rao ret = fdt_setprop_cell(fdt, offset, "ibm,memory-preservation-time", 0x0); 64003d196b7SBharata B Rao if (ret < 0) { 64103d196b7SBharata B Rao goto out; 64203d196b7SBharata B Rao } 64303d196b7SBharata B Rao 64403d196b7SBharata B Rao /* ibm,dynamic-memory */ 64503d196b7SBharata B Rao int_buf[0] = cpu_to_be32(nr_lmbs); 64603d196b7SBharata B Rao cur_index++; 64703d196b7SBharata B Rao for (i = 0; i < nr_lmbs; i++) { 648d0e5a8f2SBharata B Rao uint64_t addr = i * lmb_size; 64903d196b7SBharata B Rao uint32_t *dynamic_memory = cur_index; 65003d196b7SBharata B Rao 651d0e5a8f2SBharata B Rao if (i >= hotplug_lmb_start) { 652d0e5a8f2SBharata B Rao sPAPRDRConnector *drc; 653d0e5a8f2SBharata B Rao sPAPRDRConnectorClass *drck; 654d0e5a8f2SBharata B Rao 655d0e5a8f2SBharata B Rao drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_LMB, i); 65603d196b7SBharata B Rao g_assert(drc); 65703d196b7SBharata B Rao drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 65803d196b7SBharata B Rao 65903d196b7SBharata B Rao dynamic_memory[0] = cpu_to_be32(addr >> 32); 66003d196b7SBharata B Rao dynamic_memory[1] = cpu_to_be32(addr & 0xffffffff); 66103d196b7SBharata B Rao dynamic_memory[2] = cpu_to_be32(drck->get_index(drc)); 66203d196b7SBharata B Rao dynamic_memory[3] = cpu_to_be32(0); /* reserved */ 66303d196b7SBharata B Rao dynamic_memory[4] = cpu_to_be32(numa_get_node(addr, NULL)); 664d0e5a8f2SBharata B Rao if (memory_region_present(get_system_memory(), addr)) { 66503d196b7SBharata B Rao dynamic_memory[5] = cpu_to_be32(SPAPR_LMB_FLAGS_ASSIGNED); 66603d196b7SBharata B Rao } else { 66703d196b7SBharata B Rao dynamic_memory[5] = cpu_to_be32(0); 66803d196b7SBharata B Rao } 669d0e5a8f2SBharata B Rao } else { 670d0e5a8f2SBharata B Rao /* 671d0e5a8f2SBharata B Rao * LMB information for RMA, boot time RAM and gap b/n RAM and 672d0e5a8f2SBharata B Rao * hotplug memory region -- all these are marked as reserved 673d0e5a8f2SBharata B Rao * and as having no valid DRC. 674d0e5a8f2SBharata B Rao */ 675d0e5a8f2SBharata B Rao dynamic_memory[0] = cpu_to_be32(addr >> 32); 676d0e5a8f2SBharata B Rao dynamic_memory[1] = cpu_to_be32(addr & 0xffffffff); 677d0e5a8f2SBharata B Rao dynamic_memory[2] = cpu_to_be32(0); 678d0e5a8f2SBharata B Rao dynamic_memory[3] = cpu_to_be32(0); /* reserved */ 679d0e5a8f2SBharata B Rao dynamic_memory[4] = cpu_to_be32(-1); 680d0e5a8f2SBharata B Rao dynamic_memory[5] = cpu_to_be32(SPAPR_LMB_FLAGS_RESERVED | 681d0e5a8f2SBharata B Rao SPAPR_LMB_FLAGS_DRC_INVALID); 682d0e5a8f2SBharata B Rao } 68303d196b7SBharata B Rao 68403d196b7SBharata B Rao cur_index += SPAPR_DR_LMB_LIST_ENTRY_SIZE; 68503d196b7SBharata B Rao } 68603d196b7SBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,dynamic-memory", int_buf, buf_len); 68703d196b7SBharata B Rao if (ret < 0) { 68803d196b7SBharata B Rao goto out; 68903d196b7SBharata B Rao } 69003d196b7SBharata B Rao 69103d196b7SBharata B Rao /* ibm,associativity-lookup-arrays */ 69203d196b7SBharata B Rao cur_index = int_buf; 6936663864eSBharata B Rao int_buf[0] = cpu_to_be32(nr_nodes); 69403d196b7SBharata B Rao int_buf[1] = cpu_to_be32(4); /* Number of entries per associativity list */ 69503d196b7SBharata B Rao cur_index += 2; 6966663864eSBharata B Rao for (i = 0; i < nr_nodes; i++) { 69703d196b7SBharata B Rao uint32_t associativity[] = { 69803d196b7SBharata B Rao cpu_to_be32(0x0), 69903d196b7SBharata B Rao cpu_to_be32(0x0), 70003d196b7SBharata B Rao cpu_to_be32(0x0), 70103d196b7SBharata B Rao cpu_to_be32(i) 70203d196b7SBharata B Rao }; 70303d196b7SBharata B Rao memcpy(cur_index, associativity, sizeof(associativity)); 70403d196b7SBharata B Rao cur_index += 4; 70503d196b7SBharata B Rao } 70603d196b7SBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,associativity-lookup-arrays", int_buf, 70703d196b7SBharata B Rao (cur_index - int_buf) * sizeof(uint32_t)); 70803d196b7SBharata B Rao out: 70903d196b7SBharata B Rao g_free(int_buf); 71003d196b7SBharata B Rao return ret; 71103d196b7SBharata B Rao } 71203d196b7SBharata B Rao 7136787d27bSMichael Roth static int spapr_dt_cas_updates(sPAPRMachineState *spapr, void *fdt, 7146787d27bSMichael Roth sPAPROptionVector *ov5_updates) 7156787d27bSMichael Roth { 7166787d27bSMichael Roth sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(spapr); 717417ece33SMichael Roth int ret = 0, offset; 7186787d27bSMichael Roth 7196787d27bSMichael Roth /* Generate ibm,dynamic-reconfiguration-memory node if required */ 7206787d27bSMichael Roth if (spapr_ovec_test(ov5_updates, OV5_DRCONF_MEMORY)) { 7216787d27bSMichael Roth g_assert(smc->dr_lmb_enabled); 7226787d27bSMichael Roth ret = spapr_populate_drconf_memory(spapr, fdt); 723417ece33SMichael Roth if (ret) { 724417ece33SMichael Roth goto out; 725417ece33SMichael Roth } 7266787d27bSMichael Roth } 7276787d27bSMichael Roth 728417ece33SMichael Roth offset = fdt_path_offset(fdt, "/chosen"); 729417ece33SMichael Roth if (offset < 0) { 730417ece33SMichael Roth offset = fdt_add_subnode(fdt, 0, "chosen"); 731417ece33SMichael Roth if (offset < 0) { 732417ece33SMichael Roth return offset; 733417ece33SMichael Roth } 734417ece33SMichael Roth } 735417ece33SMichael Roth ret = spapr_ovec_populate_dt(fdt, offset, spapr->ov5_cas, 736417ece33SMichael Roth "ibm,architecture-vec-5"); 737417ece33SMichael Roth 738417ece33SMichael Roth out: 7396787d27bSMichael Roth return ret; 7406787d27bSMichael Roth } 7416787d27bSMichael Roth 74203d196b7SBharata B Rao int spapr_h_cas_compose_response(sPAPRMachineState *spapr, 74303d196b7SBharata B Rao target_ulong addr, target_ulong size, 7446787d27bSMichael Roth sPAPROptionVector *ov5_updates) 74503d196b7SBharata B Rao { 74603d196b7SBharata B Rao void *fdt, *fdt_skel; 74703d196b7SBharata B Rao sPAPRDeviceTreeUpdateHeader hdr = { .version_id = 1 }; 74803d196b7SBharata B Rao 74903d196b7SBharata B Rao size -= sizeof(hdr); 75003d196b7SBharata B Rao 75103d196b7SBharata B Rao /* Create sceleton */ 75203d196b7SBharata B Rao fdt_skel = g_malloc0(size); 75303d196b7SBharata B Rao _FDT((fdt_create(fdt_skel, size))); 75403d196b7SBharata B Rao _FDT((fdt_begin_node(fdt_skel, ""))); 75503d196b7SBharata B Rao _FDT((fdt_end_node(fdt_skel))); 75603d196b7SBharata B Rao _FDT((fdt_finish(fdt_skel))); 75703d196b7SBharata B Rao fdt = g_malloc0(size); 75803d196b7SBharata B Rao _FDT((fdt_open_into(fdt_skel, fdt, size))); 75903d196b7SBharata B Rao g_free(fdt_skel); 76003d196b7SBharata B Rao 76103d196b7SBharata B Rao /* Fixup cpu nodes */ 76203d196b7SBharata B Rao _FDT((spapr_fixup_cpu_dt(fdt, spapr))); 76303d196b7SBharata B Rao 7646787d27bSMichael Roth if (spapr_dt_cas_updates(spapr, fdt, ov5_updates)) { 7656787d27bSMichael Roth return -1; 76603d196b7SBharata B Rao } 76703d196b7SBharata B Rao 76803d196b7SBharata B Rao /* Pack resulting tree */ 76903d196b7SBharata B Rao _FDT((fdt_pack(fdt))); 77003d196b7SBharata B Rao 77103d196b7SBharata B Rao if (fdt_totalsize(fdt) + sizeof(hdr) > size) { 77203d196b7SBharata B Rao trace_spapr_cas_failed(size); 77303d196b7SBharata B Rao return -1; 77403d196b7SBharata B Rao } 77503d196b7SBharata B Rao 77603d196b7SBharata B Rao cpu_physical_memory_write(addr, &hdr, sizeof(hdr)); 77703d196b7SBharata B Rao cpu_physical_memory_write(addr + sizeof(hdr), fdt, fdt_totalsize(fdt)); 77803d196b7SBharata B Rao trace_spapr_cas_continue(fdt_totalsize(fdt) + sizeof(hdr)); 77903d196b7SBharata B Rao g_free(fdt); 78003d196b7SBharata B Rao 78103d196b7SBharata B Rao return 0; 78203d196b7SBharata B Rao } 78303d196b7SBharata B Rao 7843f5dabceSDavid Gibson static void spapr_dt_rtas(sPAPRMachineState *spapr, void *fdt) 7853f5dabceSDavid Gibson { 7863f5dabceSDavid Gibson int rtas; 7873f5dabceSDavid Gibson GString *hypertas = g_string_sized_new(256); 7883f5dabceSDavid Gibson GString *qemu_hypertas = g_string_sized_new(256); 7893f5dabceSDavid Gibson uint32_t refpoints[] = { cpu_to_be32(0x4), cpu_to_be32(0x4) }; 7903f5dabceSDavid Gibson uint64_t max_hotplug_addr = spapr->hotplug_memory.base + 7913f5dabceSDavid Gibson memory_region_size(&spapr->hotplug_memory.mr); 7923f5dabceSDavid Gibson uint32_t lrdr_capacity[] = { 7933f5dabceSDavid Gibson cpu_to_be32(max_hotplug_addr >> 32), 7943f5dabceSDavid Gibson cpu_to_be32(max_hotplug_addr & 0xffffffff), 7953f5dabceSDavid Gibson 0, cpu_to_be32(SPAPR_MEMORY_BLOCK_SIZE), 7963f5dabceSDavid Gibson cpu_to_be32(max_cpus / smp_threads), 7973f5dabceSDavid Gibson }; 7983f5dabceSDavid Gibson 7993f5dabceSDavid Gibson _FDT(rtas = fdt_add_subnode(fdt, 0, "rtas")); 8003f5dabceSDavid Gibson 8013f5dabceSDavid Gibson /* hypertas */ 8023f5dabceSDavid Gibson add_str(hypertas, "hcall-pft"); 8033f5dabceSDavid Gibson add_str(hypertas, "hcall-term"); 8043f5dabceSDavid Gibson add_str(hypertas, "hcall-dabr"); 8053f5dabceSDavid Gibson add_str(hypertas, "hcall-interrupt"); 8063f5dabceSDavid Gibson add_str(hypertas, "hcall-tce"); 8073f5dabceSDavid Gibson add_str(hypertas, "hcall-vio"); 8083f5dabceSDavid Gibson add_str(hypertas, "hcall-splpar"); 8093f5dabceSDavid Gibson add_str(hypertas, "hcall-bulk"); 8103f5dabceSDavid Gibson add_str(hypertas, "hcall-set-mode"); 8113f5dabceSDavid Gibson add_str(hypertas, "hcall-sprg0"); 8123f5dabceSDavid Gibson add_str(hypertas, "hcall-copy"); 8133f5dabceSDavid Gibson add_str(hypertas, "hcall-debug"); 8143f5dabceSDavid Gibson add_str(qemu_hypertas, "hcall-memop1"); 8153f5dabceSDavid Gibson 8163f5dabceSDavid Gibson if (!kvm_enabled() || kvmppc_spapr_use_multitce()) { 8173f5dabceSDavid Gibson add_str(hypertas, "hcall-multi-tce"); 8183f5dabceSDavid Gibson } 8193f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,hypertas-functions", 8203f5dabceSDavid Gibson hypertas->str, hypertas->len)); 8213f5dabceSDavid Gibson g_string_free(hypertas, TRUE); 8223f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "qemu,hypertas-functions", 8233f5dabceSDavid Gibson qemu_hypertas->str, qemu_hypertas->len)); 8243f5dabceSDavid Gibson g_string_free(qemu_hypertas, TRUE); 8253f5dabceSDavid Gibson 8263f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,associativity-reference-points", 8273f5dabceSDavid Gibson refpoints, sizeof(refpoints))); 8283f5dabceSDavid Gibson 8293f5dabceSDavid Gibson _FDT(fdt_setprop_cell(fdt, rtas, "rtas-error-log-max", 8303f5dabceSDavid Gibson RTAS_ERROR_LOG_MAX)); 8313f5dabceSDavid Gibson _FDT(fdt_setprop_cell(fdt, rtas, "rtas-event-scan-rate", 8323f5dabceSDavid Gibson RTAS_EVENT_SCAN_RATE)); 8333f5dabceSDavid Gibson 8343f5dabceSDavid Gibson if (msi_nonbroken) { 8353f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,change-msix-capable", NULL, 0)); 8363f5dabceSDavid Gibson } 8373f5dabceSDavid Gibson 8383f5dabceSDavid Gibson /* 8393f5dabceSDavid Gibson * According to PAPR, rtas ibm,os-term does not guarantee a return 8403f5dabceSDavid Gibson * back to the guest cpu. 8413f5dabceSDavid Gibson * 8423f5dabceSDavid Gibson * While an additional ibm,extended-os-term property indicates 8433f5dabceSDavid Gibson * that rtas call return will always occur. Set this property. 8443f5dabceSDavid Gibson */ 8453f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,extended-os-term", NULL, 0)); 8463f5dabceSDavid Gibson 8473f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,lrdr-capacity", 8483f5dabceSDavid Gibson lrdr_capacity, sizeof(lrdr_capacity))); 8493f5dabceSDavid Gibson 8503f5dabceSDavid Gibson spapr_dt_rtas_tokens(fdt, rtas); 8513f5dabceSDavid Gibson } 8523f5dabceSDavid Gibson 8539fb4541fSSam Bobroff /* Prepare ibm,arch-vec-5-platform-support, which indicates the MMU features 8549fb4541fSSam Bobroff * that the guest may request and thus the valid values for bytes 24..26 of 8559fb4541fSSam Bobroff * option vector 5: */ 8569fb4541fSSam Bobroff static void spapr_dt_ov5_platform_support(void *fdt, int chosen) 8579fb4541fSSam Bobroff { 8589fb4541fSSam Bobroff char val[2 * 3] = { 8599fb4541fSSam Bobroff 24, 0x00, /* Hash/Radix, filled in below. */ 8609fb4541fSSam Bobroff 25, 0x00, /* Hash options: Segment Tables == no, GTSE == no. */ 8619fb4541fSSam Bobroff 26, 0x40, /* Radix options: GTSE == yes. */ 8629fb4541fSSam Bobroff }; 8639fb4541fSSam Bobroff 8649fb4541fSSam Bobroff if (kvm_enabled()) { 8659fb4541fSSam Bobroff if (kvmppc_has_cap_mmu_radix() && kvmppc_has_cap_mmu_hash_v3()) { 8669fb4541fSSam Bobroff val[1] = 0x80; /* OV5_MMU_BOTH */ 8679fb4541fSSam Bobroff } else if (kvmppc_has_cap_mmu_radix()) { 8689fb4541fSSam Bobroff val[1] = 0x40; /* OV5_MMU_RADIX_300 */ 8699fb4541fSSam Bobroff } else { 8709fb4541fSSam Bobroff val[1] = 0x00; /* Hash */ 8719fb4541fSSam Bobroff } 8729fb4541fSSam Bobroff } else { 8739fb4541fSSam Bobroff /* TODO: TCG case, hash */ 8749fb4541fSSam Bobroff val[1] = 0x00; 8759fb4541fSSam Bobroff } 8769fb4541fSSam Bobroff _FDT(fdt_setprop(fdt, chosen, "ibm,arch-vec-5-platform-support", 8779fb4541fSSam Bobroff val, sizeof(val))); 8789fb4541fSSam Bobroff } 8799fb4541fSSam Bobroff 8807c866c6aSDavid Gibson static void spapr_dt_chosen(sPAPRMachineState *spapr, void *fdt) 8817c866c6aSDavid Gibson { 8827c866c6aSDavid Gibson MachineState *machine = MACHINE(spapr); 8837c866c6aSDavid Gibson int chosen; 8847c866c6aSDavid Gibson const char *boot_device = machine->boot_order; 8857c866c6aSDavid Gibson char *stdout_path = spapr_vio_stdout_path(spapr->vio_bus); 8867c866c6aSDavid Gibson size_t cb = 0; 8877c866c6aSDavid Gibson char *bootlist = get_boot_devices_list(&cb, true); 8887c866c6aSDavid Gibson 8897c866c6aSDavid Gibson _FDT(chosen = fdt_add_subnode(fdt, 0, "chosen")); 8907c866c6aSDavid Gibson 8917c866c6aSDavid Gibson _FDT(fdt_setprop_string(fdt, chosen, "bootargs", machine->kernel_cmdline)); 8927c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "linux,initrd-start", 8937c866c6aSDavid Gibson spapr->initrd_base)); 8947c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "linux,initrd-end", 8957c866c6aSDavid Gibson spapr->initrd_base + spapr->initrd_size)); 8967c866c6aSDavid Gibson 8977c866c6aSDavid Gibson if (spapr->kernel_size) { 8987c866c6aSDavid Gibson uint64_t kprop[2] = { cpu_to_be64(KERNEL_LOAD_ADDR), 8997c866c6aSDavid Gibson cpu_to_be64(spapr->kernel_size) }; 9007c866c6aSDavid Gibson 9017c866c6aSDavid Gibson _FDT(fdt_setprop(fdt, chosen, "qemu,boot-kernel", 9027c866c6aSDavid Gibson &kprop, sizeof(kprop))); 9037c866c6aSDavid Gibson if (spapr->kernel_le) { 9047c866c6aSDavid Gibson _FDT(fdt_setprop(fdt, chosen, "qemu,boot-kernel-le", NULL, 0)); 9057c866c6aSDavid Gibson } 9067c866c6aSDavid Gibson } 9077c866c6aSDavid Gibson if (boot_menu) { 9087c866c6aSDavid Gibson _FDT((fdt_setprop_cell(fdt, chosen, "qemu,boot-menu", boot_menu))); 9097c866c6aSDavid Gibson } 9107c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "qemu,graphic-width", graphic_width)); 9117c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "qemu,graphic-height", graphic_height)); 9127c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "qemu,graphic-depth", graphic_depth)); 9137c866c6aSDavid Gibson 9147c866c6aSDavid Gibson if (cb && bootlist) { 9157c866c6aSDavid Gibson int i; 9167c866c6aSDavid Gibson 9177c866c6aSDavid Gibson for (i = 0; i < cb; i++) { 9187c866c6aSDavid Gibson if (bootlist[i] == '\n') { 9197c866c6aSDavid Gibson bootlist[i] = ' '; 9207c866c6aSDavid Gibson } 9217c866c6aSDavid Gibson } 9227c866c6aSDavid Gibson _FDT(fdt_setprop_string(fdt, chosen, "qemu,boot-list", bootlist)); 9237c866c6aSDavid Gibson } 9247c866c6aSDavid Gibson 9257c866c6aSDavid Gibson if (boot_device && strlen(boot_device)) { 9267c866c6aSDavid Gibson _FDT(fdt_setprop_string(fdt, chosen, "qemu,boot-device", boot_device)); 9277c866c6aSDavid Gibson } 9287c866c6aSDavid Gibson 9297c866c6aSDavid Gibson if (!spapr->has_graphics && stdout_path) { 9307c866c6aSDavid Gibson _FDT(fdt_setprop_string(fdt, chosen, "linux,stdout-path", stdout_path)); 9317c866c6aSDavid Gibson } 9327c866c6aSDavid Gibson 9339fb4541fSSam Bobroff spapr_dt_ov5_platform_support(fdt, chosen); 9349fb4541fSSam Bobroff 9357c866c6aSDavid Gibson g_free(stdout_path); 9367c866c6aSDavid Gibson g_free(bootlist); 9377c866c6aSDavid Gibson } 9387c866c6aSDavid Gibson 939fca5f2dcSDavid Gibson static void spapr_dt_hypervisor(sPAPRMachineState *spapr, void *fdt) 940fca5f2dcSDavid Gibson { 941fca5f2dcSDavid Gibson /* The /hypervisor node isn't in PAPR - this is a hack to allow PR 942fca5f2dcSDavid Gibson * KVM to work under pHyp with some guest co-operation */ 943fca5f2dcSDavid Gibson int hypervisor; 944fca5f2dcSDavid Gibson uint8_t hypercall[16]; 945fca5f2dcSDavid Gibson 946fca5f2dcSDavid Gibson _FDT(hypervisor = fdt_add_subnode(fdt, 0, "hypervisor")); 947fca5f2dcSDavid Gibson /* indicate KVM hypercall interface */ 948fca5f2dcSDavid Gibson _FDT(fdt_setprop_string(fdt, hypervisor, "compatible", "linux,kvm")); 949fca5f2dcSDavid Gibson if (kvmppc_has_cap_fixup_hcalls()) { 950fca5f2dcSDavid Gibson /* 951fca5f2dcSDavid Gibson * Older KVM versions with older guest kernels were broken 952fca5f2dcSDavid Gibson * with the magic page, don't allow the guest to map it. 953fca5f2dcSDavid Gibson */ 954fca5f2dcSDavid Gibson if (!kvmppc_get_hypercall(first_cpu->env_ptr, hypercall, 955fca5f2dcSDavid Gibson sizeof(hypercall))) { 956fca5f2dcSDavid Gibson _FDT(fdt_setprop(fdt, hypervisor, "hcall-instructions", 957fca5f2dcSDavid Gibson hypercall, sizeof(hypercall))); 958fca5f2dcSDavid Gibson } 959fca5f2dcSDavid Gibson } 960fca5f2dcSDavid Gibson } 961fca5f2dcSDavid Gibson 962997b6cfcSDavid Gibson static void *spapr_build_fdt(sPAPRMachineState *spapr, 96353018216SPaolo Bonzini hwaddr rtas_addr, 96453018216SPaolo Bonzini hwaddr rtas_size) 96553018216SPaolo Bonzini { 9665b2128d2SAlexander Graf MachineState *machine = MACHINE(qdev_get_machine()); 9673c0c47e3SDavid Gibson MachineClass *mc = MACHINE_GET_CLASS(machine); 968c20d332aSBharata B Rao sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(machine); 9697c866c6aSDavid Gibson int ret; 97053018216SPaolo Bonzini void *fdt; 97153018216SPaolo Bonzini sPAPRPHBState *phb; 972398a0bd5SDavid Gibson char *buf; 97371cd4dacSCédric Le Goater int smt = kvmppc_smt_threads(); 97453018216SPaolo Bonzini 975398a0bd5SDavid Gibson fdt = g_malloc0(FDT_MAX_SIZE); 976398a0bd5SDavid Gibson _FDT((fdt_create_empty_tree(fdt, FDT_MAX_SIZE))); 97753018216SPaolo Bonzini 978398a0bd5SDavid Gibson /* Root node */ 979398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "device_type", "chrp")); 980398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "model", "IBM pSeries (emulated by qemu)")); 981398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "compatible", "qemu,pseries")); 982398a0bd5SDavid Gibson 983398a0bd5SDavid Gibson /* 984398a0bd5SDavid Gibson * Add info to guest to indentify which host is it being run on 985398a0bd5SDavid Gibson * and what is the uuid of the guest 986398a0bd5SDavid Gibson */ 987398a0bd5SDavid Gibson if (kvmppc_get_host_model(&buf)) { 988398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "host-model", buf)); 989398a0bd5SDavid Gibson g_free(buf); 990398a0bd5SDavid Gibson } 991398a0bd5SDavid Gibson if (kvmppc_get_host_serial(&buf)) { 992398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "host-serial", buf)); 993398a0bd5SDavid Gibson g_free(buf); 994398a0bd5SDavid Gibson } 995398a0bd5SDavid Gibson 996398a0bd5SDavid Gibson buf = qemu_uuid_unparse_strdup(&qemu_uuid); 997398a0bd5SDavid Gibson 998398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "vm,uuid", buf)); 999398a0bd5SDavid Gibson if (qemu_uuid_set) { 1000398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "system-id", buf)); 1001398a0bd5SDavid Gibson } 1002398a0bd5SDavid Gibson g_free(buf); 1003398a0bd5SDavid Gibson 1004398a0bd5SDavid Gibson if (qemu_get_vm_name()) { 1005398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "ibm,partition-name", 1006398a0bd5SDavid Gibson qemu_get_vm_name())); 1007398a0bd5SDavid Gibson } 1008398a0bd5SDavid Gibson 1009398a0bd5SDavid Gibson _FDT(fdt_setprop_cell(fdt, 0, "#address-cells", 2)); 1010398a0bd5SDavid Gibson _FDT(fdt_setprop_cell(fdt, 0, "#size-cells", 2)); 101153018216SPaolo Bonzini 10129b9a1908SDavid Gibson /* /interrupt controller */ 101371cd4dacSCédric Le Goater spapr_dt_xics(DIV_ROUND_UP(max_cpus * smt, smp_threads), fdt, PHANDLE_XICP); 10149b9a1908SDavid Gibson 1015e8f986fcSBharata B Rao ret = spapr_populate_memory(spapr, fdt); 1016e8f986fcSBharata B Rao if (ret < 0) { 1017ce9863b7SCédric Le Goater error_report("couldn't setup memory nodes in fdt"); 1018e8f986fcSBharata B Rao exit(1); 101953018216SPaolo Bonzini } 102053018216SPaolo Bonzini 1021bf5a6696SDavid Gibson /* /vdevice */ 1022bf5a6696SDavid Gibson spapr_dt_vdevice(spapr->vio_bus, fdt); 102353018216SPaolo Bonzini 10244d9392beSThomas Huth if (object_resolve_path_type("", TYPE_SPAPR_RNG, NULL)) { 10254d9392beSThomas Huth ret = spapr_rng_populate_dt(fdt); 10264d9392beSThomas Huth if (ret < 0) { 1027ce9863b7SCédric Le Goater error_report("could not set up rng device in the fdt"); 10284d9392beSThomas Huth exit(1); 10294d9392beSThomas Huth } 10304d9392beSThomas Huth } 10314d9392beSThomas Huth 103253018216SPaolo Bonzini QLIST_FOREACH(phb, &spapr->phbs, list) { 103353018216SPaolo Bonzini ret = spapr_populate_pci_dt(phb, PHANDLE_XICP, fdt); 103453018216SPaolo Bonzini if (ret < 0) { 1035da34fed7SThomas Huth error_report("couldn't setup PCI devices in fdt"); 103653018216SPaolo Bonzini exit(1); 103753018216SPaolo Bonzini } 1038da34fed7SThomas Huth } 103953018216SPaolo Bonzini 10400da6f3feSBharata B Rao /* cpus */ 10410da6f3feSBharata B Rao spapr_populate_cpus_dt_node(fdt, spapr); 104253018216SPaolo Bonzini 1043c20d332aSBharata B Rao if (smc->dr_lmb_enabled) { 1044c20d332aSBharata B Rao _FDT(spapr_drc_populate_dt(fdt, 0, NULL, SPAPR_DR_CONNECTOR_TYPE_LMB)); 1045c20d332aSBharata B Rao } 1046c20d332aSBharata B Rao 1047c5514d0eSIgor Mammedov if (mc->has_hotpluggable_cpus) { 1048af81cf32SBharata B Rao int offset = fdt_path_offset(fdt, "/cpus"); 1049af81cf32SBharata B Rao ret = spapr_drc_populate_dt(fdt, offset, NULL, 1050af81cf32SBharata B Rao SPAPR_DR_CONNECTOR_TYPE_CPU); 1051af81cf32SBharata B Rao if (ret < 0) { 1052af81cf32SBharata B Rao error_report("Couldn't set up CPU DR device tree properties"); 1053af81cf32SBharata B Rao exit(1); 1054af81cf32SBharata B Rao } 1055af81cf32SBharata B Rao } 1056af81cf32SBharata B Rao 1057ffb1e275SDavid Gibson /* /event-sources */ 1058ffbb1705SMichael Roth spapr_dt_events(spapr, fdt); 1059ffb1e275SDavid Gibson 10603f5dabceSDavid Gibson /* /rtas */ 10613f5dabceSDavid Gibson spapr_dt_rtas(spapr, fdt); 10623f5dabceSDavid Gibson 10637c866c6aSDavid Gibson /* /chosen */ 10647c866c6aSDavid Gibson spapr_dt_chosen(spapr, fdt); 1065cf6e5223SDavid Gibson 1066fca5f2dcSDavid Gibson /* /hypervisor */ 1067fca5f2dcSDavid Gibson if (kvm_enabled()) { 1068fca5f2dcSDavid Gibson spapr_dt_hypervisor(spapr, fdt); 1069fca5f2dcSDavid Gibson } 1070fca5f2dcSDavid Gibson 1071cf6e5223SDavid Gibson /* Build memory reserve map */ 1072cf6e5223SDavid Gibson if (spapr->kernel_size) { 1073cf6e5223SDavid Gibson _FDT((fdt_add_mem_rsv(fdt, KERNEL_LOAD_ADDR, spapr->kernel_size))); 1074cf6e5223SDavid Gibson } 1075cf6e5223SDavid Gibson if (spapr->initrd_size) { 1076cf6e5223SDavid Gibson _FDT((fdt_add_mem_rsv(fdt, spapr->initrd_base, spapr->initrd_size))); 1077cf6e5223SDavid Gibson } 1078cf6e5223SDavid Gibson 10796787d27bSMichael Roth /* ibm,client-architecture-support updates */ 10806787d27bSMichael Roth ret = spapr_dt_cas_updates(spapr, fdt, spapr->ov5_cas); 10816787d27bSMichael Roth if (ret < 0) { 10826787d27bSMichael Roth error_report("couldn't setup CAS properties fdt"); 10836787d27bSMichael Roth exit(1); 10846787d27bSMichael Roth } 10856787d27bSMichael Roth 1086997b6cfcSDavid Gibson return fdt; 108753018216SPaolo Bonzini } 108853018216SPaolo Bonzini 108953018216SPaolo Bonzini static uint64_t translate_kernel_address(void *opaque, uint64_t addr) 109053018216SPaolo Bonzini { 109153018216SPaolo Bonzini return (addr & 0x0fffffff) + KERNEL_LOAD_ADDR; 109253018216SPaolo Bonzini } 109353018216SPaolo Bonzini 10941d1be34dSDavid Gibson static void emulate_spapr_hypercall(PPCVirtualHypervisor *vhyp, 10951d1be34dSDavid Gibson PowerPCCPU *cpu) 109653018216SPaolo Bonzini { 109753018216SPaolo Bonzini CPUPPCState *env = &cpu->env; 109853018216SPaolo Bonzini 10998d04fb55SJan Kiszka /* The TCG path should also be holding the BQL at this point */ 11008d04fb55SJan Kiszka g_assert(qemu_mutex_iothread_locked()); 11018d04fb55SJan Kiszka 110253018216SPaolo Bonzini if (msr_pr) { 110353018216SPaolo Bonzini hcall_dprintf("Hypercall made with MSR[PR]=1\n"); 110453018216SPaolo Bonzini env->gpr[3] = H_PRIVILEGE; 110553018216SPaolo Bonzini } else { 110653018216SPaolo Bonzini env->gpr[3] = spapr_hypercall(cpu, env->gpr[3], &env->gpr[4]); 110753018216SPaolo Bonzini } 110853018216SPaolo Bonzini } 110953018216SPaolo Bonzini 11109861bb3eSSuraj Jitindar Singh static uint64_t spapr_get_patbe(PPCVirtualHypervisor *vhyp) 11119861bb3eSSuraj Jitindar Singh { 11129861bb3eSSuraj Jitindar Singh sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 11139861bb3eSSuraj Jitindar Singh 11149861bb3eSSuraj Jitindar Singh return spapr->patb_entry; 11159861bb3eSSuraj Jitindar Singh } 11169861bb3eSSuraj Jitindar Singh 1117e6b8fd24SSamuel Mendoza-Jonas #define HPTE(_table, _i) (void *)(((uint64_t *)(_table)) + ((_i) * 2)) 1118e6b8fd24SSamuel Mendoza-Jonas #define HPTE_VALID(_hpte) (tswap64(*((uint64_t *)(_hpte))) & HPTE64_V_VALID) 1119e6b8fd24SSamuel Mendoza-Jonas #define HPTE_DIRTY(_hpte) (tswap64(*((uint64_t *)(_hpte))) & HPTE64_V_HPTE_DIRTY) 1120e6b8fd24SSamuel Mendoza-Jonas #define CLEAN_HPTE(_hpte) ((*(uint64_t *)(_hpte)) &= tswap64(~HPTE64_V_HPTE_DIRTY)) 1121e6b8fd24SSamuel Mendoza-Jonas #define DIRTY_HPTE(_hpte) ((*(uint64_t *)(_hpte)) |= tswap64(HPTE64_V_HPTE_DIRTY)) 1122e6b8fd24SSamuel Mendoza-Jonas 1123715c5407SDavid Gibson /* 1124715c5407SDavid Gibson * Get the fd to access the kernel htab, re-opening it if necessary 1125715c5407SDavid Gibson */ 1126715c5407SDavid Gibson static int get_htab_fd(sPAPRMachineState *spapr) 1127715c5407SDavid Gibson { 1128715c5407SDavid Gibson if (spapr->htab_fd >= 0) { 1129715c5407SDavid Gibson return spapr->htab_fd; 1130715c5407SDavid Gibson } 1131715c5407SDavid Gibson 1132715c5407SDavid Gibson spapr->htab_fd = kvmppc_get_htab_fd(false); 1133715c5407SDavid Gibson if (spapr->htab_fd < 0) { 1134715c5407SDavid Gibson error_report("Unable to open fd for reading hash table from KVM: %s", 1135715c5407SDavid Gibson strerror(errno)); 1136715c5407SDavid Gibson } 1137715c5407SDavid Gibson 1138715c5407SDavid Gibson return spapr->htab_fd; 1139715c5407SDavid Gibson } 1140715c5407SDavid Gibson 1141b4db5413SSuraj Jitindar Singh void close_htab_fd(sPAPRMachineState *spapr) 1142715c5407SDavid Gibson { 1143715c5407SDavid Gibson if (spapr->htab_fd >= 0) { 1144715c5407SDavid Gibson close(spapr->htab_fd); 1145715c5407SDavid Gibson } 1146715c5407SDavid Gibson spapr->htab_fd = -1; 1147715c5407SDavid Gibson } 1148715c5407SDavid Gibson 1149e57ca75cSDavid Gibson static hwaddr spapr_hpt_mask(PPCVirtualHypervisor *vhyp) 1150e57ca75cSDavid Gibson { 1151e57ca75cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 1152e57ca75cSDavid Gibson 1153e57ca75cSDavid Gibson return HTAB_SIZE(spapr) / HASH_PTEG_SIZE_64 - 1; 1154e57ca75cSDavid Gibson } 1155e57ca75cSDavid Gibson 1156e57ca75cSDavid Gibson static const ppc_hash_pte64_t *spapr_map_hptes(PPCVirtualHypervisor *vhyp, 1157e57ca75cSDavid Gibson hwaddr ptex, int n) 1158e57ca75cSDavid Gibson { 1159e57ca75cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 1160e57ca75cSDavid Gibson hwaddr pte_offset = ptex * HASH_PTE_SIZE_64; 1161e57ca75cSDavid Gibson 1162e57ca75cSDavid Gibson if (!spapr->htab) { 1163e57ca75cSDavid Gibson /* 1164e57ca75cSDavid Gibson * HTAB is controlled by KVM. Fetch into temporary buffer 1165e57ca75cSDavid Gibson */ 1166e57ca75cSDavid Gibson ppc_hash_pte64_t *hptes = g_malloc(n * HASH_PTE_SIZE_64); 1167e57ca75cSDavid Gibson kvmppc_read_hptes(hptes, ptex, n); 1168e57ca75cSDavid Gibson return hptes; 1169e57ca75cSDavid Gibson } 1170e57ca75cSDavid Gibson 1171e57ca75cSDavid Gibson /* 1172e57ca75cSDavid Gibson * HTAB is controlled by QEMU. Just point to the internally 1173e57ca75cSDavid Gibson * accessible PTEG. 1174e57ca75cSDavid Gibson */ 1175e57ca75cSDavid Gibson return (const ppc_hash_pte64_t *)(spapr->htab + pte_offset); 1176e57ca75cSDavid Gibson } 1177e57ca75cSDavid Gibson 1178e57ca75cSDavid Gibson static void spapr_unmap_hptes(PPCVirtualHypervisor *vhyp, 1179e57ca75cSDavid Gibson const ppc_hash_pte64_t *hptes, 1180e57ca75cSDavid Gibson hwaddr ptex, int n) 1181e57ca75cSDavid Gibson { 1182e57ca75cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 1183e57ca75cSDavid Gibson 1184e57ca75cSDavid Gibson if (!spapr->htab) { 1185e57ca75cSDavid Gibson g_free((void *)hptes); 1186e57ca75cSDavid Gibson } 1187e57ca75cSDavid Gibson 1188e57ca75cSDavid Gibson /* Nothing to do for qemu managed HPT */ 1189e57ca75cSDavid Gibson } 1190e57ca75cSDavid Gibson 1191e57ca75cSDavid Gibson static void spapr_store_hpte(PPCVirtualHypervisor *vhyp, hwaddr ptex, 1192e57ca75cSDavid Gibson uint64_t pte0, uint64_t pte1) 1193e57ca75cSDavid Gibson { 1194e57ca75cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 1195e57ca75cSDavid Gibson hwaddr offset = ptex * HASH_PTE_SIZE_64; 1196e57ca75cSDavid Gibson 1197e57ca75cSDavid Gibson if (!spapr->htab) { 1198e57ca75cSDavid Gibson kvmppc_write_hpte(ptex, pte0, pte1); 1199e57ca75cSDavid Gibson } else { 1200e57ca75cSDavid Gibson stq_p(spapr->htab + offset, pte0); 1201e57ca75cSDavid Gibson stq_p(spapr->htab + offset + HASH_PTE_SIZE_64 / 2, pte1); 1202e57ca75cSDavid Gibson } 1203e57ca75cSDavid Gibson } 1204e57ca75cSDavid Gibson 12058dfe8e7fSDavid Gibson static int spapr_hpt_shift_for_ramsize(uint64_t ramsize) 12068dfe8e7fSDavid Gibson { 12078dfe8e7fSDavid Gibson int shift; 12088dfe8e7fSDavid Gibson 12098dfe8e7fSDavid Gibson /* We aim for a hash table of size 1/128 the size of RAM (rounded 12108dfe8e7fSDavid Gibson * up). The PAPR recommendation is actually 1/64 of RAM size, but 12118dfe8e7fSDavid Gibson * that's much more than is needed for Linux guests */ 12128dfe8e7fSDavid Gibson shift = ctz64(pow2ceil(ramsize)) - 7; 12138dfe8e7fSDavid Gibson shift = MAX(shift, 18); /* Minimum architected size */ 12148dfe8e7fSDavid Gibson shift = MIN(shift, 46); /* Maximum architected size */ 12158dfe8e7fSDavid Gibson return shift; 12168dfe8e7fSDavid Gibson } 12178dfe8e7fSDavid Gibson 1218c5f54f3eSDavid Gibson static void spapr_reallocate_hpt(sPAPRMachineState *spapr, int shift, 1219c5f54f3eSDavid Gibson Error **errp) 122053018216SPaolo Bonzini { 1221c5f54f3eSDavid Gibson long rc; 122253018216SPaolo Bonzini 1223c5f54f3eSDavid Gibson /* Clean up any HPT info from a previous boot */ 1224c5f54f3eSDavid Gibson g_free(spapr->htab); 1225c5f54f3eSDavid Gibson spapr->htab = NULL; 1226c5f54f3eSDavid Gibson spapr->htab_shift = 0; 1227c5f54f3eSDavid Gibson close_htab_fd(spapr); 122853018216SPaolo Bonzini 1229c5f54f3eSDavid Gibson rc = kvmppc_reset_htab(shift); 1230c5f54f3eSDavid Gibson if (rc < 0) { 1231c5f54f3eSDavid Gibson /* kernel-side HPT needed, but couldn't allocate one */ 1232c5f54f3eSDavid Gibson error_setg_errno(errp, errno, 1233c5f54f3eSDavid Gibson "Failed to allocate KVM HPT of order %d (try smaller maxmem?)", 1234c5f54f3eSDavid Gibson shift); 1235c5f54f3eSDavid Gibson /* This is almost certainly fatal, but if the caller really 1236c5f54f3eSDavid Gibson * wants to carry on with shift == 0, it's welcome to try */ 1237c5f54f3eSDavid Gibson } else if (rc > 0) { 1238c5f54f3eSDavid Gibson /* kernel-side HPT allocated */ 1239c5f54f3eSDavid Gibson if (rc != shift) { 1240c5f54f3eSDavid Gibson error_setg(errp, 1241c5f54f3eSDavid Gibson "Requested order %d HPT, but kernel allocated order %ld (try smaller maxmem?)", 1242c5f54f3eSDavid Gibson shift, rc); 12437735fedaSBharata B Rao } 12447735fedaSBharata B Rao 124553018216SPaolo Bonzini spapr->htab_shift = shift; 1246c18ad9a5SDavid Gibson spapr->htab = NULL; 1247b817772aSBharata B Rao } else { 1248c5f54f3eSDavid Gibson /* kernel-side HPT not needed, allocate in userspace instead */ 1249c5f54f3eSDavid Gibson size_t size = 1ULL << shift; 1250c5f54f3eSDavid Gibson int i; 125101a57972SSamuel Mendoza-Jonas 1252c5f54f3eSDavid Gibson spapr->htab = qemu_memalign(size, size); 1253c5f54f3eSDavid Gibson if (!spapr->htab) { 1254c5f54f3eSDavid Gibson error_setg_errno(errp, errno, 1255c5f54f3eSDavid Gibson "Could not allocate HPT of order %d", shift); 1256c5f54f3eSDavid Gibson return; 1257b817772aSBharata B Rao } 1258b817772aSBharata B Rao 1259c5f54f3eSDavid Gibson memset(spapr->htab, 0, size); 1260c5f54f3eSDavid Gibson spapr->htab_shift = shift; 1261b817772aSBharata B Rao 1262c5f54f3eSDavid Gibson for (i = 0; i < size / HASH_PTE_SIZE_64; i++) { 1263c5f54f3eSDavid Gibson DIRTY_HPTE(HPTE(spapr->htab, i)); 12647735fedaSBharata B Rao } 126553018216SPaolo Bonzini } 126653018216SPaolo Bonzini } 126753018216SPaolo Bonzini 1268b4db5413SSuraj Jitindar Singh void spapr_setup_hpt_and_vrma(sPAPRMachineState *spapr) 1269b4db5413SSuraj Jitindar Singh { 1270b4db5413SSuraj Jitindar Singh spapr_reallocate_hpt(spapr, 1271b4db5413SSuraj Jitindar Singh spapr_hpt_shift_for_ramsize(MACHINE(spapr)->maxram_size), 1272b4db5413SSuraj Jitindar Singh &error_fatal); 1273b4db5413SSuraj Jitindar Singh if (spapr->vrma_adjust) { 1274b4db5413SSuraj Jitindar Singh spapr->rma_size = kvmppc_rma_size(spapr_node0_size(), 1275b4db5413SSuraj Jitindar Singh spapr->htab_shift); 1276b4db5413SSuraj Jitindar Singh } 1277b4db5413SSuraj Jitindar Singh /* We're setting up a hash table, so that means we're not radix */ 1278b4db5413SSuraj Jitindar Singh spapr->patb_entry = 0; 1279b4db5413SSuraj Jitindar Singh } 1280b4db5413SSuraj Jitindar Singh 12814f01a637SDavid Gibson static void find_unknown_sysbus_device(SysBusDevice *sbdev, void *opaque) 12829e3f9733SAlexander Graf { 12839e3f9733SAlexander Graf bool matched = false; 12849e3f9733SAlexander Graf 12859e3f9733SAlexander Graf if (object_dynamic_cast(OBJECT(sbdev), TYPE_SPAPR_PCI_HOST_BRIDGE)) { 12869e3f9733SAlexander Graf matched = true; 12879e3f9733SAlexander Graf } 12889e3f9733SAlexander Graf 12899e3f9733SAlexander Graf if (!matched) { 12909e3f9733SAlexander Graf error_report("Device %s is not supported by this machine yet.", 12919e3f9733SAlexander Graf qdev_fw_name(DEVICE(sbdev))); 12929e3f9733SAlexander Graf exit(1); 12939e3f9733SAlexander Graf } 12949e3f9733SAlexander Graf } 12959e3f9733SAlexander Graf 129653018216SPaolo Bonzini static void ppc_spapr_reset(void) 129753018216SPaolo Bonzini { 1298c5f54f3eSDavid Gibson MachineState *machine = MACHINE(qdev_get_machine()); 1299c5f54f3eSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(machine); 1300182735efSAndreas Färber PowerPCCPU *first_ppc_cpu; 1301b7d1f77aSBenjamin Herrenschmidt uint32_t rtas_limit; 1302cae172abSDavid Gibson hwaddr rtas_addr, fdt_addr; 1303997b6cfcSDavid Gibson void *fdt; 1304997b6cfcSDavid Gibson int rc; 1305259186a7SAndreas Färber 13069e3f9733SAlexander Graf /* Check for unknown sysbus devices */ 13079e3f9733SAlexander Graf foreach_dynamic_sysbus_device(find_unknown_sysbus_device, NULL); 13089e3f9733SAlexander Graf 1309b4db5413SSuraj Jitindar Singh if (kvm_enabled() && kvmppc_has_cap_mmu_radix()) { 1310b4db5413SSuraj Jitindar Singh /* If using KVM with radix mode available, VCPUs can be started 1311b4db5413SSuraj Jitindar Singh * without a HPT because KVM will start them in radix mode. 1312b4db5413SSuraj Jitindar Singh * Set the GR bit in PATB so that we know there is no HPT. */ 1313b4db5413SSuraj Jitindar Singh spapr->patb_entry = PATBE1_GR; 1314b4db5413SSuraj Jitindar Singh } else { 13159861bb3eSSuraj Jitindar Singh spapr->patb_entry = 0; 1316b4db5413SSuraj Jitindar Singh spapr_setup_hpt_and_vrma(spapr); 1317c5f54f3eSDavid Gibson } 131853018216SPaolo Bonzini 131953018216SPaolo Bonzini qemu_devices_reset(); 132053018216SPaolo Bonzini 1321b7d1f77aSBenjamin Herrenschmidt /* 1322b7d1f77aSBenjamin Herrenschmidt * We place the device tree and RTAS just below either the top of the RMA, 1323b7d1f77aSBenjamin Herrenschmidt * or just below 2GB, whichever is lowere, so that it can be 1324b7d1f77aSBenjamin Herrenschmidt * processed with 32-bit real mode code if necessary 1325b7d1f77aSBenjamin Herrenschmidt */ 1326b7d1f77aSBenjamin Herrenschmidt rtas_limit = MIN(spapr->rma_size, RTAS_MAX_ADDR); 1327cae172abSDavid Gibson rtas_addr = rtas_limit - RTAS_MAX_SIZE; 1328cae172abSDavid Gibson fdt_addr = rtas_addr - FDT_MAX_SIZE; 1329b7d1f77aSBenjamin Herrenschmidt 13306787d27bSMichael Roth /* if this reset wasn't generated by CAS, we should reset our 13316787d27bSMichael Roth * negotiated options and start from scratch */ 13326787d27bSMichael Roth if (!spapr->cas_reboot) { 13336787d27bSMichael Roth spapr_ovec_cleanup(spapr->ov5_cas); 13346787d27bSMichael Roth spapr->ov5_cas = spapr_ovec_new(); 13356787d27bSMichael Roth } 13366787d27bSMichael Roth 1337cae172abSDavid Gibson fdt = spapr_build_fdt(spapr, rtas_addr, spapr->rtas_size); 133853018216SPaolo Bonzini 13392cac78c1SDavid Gibson spapr_load_rtas(spapr, fdt, rtas_addr); 1340b7d1f77aSBenjamin Herrenschmidt 1341997b6cfcSDavid Gibson rc = fdt_pack(fdt); 1342997b6cfcSDavid Gibson 1343997b6cfcSDavid Gibson /* Should only fail if we've built a corrupted tree */ 1344997b6cfcSDavid Gibson assert(rc == 0); 1345997b6cfcSDavid Gibson 1346997b6cfcSDavid Gibson if (fdt_totalsize(fdt) > FDT_MAX_SIZE) { 1347997b6cfcSDavid Gibson error_report("FDT too big ! 0x%x bytes (max is 0x%x)", 1348997b6cfcSDavid Gibson fdt_totalsize(fdt), FDT_MAX_SIZE); 1349997b6cfcSDavid Gibson exit(1); 1350997b6cfcSDavid Gibson } 1351997b6cfcSDavid Gibson 1352997b6cfcSDavid Gibson /* Load the fdt */ 1353997b6cfcSDavid Gibson qemu_fdt_dumpdtb(fdt, fdt_totalsize(fdt)); 1354cae172abSDavid Gibson cpu_physical_memory_write(fdt_addr, fdt, fdt_totalsize(fdt)); 1355997b6cfcSDavid Gibson g_free(fdt); 1356997b6cfcSDavid Gibson 135753018216SPaolo Bonzini /* Set up the entry state */ 1358182735efSAndreas Färber first_ppc_cpu = POWERPC_CPU(first_cpu); 1359cae172abSDavid Gibson first_ppc_cpu->env.gpr[3] = fdt_addr; 1360182735efSAndreas Färber first_ppc_cpu->env.gpr[5] = 0; 1361182735efSAndreas Färber first_cpu->halted = 0; 13621b718907SDavid Gibson first_ppc_cpu->env.nip = SPAPR_ENTRY_POINT; 136353018216SPaolo Bonzini 13646787d27bSMichael Roth spapr->cas_reboot = false; 136553018216SPaolo Bonzini } 136653018216SPaolo Bonzini 136728e02042SDavid Gibson static void spapr_create_nvram(sPAPRMachineState *spapr) 136853018216SPaolo Bonzini { 13692ff3de68SMarkus Armbruster DeviceState *dev = qdev_create(&spapr->vio_bus->bus, "spapr-nvram"); 13703978b863SPaolo Bonzini DriveInfo *dinfo = drive_get(IF_PFLASH, 0, 0); 137153018216SPaolo Bonzini 13723978b863SPaolo Bonzini if (dinfo) { 13736231a6daSMarkus Armbruster qdev_prop_set_drive(dev, "drive", blk_by_legacy_dinfo(dinfo), 13746231a6daSMarkus Armbruster &error_fatal); 137553018216SPaolo Bonzini } 137653018216SPaolo Bonzini 137753018216SPaolo Bonzini qdev_init_nofail(dev); 137853018216SPaolo Bonzini 137953018216SPaolo Bonzini spapr->nvram = (struct sPAPRNVRAM *)dev; 138053018216SPaolo Bonzini } 138153018216SPaolo Bonzini 138228e02042SDavid Gibson static void spapr_rtc_create(sPAPRMachineState *spapr) 138328df36a1SDavid Gibson { 1384147ff807SCédric Le Goater object_initialize(&spapr->rtc, sizeof(spapr->rtc), TYPE_SPAPR_RTC); 1385147ff807SCédric Le Goater object_property_add_child(OBJECT(spapr), "rtc", OBJECT(&spapr->rtc), 1386147ff807SCédric Le Goater &error_fatal); 1387147ff807SCédric Le Goater object_property_set_bool(OBJECT(&spapr->rtc), true, "realized", 1388147ff807SCédric Le Goater &error_fatal); 1389147ff807SCédric Le Goater object_property_add_alias(OBJECT(spapr), "rtc-time", OBJECT(&spapr->rtc), 1390147ff807SCédric Le Goater "date", &error_fatal); 139128df36a1SDavid Gibson } 139228df36a1SDavid Gibson 139353018216SPaolo Bonzini /* Returns whether we want to use VGA or not */ 139414c6a894SDavid Gibson static bool spapr_vga_init(PCIBus *pci_bus, Error **errp) 139553018216SPaolo Bonzini { 139653018216SPaolo Bonzini switch (vga_interface_type) { 139753018216SPaolo Bonzini case VGA_NONE: 13987effdaa3SMark Wu return false; 13997effdaa3SMark Wu case VGA_DEVICE: 14007effdaa3SMark Wu return true; 140153018216SPaolo Bonzini case VGA_STD: 1402b798c190SBenjamin Herrenschmidt case VGA_VIRTIO: 140353018216SPaolo Bonzini return pci_vga_init(pci_bus) != NULL; 140453018216SPaolo Bonzini default: 140514c6a894SDavid Gibson error_setg(errp, 140614c6a894SDavid Gibson "Unsupported VGA mode, only -vga std or -vga virtio is supported"); 140714c6a894SDavid Gibson return false; 140853018216SPaolo Bonzini } 140953018216SPaolo Bonzini } 141053018216SPaolo Bonzini 1411880ae7deSDavid Gibson static int spapr_post_load(void *opaque, int version_id) 1412880ae7deSDavid Gibson { 141328e02042SDavid Gibson sPAPRMachineState *spapr = (sPAPRMachineState *)opaque; 1414880ae7deSDavid Gibson int err = 0; 1415880ae7deSDavid Gibson 1416a7ff1212SCédric Le Goater if (!object_dynamic_cast(OBJECT(spapr->ics), TYPE_ICS_KVM)) { 14175bc8d26dSCédric Le Goater CPUState *cs; 14185bc8d26dSCédric Le Goater CPU_FOREACH(cs) { 14195bc8d26dSCédric Le Goater PowerPCCPU *cpu = POWERPC_CPU(cs); 14205bc8d26dSCédric Le Goater icp_resend(ICP(cpu->intc)); 1421a7ff1212SCédric Le Goater } 1422a7ff1212SCédric Le Goater } 1423a7ff1212SCédric Le Goater 1424631b22eaSStefan Weil /* In earlier versions, there was no separate qdev for the PAPR 1425880ae7deSDavid Gibson * RTC, so the RTC offset was stored directly in sPAPREnvironment. 1426880ae7deSDavid Gibson * So when migrating from those versions, poke the incoming offset 1427880ae7deSDavid Gibson * value into the RTC device */ 1428880ae7deSDavid Gibson if (version_id < 3) { 1429147ff807SCédric Le Goater err = spapr_rtc_import_offset(&spapr->rtc, spapr->rtc_offset); 1430880ae7deSDavid Gibson } 1431880ae7deSDavid Gibson 1432880ae7deSDavid Gibson return err; 1433880ae7deSDavid Gibson } 1434880ae7deSDavid Gibson 1435880ae7deSDavid Gibson static bool version_before_3(void *opaque, int version_id) 1436880ae7deSDavid Gibson { 1437880ae7deSDavid Gibson return version_id < 3; 1438880ae7deSDavid Gibson } 1439880ae7deSDavid Gibson 144062ef3760SMichael Roth static bool spapr_ov5_cas_needed(void *opaque) 144162ef3760SMichael Roth { 144262ef3760SMichael Roth sPAPRMachineState *spapr = opaque; 144362ef3760SMichael Roth sPAPROptionVector *ov5_mask = spapr_ovec_new(); 144462ef3760SMichael Roth sPAPROptionVector *ov5_legacy = spapr_ovec_new(); 144562ef3760SMichael Roth sPAPROptionVector *ov5_removed = spapr_ovec_new(); 144662ef3760SMichael Roth bool cas_needed; 144762ef3760SMichael Roth 144862ef3760SMichael Roth /* Prior to the introduction of sPAPROptionVector, we had two option 144962ef3760SMichael Roth * vectors we dealt with: OV5_FORM1_AFFINITY, and OV5_DRCONF_MEMORY. 145062ef3760SMichael Roth * Both of these options encode machine topology into the device-tree 145162ef3760SMichael Roth * in such a way that the now-booted OS should still be able to interact 145262ef3760SMichael Roth * appropriately with QEMU regardless of what options were actually 145362ef3760SMichael Roth * negotiatied on the source side. 145462ef3760SMichael Roth * 145562ef3760SMichael Roth * As such, we can avoid migrating the CAS-negotiated options if these 145662ef3760SMichael Roth * are the only options available on the current machine/platform. 145762ef3760SMichael Roth * Since these are the only options available for pseries-2.7 and 145862ef3760SMichael Roth * earlier, this allows us to maintain old->new/new->old migration 145962ef3760SMichael Roth * compatibility. 146062ef3760SMichael Roth * 146162ef3760SMichael Roth * For QEMU 2.8+, there are additional CAS-negotiatable options available 146262ef3760SMichael Roth * via default pseries-2.8 machines and explicit command-line parameters. 146362ef3760SMichael Roth * Some of these options, like OV5_HP_EVT, *do* require QEMU to be aware 146462ef3760SMichael Roth * of the actual CAS-negotiated values to continue working properly. For 146562ef3760SMichael Roth * example, availability of memory unplug depends on knowing whether 146662ef3760SMichael Roth * OV5_HP_EVT was negotiated via CAS. 146762ef3760SMichael Roth * 146862ef3760SMichael Roth * Thus, for any cases where the set of available CAS-negotiatable 146962ef3760SMichael Roth * options extends beyond OV5_FORM1_AFFINITY and OV5_DRCONF_MEMORY, we 147062ef3760SMichael Roth * include the CAS-negotiated options in the migration stream. 147162ef3760SMichael Roth */ 147262ef3760SMichael Roth spapr_ovec_set(ov5_mask, OV5_FORM1_AFFINITY); 147362ef3760SMichael Roth spapr_ovec_set(ov5_mask, OV5_DRCONF_MEMORY); 147462ef3760SMichael Roth 147562ef3760SMichael Roth /* spapr_ovec_diff returns true if bits were removed. we avoid using 147662ef3760SMichael Roth * the mask itself since in the future it's possible "legacy" bits may be 147762ef3760SMichael Roth * removed via machine options, which could generate a false positive 147862ef3760SMichael Roth * that breaks migration. 147962ef3760SMichael Roth */ 148062ef3760SMichael Roth spapr_ovec_intersect(ov5_legacy, spapr->ov5, ov5_mask); 148162ef3760SMichael Roth cas_needed = spapr_ovec_diff(ov5_removed, spapr->ov5, ov5_legacy); 148262ef3760SMichael Roth 148362ef3760SMichael Roth spapr_ovec_cleanup(ov5_mask); 148462ef3760SMichael Roth spapr_ovec_cleanup(ov5_legacy); 148562ef3760SMichael Roth spapr_ovec_cleanup(ov5_removed); 148662ef3760SMichael Roth 148762ef3760SMichael Roth return cas_needed; 148862ef3760SMichael Roth } 148962ef3760SMichael Roth 149062ef3760SMichael Roth static const VMStateDescription vmstate_spapr_ov5_cas = { 149162ef3760SMichael Roth .name = "spapr_option_vector_ov5_cas", 149262ef3760SMichael Roth .version_id = 1, 149362ef3760SMichael Roth .minimum_version_id = 1, 149462ef3760SMichael Roth .needed = spapr_ov5_cas_needed, 149562ef3760SMichael Roth .fields = (VMStateField[]) { 149662ef3760SMichael Roth VMSTATE_STRUCT_POINTER_V(ov5_cas, sPAPRMachineState, 1, 149762ef3760SMichael Roth vmstate_spapr_ovec, sPAPROptionVector), 149862ef3760SMichael Roth VMSTATE_END_OF_LIST() 149962ef3760SMichael Roth }, 150062ef3760SMichael Roth }; 150162ef3760SMichael Roth 15029861bb3eSSuraj Jitindar Singh static bool spapr_patb_entry_needed(void *opaque) 15039861bb3eSSuraj Jitindar Singh { 15049861bb3eSSuraj Jitindar Singh sPAPRMachineState *spapr = opaque; 15059861bb3eSSuraj Jitindar Singh 15069861bb3eSSuraj Jitindar Singh return !!spapr->patb_entry; 15079861bb3eSSuraj Jitindar Singh } 15089861bb3eSSuraj Jitindar Singh 15099861bb3eSSuraj Jitindar Singh static const VMStateDescription vmstate_spapr_patb_entry = { 15109861bb3eSSuraj Jitindar Singh .name = "spapr_patb_entry", 15119861bb3eSSuraj Jitindar Singh .version_id = 1, 15129861bb3eSSuraj Jitindar Singh .minimum_version_id = 1, 15139861bb3eSSuraj Jitindar Singh .needed = spapr_patb_entry_needed, 15149861bb3eSSuraj Jitindar Singh .fields = (VMStateField[]) { 15159861bb3eSSuraj Jitindar Singh VMSTATE_UINT64(patb_entry, sPAPRMachineState), 15169861bb3eSSuraj Jitindar Singh VMSTATE_END_OF_LIST() 15179861bb3eSSuraj Jitindar Singh }, 15189861bb3eSSuraj Jitindar Singh }; 15199861bb3eSSuraj Jitindar Singh 15204be21d56SDavid Gibson static const VMStateDescription vmstate_spapr = { 15214be21d56SDavid Gibson .name = "spapr", 1522880ae7deSDavid Gibson .version_id = 3, 15234be21d56SDavid Gibson .minimum_version_id = 1, 1524880ae7deSDavid Gibson .post_load = spapr_post_load, 15254be21d56SDavid Gibson .fields = (VMStateField[]) { 1526880ae7deSDavid Gibson /* used to be @next_irq */ 1527880ae7deSDavid Gibson VMSTATE_UNUSED_BUFFER(version_before_3, 0, 4), 15284be21d56SDavid Gibson 15294be21d56SDavid Gibson /* RTC offset */ 153028e02042SDavid Gibson VMSTATE_UINT64_TEST(rtc_offset, sPAPRMachineState, version_before_3), 1531880ae7deSDavid Gibson 153228e02042SDavid Gibson VMSTATE_PPC_TIMEBASE_V(tb, sPAPRMachineState, 2), 15334be21d56SDavid Gibson VMSTATE_END_OF_LIST() 15344be21d56SDavid Gibson }, 153562ef3760SMichael Roth .subsections = (const VMStateDescription*[]) { 153662ef3760SMichael Roth &vmstate_spapr_ov5_cas, 15379861bb3eSSuraj Jitindar Singh &vmstate_spapr_patb_entry, 153862ef3760SMichael Roth NULL 153962ef3760SMichael Roth } 15404be21d56SDavid Gibson }; 15414be21d56SDavid Gibson 15424be21d56SDavid Gibson static int htab_save_setup(QEMUFile *f, void *opaque) 15434be21d56SDavid Gibson { 154428e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 15454be21d56SDavid Gibson 15464be21d56SDavid Gibson /* "Iteration" header */ 15474be21d56SDavid Gibson qemu_put_be32(f, spapr->htab_shift); 15484be21d56SDavid Gibson 1549e68cb8b4SAlexey Kardashevskiy if (spapr->htab) { 1550e68cb8b4SAlexey Kardashevskiy spapr->htab_save_index = 0; 1551e68cb8b4SAlexey Kardashevskiy spapr->htab_first_pass = true; 1552e68cb8b4SAlexey Kardashevskiy } else { 1553e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 15544be21d56SDavid Gibson } 15554be21d56SDavid Gibson 1556e68cb8b4SAlexey Kardashevskiy 1557e68cb8b4SAlexey Kardashevskiy return 0; 1558e68cb8b4SAlexey Kardashevskiy } 15594be21d56SDavid Gibson 156028e02042SDavid Gibson static void htab_save_first_pass(QEMUFile *f, sPAPRMachineState *spapr, 15614be21d56SDavid Gibson int64_t max_ns) 15624be21d56SDavid Gibson { 1563378bc217SDavid Gibson bool has_timeout = max_ns != -1; 15644be21d56SDavid Gibson int htabslots = HTAB_SIZE(spapr) / HASH_PTE_SIZE_64; 15654be21d56SDavid Gibson int index = spapr->htab_save_index; 1566bc72ad67SAlex Bligh int64_t starttime = qemu_clock_get_ns(QEMU_CLOCK_REALTIME); 15674be21d56SDavid Gibson 15684be21d56SDavid Gibson assert(spapr->htab_first_pass); 15694be21d56SDavid Gibson 15704be21d56SDavid Gibson do { 15714be21d56SDavid Gibson int chunkstart; 15724be21d56SDavid Gibson 15734be21d56SDavid Gibson /* Consume invalid HPTEs */ 15744be21d56SDavid Gibson while ((index < htabslots) 15754be21d56SDavid Gibson && !HPTE_VALID(HPTE(spapr->htab, index))) { 15764be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 157724ec2863SMarc-André Lureau index++; 15784be21d56SDavid Gibson } 15794be21d56SDavid Gibson 15804be21d56SDavid Gibson /* Consume valid HPTEs */ 15814be21d56SDavid Gibson chunkstart = index; 1582338c25b6SSamuel Mendoza-Jonas while ((index < htabslots) && (index - chunkstart < USHRT_MAX) 15834be21d56SDavid Gibson && HPTE_VALID(HPTE(spapr->htab, index))) { 15844be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 158524ec2863SMarc-André Lureau index++; 15864be21d56SDavid Gibson } 15874be21d56SDavid Gibson 15884be21d56SDavid Gibson if (index > chunkstart) { 15894be21d56SDavid Gibson int n_valid = index - chunkstart; 15904be21d56SDavid Gibson 15914be21d56SDavid Gibson qemu_put_be32(f, chunkstart); 15924be21d56SDavid Gibson qemu_put_be16(f, n_valid); 15934be21d56SDavid Gibson qemu_put_be16(f, 0); 15944be21d56SDavid Gibson qemu_put_buffer(f, HPTE(spapr->htab, chunkstart), 15954be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_valid); 15964be21d56SDavid Gibson 1597378bc217SDavid Gibson if (has_timeout && 1598378bc217SDavid Gibson (qemu_clock_get_ns(QEMU_CLOCK_REALTIME) - starttime) > max_ns) { 15994be21d56SDavid Gibson break; 16004be21d56SDavid Gibson } 16014be21d56SDavid Gibson } 16024be21d56SDavid Gibson } while ((index < htabslots) && !qemu_file_rate_limit(f)); 16034be21d56SDavid Gibson 16044be21d56SDavid Gibson if (index >= htabslots) { 16054be21d56SDavid Gibson assert(index == htabslots); 16064be21d56SDavid Gibson index = 0; 16074be21d56SDavid Gibson spapr->htab_first_pass = false; 16084be21d56SDavid Gibson } 16094be21d56SDavid Gibson spapr->htab_save_index = index; 16104be21d56SDavid Gibson } 16114be21d56SDavid Gibson 161228e02042SDavid Gibson static int htab_save_later_pass(QEMUFile *f, sPAPRMachineState *spapr, 16134be21d56SDavid Gibson int64_t max_ns) 16144be21d56SDavid Gibson { 16154be21d56SDavid Gibson bool final = max_ns < 0; 16164be21d56SDavid Gibson int htabslots = HTAB_SIZE(spapr) / HASH_PTE_SIZE_64; 16174be21d56SDavid Gibson int examined = 0, sent = 0; 16184be21d56SDavid Gibson int index = spapr->htab_save_index; 1619bc72ad67SAlex Bligh int64_t starttime = qemu_clock_get_ns(QEMU_CLOCK_REALTIME); 16204be21d56SDavid Gibson 16214be21d56SDavid Gibson assert(!spapr->htab_first_pass); 16224be21d56SDavid Gibson 16234be21d56SDavid Gibson do { 16244be21d56SDavid Gibson int chunkstart, invalidstart; 16254be21d56SDavid Gibson 16264be21d56SDavid Gibson /* Consume non-dirty HPTEs */ 16274be21d56SDavid Gibson while ((index < htabslots) 16284be21d56SDavid Gibson && !HPTE_DIRTY(HPTE(spapr->htab, index))) { 16294be21d56SDavid Gibson index++; 16304be21d56SDavid Gibson examined++; 16314be21d56SDavid Gibson } 16324be21d56SDavid Gibson 16334be21d56SDavid Gibson chunkstart = index; 16344be21d56SDavid Gibson /* Consume valid dirty HPTEs */ 1635338c25b6SSamuel Mendoza-Jonas while ((index < htabslots) && (index - chunkstart < USHRT_MAX) 16364be21d56SDavid Gibson && HPTE_DIRTY(HPTE(spapr->htab, index)) 16374be21d56SDavid Gibson && HPTE_VALID(HPTE(spapr->htab, index))) { 16384be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 16394be21d56SDavid Gibson index++; 16404be21d56SDavid Gibson examined++; 16414be21d56SDavid Gibson } 16424be21d56SDavid Gibson 16434be21d56SDavid Gibson invalidstart = index; 16444be21d56SDavid Gibson /* Consume invalid dirty HPTEs */ 1645338c25b6SSamuel Mendoza-Jonas while ((index < htabslots) && (index - invalidstart < USHRT_MAX) 16464be21d56SDavid Gibson && HPTE_DIRTY(HPTE(spapr->htab, index)) 16474be21d56SDavid Gibson && !HPTE_VALID(HPTE(spapr->htab, index))) { 16484be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 16494be21d56SDavid Gibson index++; 16504be21d56SDavid Gibson examined++; 16514be21d56SDavid Gibson } 16524be21d56SDavid Gibson 16534be21d56SDavid Gibson if (index > chunkstart) { 16544be21d56SDavid Gibson int n_valid = invalidstart - chunkstart; 16554be21d56SDavid Gibson int n_invalid = index - invalidstart; 16564be21d56SDavid Gibson 16574be21d56SDavid Gibson qemu_put_be32(f, chunkstart); 16584be21d56SDavid Gibson qemu_put_be16(f, n_valid); 16594be21d56SDavid Gibson qemu_put_be16(f, n_invalid); 16604be21d56SDavid Gibson qemu_put_buffer(f, HPTE(spapr->htab, chunkstart), 16614be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_valid); 16624be21d56SDavid Gibson sent += index - chunkstart; 16634be21d56SDavid Gibson 1664bc72ad67SAlex Bligh if (!final && (qemu_clock_get_ns(QEMU_CLOCK_REALTIME) - starttime) > max_ns) { 16654be21d56SDavid Gibson break; 16664be21d56SDavid Gibson } 16674be21d56SDavid Gibson } 16684be21d56SDavid Gibson 16694be21d56SDavid Gibson if (examined >= htabslots) { 16704be21d56SDavid Gibson break; 16714be21d56SDavid Gibson } 16724be21d56SDavid Gibson 16734be21d56SDavid Gibson if (index >= htabslots) { 16744be21d56SDavid Gibson assert(index == htabslots); 16754be21d56SDavid Gibson index = 0; 16764be21d56SDavid Gibson } 16774be21d56SDavid Gibson } while ((examined < htabslots) && (!qemu_file_rate_limit(f) || final)); 16784be21d56SDavid Gibson 16794be21d56SDavid Gibson if (index >= htabslots) { 16804be21d56SDavid Gibson assert(index == htabslots); 16814be21d56SDavid Gibson index = 0; 16824be21d56SDavid Gibson } 16834be21d56SDavid Gibson 16844be21d56SDavid Gibson spapr->htab_save_index = index; 16854be21d56SDavid Gibson 1686e68cb8b4SAlexey Kardashevskiy return (examined >= htabslots) && (sent == 0) ? 1 : 0; 16874be21d56SDavid Gibson } 16884be21d56SDavid Gibson 1689e68cb8b4SAlexey Kardashevskiy #define MAX_ITERATION_NS 5000000 /* 5 ms */ 1690e68cb8b4SAlexey Kardashevskiy #define MAX_KVM_BUF_SIZE 2048 1691e68cb8b4SAlexey Kardashevskiy 16924be21d56SDavid Gibson static int htab_save_iterate(QEMUFile *f, void *opaque) 16934be21d56SDavid Gibson { 169428e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 1695715c5407SDavid Gibson int fd; 1696e68cb8b4SAlexey Kardashevskiy int rc = 0; 16974be21d56SDavid Gibson 16984be21d56SDavid Gibson /* Iteration header */ 16994be21d56SDavid Gibson qemu_put_be32(f, 0); 17004be21d56SDavid Gibson 1701e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1702e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 1703e68cb8b4SAlexey Kardashevskiy 1704715c5407SDavid Gibson fd = get_htab_fd(spapr); 1705715c5407SDavid Gibson if (fd < 0) { 1706715c5407SDavid Gibson return fd; 170701a57972SSamuel Mendoza-Jonas } 170801a57972SSamuel Mendoza-Jonas 1709715c5407SDavid Gibson rc = kvmppc_save_htab(f, fd, MAX_KVM_BUF_SIZE, MAX_ITERATION_NS); 1710e68cb8b4SAlexey Kardashevskiy if (rc < 0) { 1711e68cb8b4SAlexey Kardashevskiy return rc; 1712e68cb8b4SAlexey Kardashevskiy } 1713e68cb8b4SAlexey Kardashevskiy } else if (spapr->htab_first_pass) { 17144be21d56SDavid Gibson htab_save_first_pass(f, spapr, MAX_ITERATION_NS); 17154be21d56SDavid Gibson } else { 1716e68cb8b4SAlexey Kardashevskiy rc = htab_save_later_pass(f, spapr, MAX_ITERATION_NS); 17174be21d56SDavid Gibson } 17184be21d56SDavid Gibson 17194be21d56SDavid Gibson /* End marker */ 17204be21d56SDavid Gibson qemu_put_be32(f, 0); 17214be21d56SDavid Gibson qemu_put_be16(f, 0); 17224be21d56SDavid Gibson qemu_put_be16(f, 0); 17234be21d56SDavid Gibson 1724e68cb8b4SAlexey Kardashevskiy return rc; 17254be21d56SDavid Gibson } 17264be21d56SDavid Gibson 17274be21d56SDavid Gibson static int htab_save_complete(QEMUFile *f, void *opaque) 17284be21d56SDavid Gibson { 172928e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 1730715c5407SDavid Gibson int fd; 17314be21d56SDavid Gibson 17324be21d56SDavid Gibson /* Iteration header */ 17334be21d56SDavid Gibson qemu_put_be32(f, 0); 17344be21d56SDavid Gibson 1735e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1736e68cb8b4SAlexey Kardashevskiy int rc; 1737e68cb8b4SAlexey Kardashevskiy 1738e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 1739e68cb8b4SAlexey Kardashevskiy 1740715c5407SDavid Gibson fd = get_htab_fd(spapr); 1741715c5407SDavid Gibson if (fd < 0) { 1742715c5407SDavid Gibson return fd; 174301a57972SSamuel Mendoza-Jonas } 174401a57972SSamuel Mendoza-Jonas 1745715c5407SDavid Gibson rc = kvmppc_save_htab(f, fd, MAX_KVM_BUF_SIZE, -1); 1746e68cb8b4SAlexey Kardashevskiy if (rc < 0) { 1747e68cb8b4SAlexey Kardashevskiy return rc; 1748e68cb8b4SAlexey Kardashevskiy } 1749e68cb8b4SAlexey Kardashevskiy } else { 1750378bc217SDavid Gibson if (spapr->htab_first_pass) { 1751378bc217SDavid Gibson htab_save_first_pass(f, spapr, -1); 1752378bc217SDavid Gibson } 17534be21d56SDavid Gibson htab_save_later_pass(f, spapr, -1); 1754e68cb8b4SAlexey Kardashevskiy } 17554be21d56SDavid Gibson 17564be21d56SDavid Gibson /* End marker */ 17574be21d56SDavid Gibson qemu_put_be32(f, 0); 17584be21d56SDavid Gibson qemu_put_be16(f, 0); 17594be21d56SDavid Gibson qemu_put_be16(f, 0); 17604be21d56SDavid Gibson 17614be21d56SDavid Gibson return 0; 17624be21d56SDavid Gibson } 17634be21d56SDavid Gibson 17644be21d56SDavid Gibson static int htab_load(QEMUFile *f, void *opaque, int version_id) 17654be21d56SDavid Gibson { 176628e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 17674be21d56SDavid Gibson uint32_t section_hdr; 1768e68cb8b4SAlexey Kardashevskiy int fd = -1; 17694be21d56SDavid Gibson 17704be21d56SDavid Gibson if (version_id < 1 || version_id > 1) { 177198a5d100SDavid Gibson error_report("htab_load() bad version"); 17724be21d56SDavid Gibson return -EINVAL; 17734be21d56SDavid Gibson } 17744be21d56SDavid Gibson 17754be21d56SDavid Gibson section_hdr = qemu_get_be32(f); 17764be21d56SDavid Gibson 17774be21d56SDavid Gibson if (section_hdr) { 17789897e462SGreg Kurz Error *local_err = NULL; 1779c5f54f3eSDavid Gibson 1780c5f54f3eSDavid Gibson /* First section gives the htab size */ 1781c5f54f3eSDavid Gibson spapr_reallocate_hpt(spapr, section_hdr, &local_err); 1782c5f54f3eSDavid Gibson if (local_err) { 1783c5f54f3eSDavid Gibson error_report_err(local_err); 17844be21d56SDavid Gibson return -EINVAL; 17854be21d56SDavid Gibson } 17864be21d56SDavid Gibson return 0; 17874be21d56SDavid Gibson } 17884be21d56SDavid Gibson 1789e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1790e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 1791e68cb8b4SAlexey Kardashevskiy 1792e68cb8b4SAlexey Kardashevskiy fd = kvmppc_get_htab_fd(true); 1793e68cb8b4SAlexey Kardashevskiy if (fd < 0) { 179498a5d100SDavid Gibson error_report("Unable to open fd to restore KVM hash table: %s", 1795e68cb8b4SAlexey Kardashevskiy strerror(errno)); 1796e68cb8b4SAlexey Kardashevskiy } 1797e68cb8b4SAlexey Kardashevskiy } 1798e68cb8b4SAlexey Kardashevskiy 17994be21d56SDavid Gibson while (true) { 18004be21d56SDavid Gibson uint32_t index; 18014be21d56SDavid Gibson uint16_t n_valid, n_invalid; 18024be21d56SDavid Gibson 18034be21d56SDavid Gibson index = qemu_get_be32(f); 18044be21d56SDavid Gibson n_valid = qemu_get_be16(f); 18054be21d56SDavid Gibson n_invalid = qemu_get_be16(f); 18064be21d56SDavid Gibson 18074be21d56SDavid Gibson if ((index == 0) && (n_valid == 0) && (n_invalid == 0)) { 18084be21d56SDavid Gibson /* End of Stream */ 18094be21d56SDavid Gibson break; 18104be21d56SDavid Gibson } 18114be21d56SDavid Gibson 1812e68cb8b4SAlexey Kardashevskiy if ((index + n_valid + n_invalid) > 18134be21d56SDavid Gibson (HTAB_SIZE(spapr) / HASH_PTE_SIZE_64)) { 18144be21d56SDavid Gibson /* Bad index in stream */ 181598a5d100SDavid Gibson error_report( 181698a5d100SDavid Gibson "htab_load() bad index %d (%hd+%hd entries) in htab stream (htab_shift=%d)", 181798a5d100SDavid Gibson index, n_valid, n_invalid, spapr->htab_shift); 18184be21d56SDavid Gibson return -EINVAL; 18194be21d56SDavid Gibson } 18204be21d56SDavid Gibson 1821e68cb8b4SAlexey Kardashevskiy if (spapr->htab) { 18224be21d56SDavid Gibson if (n_valid) { 18234be21d56SDavid Gibson qemu_get_buffer(f, HPTE(spapr->htab, index), 18244be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_valid); 18254be21d56SDavid Gibson } 18264be21d56SDavid Gibson if (n_invalid) { 18274be21d56SDavid Gibson memset(HPTE(spapr->htab, index + n_valid), 0, 18284be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_invalid); 18294be21d56SDavid Gibson } 1830e68cb8b4SAlexey Kardashevskiy } else { 1831e68cb8b4SAlexey Kardashevskiy int rc; 1832e68cb8b4SAlexey Kardashevskiy 1833e68cb8b4SAlexey Kardashevskiy assert(fd >= 0); 1834e68cb8b4SAlexey Kardashevskiy 1835e68cb8b4SAlexey Kardashevskiy rc = kvmppc_load_htab_chunk(f, fd, index, n_valid, n_invalid); 1836e68cb8b4SAlexey Kardashevskiy if (rc < 0) { 1837e68cb8b4SAlexey Kardashevskiy return rc; 1838e68cb8b4SAlexey Kardashevskiy } 1839e68cb8b4SAlexey Kardashevskiy } 1840e68cb8b4SAlexey Kardashevskiy } 1841e68cb8b4SAlexey Kardashevskiy 1842e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1843e68cb8b4SAlexey Kardashevskiy assert(fd >= 0); 1844e68cb8b4SAlexey Kardashevskiy close(fd); 18454be21d56SDavid Gibson } 18464be21d56SDavid Gibson 18474be21d56SDavid Gibson return 0; 18484be21d56SDavid Gibson } 18494be21d56SDavid Gibson 1850c573fc03SThomas Huth static void htab_cleanup(void *opaque) 1851c573fc03SThomas Huth { 1852c573fc03SThomas Huth sPAPRMachineState *spapr = opaque; 1853c573fc03SThomas Huth 1854c573fc03SThomas Huth close_htab_fd(spapr); 1855c573fc03SThomas Huth } 1856c573fc03SThomas Huth 18574be21d56SDavid Gibson static SaveVMHandlers savevm_htab_handlers = { 18584be21d56SDavid Gibson .save_live_setup = htab_save_setup, 18594be21d56SDavid Gibson .save_live_iterate = htab_save_iterate, 1860a3e06c3dSDr. David Alan Gilbert .save_live_complete_precopy = htab_save_complete, 1861c573fc03SThomas Huth .cleanup = htab_cleanup, 18624be21d56SDavid Gibson .load_state = htab_load, 18634be21d56SDavid Gibson }; 18644be21d56SDavid Gibson 18655b2128d2SAlexander Graf static void spapr_boot_set(void *opaque, const char *boot_device, 18665b2128d2SAlexander Graf Error **errp) 18675b2128d2SAlexander Graf { 18685b2128d2SAlexander Graf MachineState *machine = MACHINE(qdev_get_machine()); 18695b2128d2SAlexander Graf machine->boot_order = g_strdup(boot_device); 18705b2128d2SAlexander Graf } 18715b2128d2SAlexander Graf 1872224245bfSDavid Gibson /* 1873224245bfSDavid Gibson * Reset routine for LMB DR devices. 1874224245bfSDavid Gibson * 1875224245bfSDavid Gibson * Unlike PCI DR devices, LMB DR devices explicitly register this reset 1876224245bfSDavid Gibson * routine. Reset for PCI DR devices will be handled by PHB reset routine 1877224245bfSDavid Gibson * when it walks all its children devices. LMB devices reset occurs 1878224245bfSDavid Gibson * as part of spapr_ppc_reset(). 1879224245bfSDavid Gibson */ 1880224245bfSDavid Gibson static void spapr_drc_reset(void *opaque) 1881224245bfSDavid Gibson { 1882224245bfSDavid Gibson sPAPRDRConnector *drc = opaque; 1883224245bfSDavid Gibson DeviceState *d = DEVICE(drc); 1884224245bfSDavid Gibson 1885224245bfSDavid Gibson if (d) { 1886224245bfSDavid Gibson device_reset(d); 1887224245bfSDavid Gibson } 1888224245bfSDavid Gibson } 1889224245bfSDavid Gibson 1890224245bfSDavid Gibson static void spapr_create_lmb_dr_connectors(sPAPRMachineState *spapr) 1891224245bfSDavid Gibson { 1892224245bfSDavid Gibson MachineState *machine = MACHINE(spapr); 1893224245bfSDavid Gibson uint64_t lmb_size = SPAPR_MEMORY_BLOCK_SIZE; 1894e8f986fcSBharata B Rao uint32_t nr_lmbs = (machine->maxram_size - machine->ram_size)/lmb_size; 1895224245bfSDavid Gibson int i; 1896224245bfSDavid Gibson 1897224245bfSDavid Gibson for (i = 0; i < nr_lmbs; i++) { 1898224245bfSDavid Gibson sPAPRDRConnector *drc; 1899224245bfSDavid Gibson uint64_t addr; 1900224245bfSDavid Gibson 1901e8f986fcSBharata B Rao addr = i * lmb_size + spapr->hotplug_memory.base; 1902224245bfSDavid Gibson drc = spapr_dr_connector_new(OBJECT(spapr), SPAPR_DR_CONNECTOR_TYPE_LMB, 1903224245bfSDavid Gibson addr/lmb_size); 1904224245bfSDavid Gibson qemu_register_reset(spapr_drc_reset, drc); 1905224245bfSDavid Gibson } 1906224245bfSDavid Gibson } 1907224245bfSDavid Gibson 1908224245bfSDavid Gibson /* 1909224245bfSDavid Gibson * If RAM size, maxmem size and individual node mem sizes aren't aligned 1910224245bfSDavid Gibson * to SPAPR_MEMORY_BLOCK_SIZE(256MB), then refuse to start the guest 1911224245bfSDavid Gibson * since we can't support such unaligned sizes with DRCONF_MEMORY. 1912224245bfSDavid Gibson */ 19137c150d6fSDavid Gibson static void spapr_validate_node_memory(MachineState *machine, Error **errp) 1914224245bfSDavid Gibson { 1915224245bfSDavid Gibson int i; 1916224245bfSDavid Gibson 19177c150d6fSDavid Gibson if (machine->ram_size % SPAPR_MEMORY_BLOCK_SIZE) { 19187c150d6fSDavid Gibson error_setg(errp, "Memory size 0x" RAM_ADDR_FMT 19197c150d6fSDavid Gibson " is not aligned to %llu MiB", 19207c150d6fSDavid Gibson machine->ram_size, 1921224245bfSDavid Gibson SPAPR_MEMORY_BLOCK_SIZE / M_BYTE); 19227c150d6fSDavid Gibson return; 19237c150d6fSDavid Gibson } 19247c150d6fSDavid Gibson 19257c150d6fSDavid Gibson if (machine->maxram_size % SPAPR_MEMORY_BLOCK_SIZE) { 19267c150d6fSDavid Gibson error_setg(errp, "Maximum memory size 0x" RAM_ADDR_FMT 19277c150d6fSDavid Gibson " is not aligned to %llu MiB", 19287c150d6fSDavid Gibson machine->ram_size, 19297c150d6fSDavid Gibson SPAPR_MEMORY_BLOCK_SIZE / M_BYTE); 19307c150d6fSDavid Gibson return; 1931224245bfSDavid Gibson } 1932224245bfSDavid Gibson 1933224245bfSDavid Gibson for (i = 0; i < nb_numa_nodes; i++) { 1934224245bfSDavid Gibson if (numa_info[i].node_mem % SPAPR_MEMORY_BLOCK_SIZE) { 19357c150d6fSDavid Gibson error_setg(errp, 19367c150d6fSDavid Gibson "Node %d memory size 0x%" PRIx64 19377c150d6fSDavid Gibson " is not aligned to %llu MiB", 19387c150d6fSDavid Gibson i, numa_info[i].node_mem, 1939224245bfSDavid Gibson SPAPR_MEMORY_BLOCK_SIZE / M_BYTE); 19407c150d6fSDavid Gibson return; 1941224245bfSDavid Gibson } 1942224245bfSDavid Gibson } 1943224245bfSDavid Gibson } 1944224245bfSDavid Gibson 1945535455fdSIgor Mammedov /* find cpu slot in machine->possible_cpus by core_id */ 1946535455fdSIgor Mammedov static CPUArchId *spapr_find_cpu_slot(MachineState *ms, uint32_t id, int *idx) 1947535455fdSIgor Mammedov { 1948535455fdSIgor Mammedov int index = id / smp_threads; 1949535455fdSIgor Mammedov 1950535455fdSIgor Mammedov if (index >= ms->possible_cpus->len) { 1951535455fdSIgor Mammedov return NULL; 1952535455fdSIgor Mammedov } 1953535455fdSIgor Mammedov if (idx) { 1954535455fdSIgor Mammedov *idx = index; 1955535455fdSIgor Mammedov } 1956535455fdSIgor Mammedov return &ms->possible_cpus->cpus[index]; 1957535455fdSIgor Mammedov } 1958535455fdSIgor Mammedov 19590c86d0fdSDavid Gibson static void spapr_init_cpus(sPAPRMachineState *spapr) 19600c86d0fdSDavid Gibson { 19610c86d0fdSDavid Gibson MachineState *machine = MACHINE(spapr); 19620c86d0fdSDavid Gibson MachineClass *mc = MACHINE_GET_CLASS(machine); 19630c86d0fdSDavid Gibson char *type = spapr_get_cpu_core_type(machine->cpu_model); 19640c86d0fdSDavid Gibson int smt = kvmppc_smt_threads(); 1965535455fdSIgor Mammedov const CPUArchIdList *possible_cpus; 1966535455fdSIgor Mammedov int boot_cores_nr = smp_cpus / smp_threads; 19670c86d0fdSDavid Gibson int i; 19680c86d0fdSDavid Gibson 19690c86d0fdSDavid Gibson if (!type) { 19700c86d0fdSDavid Gibson error_report("Unable to find sPAPR CPU Core definition"); 19710c86d0fdSDavid Gibson exit(1); 19720c86d0fdSDavid Gibson } 19730c86d0fdSDavid Gibson 1974535455fdSIgor Mammedov possible_cpus = mc->possible_cpu_arch_ids(machine); 1975c5514d0eSIgor Mammedov if (mc->has_hotpluggable_cpus) { 19760c86d0fdSDavid Gibson if (smp_cpus % smp_threads) { 19770c86d0fdSDavid Gibson error_report("smp_cpus (%u) must be multiple of threads (%u)", 19780c86d0fdSDavid Gibson smp_cpus, smp_threads); 19790c86d0fdSDavid Gibson exit(1); 19800c86d0fdSDavid Gibson } 19810c86d0fdSDavid Gibson if (max_cpus % smp_threads) { 19820c86d0fdSDavid Gibson error_report("max_cpus (%u) must be multiple of threads (%u)", 19830c86d0fdSDavid Gibson max_cpus, smp_threads); 19840c86d0fdSDavid Gibson exit(1); 19850c86d0fdSDavid Gibson } 19860c86d0fdSDavid Gibson } else { 19870c86d0fdSDavid Gibson if (max_cpus != smp_cpus) { 19880c86d0fdSDavid Gibson error_report("This machine version does not support CPU hotplug"); 19890c86d0fdSDavid Gibson exit(1); 19900c86d0fdSDavid Gibson } 1991535455fdSIgor Mammedov boot_cores_nr = possible_cpus->len; 19920c86d0fdSDavid Gibson } 19930c86d0fdSDavid Gibson 1994535455fdSIgor Mammedov for (i = 0; i < possible_cpus->len; i++) { 19950c86d0fdSDavid Gibson int core_id = i * smp_threads; 19960c86d0fdSDavid Gibson 1997c5514d0eSIgor Mammedov if (mc->has_hotpluggable_cpus) { 19980c86d0fdSDavid Gibson sPAPRDRConnector *drc = 19990c86d0fdSDavid Gibson spapr_dr_connector_new(OBJECT(spapr), 20000c86d0fdSDavid Gibson SPAPR_DR_CONNECTOR_TYPE_CPU, 20010c86d0fdSDavid Gibson (core_id / smp_threads) * smt); 20020c86d0fdSDavid Gibson 20030c86d0fdSDavid Gibson qemu_register_reset(spapr_drc_reset, drc); 20040c86d0fdSDavid Gibson } 20050c86d0fdSDavid Gibson 2006535455fdSIgor Mammedov if (i < boot_cores_nr) { 20070c86d0fdSDavid Gibson Object *core = object_new(type); 20080c86d0fdSDavid Gibson int nr_threads = smp_threads; 20090c86d0fdSDavid Gibson 20100c86d0fdSDavid Gibson /* Handle the partially filled core for older machine types */ 20110c86d0fdSDavid Gibson if ((i + 1) * smp_threads >= smp_cpus) { 20120c86d0fdSDavid Gibson nr_threads = smp_cpus - i * smp_threads; 20130c86d0fdSDavid Gibson } 20140c86d0fdSDavid Gibson 20150c86d0fdSDavid Gibson object_property_set_int(core, nr_threads, "nr-threads", 20160c86d0fdSDavid Gibson &error_fatal); 20170c86d0fdSDavid Gibson object_property_set_int(core, core_id, CPU_CORE_PROP_CORE_ID, 20180c86d0fdSDavid Gibson &error_fatal); 20190c86d0fdSDavid Gibson object_property_set_bool(core, true, "realized", &error_fatal); 20200c86d0fdSDavid Gibson } 20210c86d0fdSDavid Gibson } 20220c86d0fdSDavid Gibson g_free(type); 20230c86d0fdSDavid Gibson } 20240c86d0fdSDavid Gibson 202553018216SPaolo Bonzini /* pSeries LPAR / sPAPR hardware init */ 20263ef96221SMarcel Apfelbaum static void ppc_spapr_init(MachineState *machine) 202753018216SPaolo Bonzini { 202828e02042SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(machine); 2029224245bfSDavid Gibson sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(machine); 20303ef96221SMarcel Apfelbaum const char *kernel_filename = machine->kernel_filename; 20313ef96221SMarcel Apfelbaum const char *initrd_filename = machine->initrd_filename; 203253018216SPaolo Bonzini PCIHostState *phb; 203353018216SPaolo Bonzini int i; 203453018216SPaolo Bonzini MemoryRegion *sysmem = get_system_memory(); 203553018216SPaolo Bonzini MemoryRegion *ram = g_new(MemoryRegion, 1); 2036658fa66bSAlexey Kardashevskiy MemoryRegion *rma_region; 2037658fa66bSAlexey Kardashevskiy void *rma = NULL; 203853018216SPaolo Bonzini hwaddr rma_alloc_size; 2039b082d65aSAlexey Kardashevskiy hwaddr node0_size = spapr_node0_size(); 2040b7d1f77aSBenjamin Herrenschmidt long load_limit, fw_size; 204153018216SPaolo Bonzini char *filename; 204253018216SPaolo Bonzini 2043226419d6SMichael S. Tsirkin msi_nonbroken = true; 204453018216SPaolo Bonzini 204553018216SPaolo Bonzini QLIST_INIT(&spapr->phbs); 204653018216SPaolo Bonzini 204753018216SPaolo Bonzini /* Allocate RMA if necessary */ 2048658fa66bSAlexey Kardashevskiy rma_alloc_size = kvmppc_alloc_rma(&rma); 204953018216SPaolo Bonzini 205053018216SPaolo Bonzini if (rma_alloc_size == -1) { 2051730fce59SThomas Huth error_report("Unable to create RMA"); 205253018216SPaolo Bonzini exit(1); 205353018216SPaolo Bonzini } 205453018216SPaolo Bonzini 2055c4177479SAlexey Kardashevskiy if (rma_alloc_size && (rma_alloc_size < node0_size)) { 205653018216SPaolo Bonzini spapr->rma_size = rma_alloc_size; 205753018216SPaolo Bonzini } else { 2058c4177479SAlexey Kardashevskiy spapr->rma_size = node0_size; 205953018216SPaolo Bonzini 206053018216SPaolo Bonzini /* With KVM, we don't actually know whether KVM supports an 206153018216SPaolo Bonzini * unbounded RMA (PR KVM) or is limited by the hash table size 206253018216SPaolo Bonzini * (HV KVM using VRMA), so we always assume the latter 206353018216SPaolo Bonzini * 206453018216SPaolo Bonzini * In that case, we also limit the initial allocations for RTAS 206553018216SPaolo Bonzini * etc... to 256M since we have no way to know what the VRMA size 206653018216SPaolo Bonzini * is going to be as it depends on the size of the hash table 206753018216SPaolo Bonzini * isn't determined yet. 206853018216SPaolo Bonzini */ 206953018216SPaolo Bonzini if (kvm_enabled()) { 207053018216SPaolo Bonzini spapr->vrma_adjust = 1; 207153018216SPaolo Bonzini spapr->rma_size = MIN(spapr->rma_size, 0x10000000); 207253018216SPaolo Bonzini } 2073912acdf4SBenjamin Herrenschmidt 2074912acdf4SBenjamin Herrenschmidt /* Actually we don't support unbounded RMA anymore since we 2075912acdf4SBenjamin Herrenschmidt * added proper emulation of HV mode. The max we can get is 2076912acdf4SBenjamin Herrenschmidt * 16G which also happens to be what we configure for PAPR 2077912acdf4SBenjamin Herrenschmidt * mode so make sure we don't do anything bigger than that 2078912acdf4SBenjamin Herrenschmidt */ 2079912acdf4SBenjamin Herrenschmidt spapr->rma_size = MIN(spapr->rma_size, 0x400000000ull); 208053018216SPaolo Bonzini } 208153018216SPaolo Bonzini 2082c4177479SAlexey Kardashevskiy if (spapr->rma_size > node0_size) { 2083d54e4d76SDavid Gibson error_report("Numa node 0 has to span the RMA (%#08"HWADDR_PRIx")", 2084c4177479SAlexey Kardashevskiy spapr->rma_size); 2085c4177479SAlexey Kardashevskiy exit(1); 2086c4177479SAlexey Kardashevskiy } 2087c4177479SAlexey Kardashevskiy 2088b7d1f77aSBenjamin Herrenschmidt /* Setup a load limit for the ramdisk leaving room for SLOF and FDT */ 2089b7d1f77aSBenjamin Herrenschmidt load_limit = MIN(spapr->rma_size, RTAS_MAX_ADDR) - FW_OVERHEAD; 209053018216SPaolo Bonzini 20917b565160SDavid Gibson /* Set up Interrupt Controller before we create the VCPUs */ 209271cd4dacSCédric Le Goater xics_system_init(machine, XICS_IRQS_SPAPR, &error_fatal); 20937b565160SDavid Gibson 2094facdb8b6SMichael Roth /* Set up containers for ibm,client-set-architecture negotiated options */ 2095facdb8b6SMichael Roth spapr->ov5 = spapr_ovec_new(); 2096facdb8b6SMichael Roth spapr->ov5_cas = spapr_ovec_new(); 2097facdb8b6SMichael Roth 2098224245bfSDavid Gibson if (smc->dr_lmb_enabled) { 2099facdb8b6SMichael Roth spapr_ovec_set(spapr->ov5, OV5_DRCONF_MEMORY); 21007c150d6fSDavid Gibson spapr_validate_node_memory(machine, &error_fatal); 2101224245bfSDavid Gibson } 2102224245bfSDavid Gibson 2103417ece33SMichael Roth spapr_ovec_set(spapr->ov5, OV5_FORM1_AFFINITY); 21049fb4541fSSam Bobroff if (kvmppc_has_cap_mmu_radix()) { 21059fb4541fSSam Bobroff /* KVM always allows GTSE with radix... */ 21069fb4541fSSam Bobroff spapr_ovec_set(spapr->ov5, OV5_MMU_RADIX_GTSE); 21079fb4541fSSam Bobroff } 21089fb4541fSSam Bobroff /* ... but not with hash (currently). */ 2109417ece33SMichael Roth 2110ffbb1705SMichael Roth /* advertise support for dedicated HP event source to guests */ 2111ffbb1705SMichael Roth if (spapr->use_hotplug_event_source) { 2112ffbb1705SMichael Roth spapr_ovec_set(spapr->ov5, OV5_HP_EVT); 2113ffbb1705SMichael Roth } 2114ffbb1705SMichael Roth 211553018216SPaolo Bonzini /* init CPUs */ 211619fb2c36SBharata B Rao if (machine->cpu_model == NULL) { 21173daa4a9fSThomas Huth machine->cpu_model = kvm_enabled() ? "host" : smc->tcg_default_cpu; 211853018216SPaolo Bonzini } 211994a94e4cSBharata B Rao 2120e703d2f7SGreg Kurz ppc_cpu_parse_features(machine->cpu_model); 2121e703d2f7SGreg Kurz 21220c86d0fdSDavid Gibson spapr_init_cpus(spapr); 212353018216SPaolo Bonzini 2124026bfd89SDavid Gibson if (kvm_enabled()) { 2125026bfd89SDavid Gibson /* Enable H_LOGICAL_CI_* so SLOF can talk to in-kernel devices */ 2126026bfd89SDavid Gibson kvmppc_enable_logical_ci_hcalls(); 2127ef9971ddSAlexey Kardashevskiy kvmppc_enable_set_mode_hcall(); 21285145ad4fSNathan Whitehorn 21295145ad4fSNathan Whitehorn /* H_CLEAR_MOD/_REF are mandatory in PAPR, but off by default */ 21305145ad4fSNathan Whitehorn kvmppc_enable_clear_ref_mod_hcalls(); 2131026bfd89SDavid Gibson } 2132026bfd89SDavid Gibson 213353018216SPaolo Bonzini /* allocate RAM */ 2134f92f5da1SAlexey Kardashevskiy memory_region_allocate_system_memory(ram, NULL, "ppc_spapr.ram", 2135fb164994SDavid Gibson machine->ram_size); 2136f92f5da1SAlexey Kardashevskiy memory_region_add_subregion(sysmem, 0, ram); 213753018216SPaolo Bonzini 2138658fa66bSAlexey Kardashevskiy if (rma_alloc_size && rma) { 2139658fa66bSAlexey Kardashevskiy rma_region = g_new(MemoryRegion, 1); 2140658fa66bSAlexey Kardashevskiy memory_region_init_ram_ptr(rma_region, NULL, "ppc_spapr.rma", 2141658fa66bSAlexey Kardashevskiy rma_alloc_size, rma); 2142658fa66bSAlexey Kardashevskiy vmstate_register_ram_global(rma_region); 2143658fa66bSAlexey Kardashevskiy memory_region_add_subregion(sysmem, 0, rma_region); 2144658fa66bSAlexey Kardashevskiy } 2145658fa66bSAlexey Kardashevskiy 21464a1c9cf0SBharata B Rao /* initialize hotplug memory address space */ 21474a1c9cf0SBharata B Rao if (machine->ram_size < machine->maxram_size) { 21484a1c9cf0SBharata B Rao ram_addr_t hotplug_mem_size = machine->maxram_size - machine->ram_size; 214971c9a3ddSBharata B Rao /* 215071c9a3ddSBharata B Rao * Limit the number of hotpluggable memory slots to half the number 215171c9a3ddSBharata B Rao * slots that KVM supports, leaving the other half for PCI and other 215271c9a3ddSBharata B Rao * devices. However ensure that number of slots doesn't drop below 32. 215371c9a3ddSBharata B Rao */ 215471c9a3ddSBharata B Rao int max_memslots = kvm_enabled() ? kvm_get_max_memslots() / 2 : 215571c9a3ddSBharata B Rao SPAPR_MAX_RAM_SLOTS; 21564a1c9cf0SBharata B Rao 215771c9a3ddSBharata B Rao if (max_memslots < SPAPR_MAX_RAM_SLOTS) { 215871c9a3ddSBharata B Rao max_memslots = SPAPR_MAX_RAM_SLOTS; 215971c9a3ddSBharata B Rao } 216071c9a3ddSBharata B Rao if (machine->ram_slots > max_memslots) { 2161d54e4d76SDavid Gibson error_report("Specified number of memory slots %" 2162d54e4d76SDavid Gibson PRIu64" exceeds max supported %d", 216371c9a3ddSBharata B Rao machine->ram_slots, max_memslots); 2164d54e4d76SDavid Gibson exit(1); 21654a1c9cf0SBharata B Rao } 21664a1c9cf0SBharata B Rao 21674a1c9cf0SBharata B Rao spapr->hotplug_memory.base = ROUND_UP(machine->ram_size, 21684a1c9cf0SBharata B Rao SPAPR_HOTPLUG_MEM_ALIGN); 21694a1c9cf0SBharata B Rao memory_region_init(&spapr->hotplug_memory.mr, OBJECT(spapr), 21704a1c9cf0SBharata B Rao "hotplug-memory", hotplug_mem_size); 21714a1c9cf0SBharata B Rao memory_region_add_subregion(sysmem, spapr->hotplug_memory.base, 21724a1c9cf0SBharata B Rao &spapr->hotplug_memory.mr); 21734a1c9cf0SBharata B Rao } 21744a1c9cf0SBharata B Rao 2175224245bfSDavid Gibson if (smc->dr_lmb_enabled) { 2176224245bfSDavid Gibson spapr_create_lmb_dr_connectors(spapr); 2177224245bfSDavid Gibson } 2178224245bfSDavid Gibson 217953018216SPaolo Bonzini filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, "spapr-rtas.bin"); 21804c56440dSStefan Weil if (!filename) { 2181730fce59SThomas Huth error_report("Could not find LPAR rtas '%s'", "spapr-rtas.bin"); 21824c56440dSStefan Weil exit(1); 21834c56440dSStefan Weil } 2184b7d1f77aSBenjamin Herrenschmidt spapr->rtas_size = get_image_size(filename); 21858afc22a2SZhou Jie if (spapr->rtas_size < 0) { 21868afc22a2SZhou Jie error_report("Could not get size of LPAR rtas '%s'", filename); 21878afc22a2SZhou Jie exit(1); 21888afc22a2SZhou Jie } 2189b7d1f77aSBenjamin Herrenschmidt spapr->rtas_blob = g_malloc(spapr->rtas_size); 2190b7d1f77aSBenjamin Herrenschmidt if (load_image_size(filename, spapr->rtas_blob, spapr->rtas_size) < 0) { 2191730fce59SThomas Huth error_report("Could not load LPAR rtas '%s'", filename); 219253018216SPaolo Bonzini exit(1); 219353018216SPaolo Bonzini } 219453018216SPaolo Bonzini if (spapr->rtas_size > RTAS_MAX_SIZE) { 2195730fce59SThomas Huth error_report("RTAS too big ! 0x%zx bytes (max is 0x%x)", 21962f285bddSPeter Maydell (size_t)spapr->rtas_size, RTAS_MAX_SIZE); 219753018216SPaolo Bonzini exit(1); 219853018216SPaolo Bonzini } 219953018216SPaolo Bonzini g_free(filename); 220053018216SPaolo Bonzini 2201ffbb1705SMichael Roth /* Set up RTAS event infrastructure */ 220253018216SPaolo Bonzini spapr_events_init(spapr); 220353018216SPaolo Bonzini 220412f42174SDavid Gibson /* Set up the RTC RTAS interfaces */ 220528df36a1SDavid Gibson spapr_rtc_create(spapr); 220612f42174SDavid Gibson 220753018216SPaolo Bonzini /* Set up VIO bus */ 220853018216SPaolo Bonzini spapr->vio_bus = spapr_vio_bus_init(); 220953018216SPaolo Bonzini 221053018216SPaolo Bonzini for (i = 0; i < MAX_SERIAL_PORTS; i++) { 221153018216SPaolo Bonzini if (serial_hds[i]) { 221253018216SPaolo Bonzini spapr_vty_create(spapr->vio_bus, serial_hds[i]); 221353018216SPaolo Bonzini } 221453018216SPaolo Bonzini } 221553018216SPaolo Bonzini 221653018216SPaolo Bonzini /* We always have at least the nvram device on VIO */ 221753018216SPaolo Bonzini spapr_create_nvram(spapr); 221853018216SPaolo Bonzini 221953018216SPaolo Bonzini /* Set up PCI */ 222053018216SPaolo Bonzini spapr_pci_rtas_init(); 222153018216SPaolo Bonzini 222289dfd6e1SDavid Gibson phb = spapr_create_phb(spapr, 0); 222353018216SPaolo Bonzini 222453018216SPaolo Bonzini for (i = 0; i < nb_nics; i++) { 222553018216SPaolo Bonzini NICInfo *nd = &nd_table[i]; 222653018216SPaolo Bonzini 222753018216SPaolo Bonzini if (!nd->model) { 222853018216SPaolo Bonzini nd->model = g_strdup("ibmveth"); 222953018216SPaolo Bonzini } 223053018216SPaolo Bonzini 223153018216SPaolo Bonzini if (strcmp(nd->model, "ibmveth") == 0) { 223253018216SPaolo Bonzini spapr_vlan_create(spapr->vio_bus, nd); 223353018216SPaolo Bonzini } else { 223429b358f9SDavid Gibson pci_nic_init_nofail(&nd_table[i], phb->bus, nd->model, NULL); 223553018216SPaolo Bonzini } 223653018216SPaolo Bonzini } 223753018216SPaolo Bonzini 223853018216SPaolo Bonzini for (i = 0; i <= drive_get_max_bus(IF_SCSI); i++) { 223953018216SPaolo Bonzini spapr_vscsi_create(spapr->vio_bus); 224053018216SPaolo Bonzini } 224153018216SPaolo Bonzini 224253018216SPaolo Bonzini /* Graphics */ 224314c6a894SDavid Gibson if (spapr_vga_init(phb->bus, &error_fatal)) { 224453018216SPaolo Bonzini spapr->has_graphics = true; 2245c6e76503SPaolo Bonzini machine->usb |= defaults_enabled() && !machine->usb_disabled; 224653018216SPaolo Bonzini } 224753018216SPaolo Bonzini 22484ee9ced9SMarcel Apfelbaum if (machine->usb) { 224957040d45SThomas Huth if (smc->use_ohci_by_default) { 225053018216SPaolo Bonzini pci_create_simple(phb->bus, -1, "pci-ohci"); 225157040d45SThomas Huth } else { 225257040d45SThomas Huth pci_create_simple(phb->bus, -1, "nec-usb-xhci"); 225357040d45SThomas Huth } 2254c86580b8SMarkus Armbruster 225553018216SPaolo Bonzini if (spapr->has_graphics) { 2256c86580b8SMarkus Armbruster USBBus *usb_bus = usb_bus_find(-1); 2257c86580b8SMarkus Armbruster 2258c86580b8SMarkus Armbruster usb_create_simple(usb_bus, "usb-kbd"); 2259c86580b8SMarkus Armbruster usb_create_simple(usb_bus, "usb-mouse"); 226053018216SPaolo Bonzini } 226153018216SPaolo Bonzini } 226253018216SPaolo Bonzini 226353018216SPaolo Bonzini if (spapr->rma_size < (MIN_RMA_SLOF << 20)) { 2264d54e4d76SDavid Gibson error_report( 2265d54e4d76SDavid Gibson "pSeries SLOF firmware requires >= %ldM guest RMA (Real Mode Area memory)", 2266d54e4d76SDavid Gibson MIN_RMA_SLOF); 226753018216SPaolo Bonzini exit(1); 226853018216SPaolo Bonzini } 226953018216SPaolo Bonzini 227053018216SPaolo Bonzini if (kernel_filename) { 227153018216SPaolo Bonzini uint64_t lowaddr = 0; 227253018216SPaolo Bonzini 2273a19f7fb0SDavid Gibson spapr->kernel_size = load_elf(kernel_filename, translate_kernel_address, 2274a19f7fb0SDavid Gibson NULL, NULL, &lowaddr, NULL, 1, 2275a19f7fb0SDavid Gibson PPC_ELF_MACHINE, 0, 0); 2276a19f7fb0SDavid Gibson if (spapr->kernel_size == ELF_LOAD_WRONG_ENDIAN) { 2277a19f7fb0SDavid Gibson spapr->kernel_size = load_elf(kernel_filename, 2278a19f7fb0SDavid Gibson translate_kernel_address, NULL, NULL, 2279a19f7fb0SDavid Gibson &lowaddr, NULL, 0, PPC_ELF_MACHINE, 22807ef295eaSPeter Crosthwaite 0, 0); 2281a19f7fb0SDavid Gibson spapr->kernel_le = spapr->kernel_size > 0; 228216457e7fSBenjamin Herrenschmidt } 2283a19f7fb0SDavid Gibson if (spapr->kernel_size < 0) { 2284a19f7fb0SDavid Gibson error_report("error loading %s: %s", kernel_filename, 2285a19f7fb0SDavid Gibson load_elf_strerror(spapr->kernel_size)); 228653018216SPaolo Bonzini exit(1); 228753018216SPaolo Bonzini } 228853018216SPaolo Bonzini 228953018216SPaolo Bonzini /* load initrd */ 229053018216SPaolo Bonzini if (initrd_filename) { 229153018216SPaolo Bonzini /* Try to locate the initrd in the gap between the kernel 229253018216SPaolo Bonzini * and the firmware. Add a bit of space just in case 229353018216SPaolo Bonzini */ 2294a19f7fb0SDavid Gibson spapr->initrd_base = (KERNEL_LOAD_ADDR + spapr->kernel_size 2295a19f7fb0SDavid Gibson + 0x1ffff) & ~0xffff; 2296a19f7fb0SDavid Gibson spapr->initrd_size = load_image_targphys(initrd_filename, 2297a19f7fb0SDavid Gibson spapr->initrd_base, 2298a19f7fb0SDavid Gibson load_limit 2299a19f7fb0SDavid Gibson - spapr->initrd_base); 2300a19f7fb0SDavid Gibson if (spapr->initrd_size < 0) { 2301d54e4d76SDavid Gibson error_report("could not load initial ram disk '%s'", 230253018216SPaolo Bonzini initrd_filename); 230353018216SPaolo Bonzini exit(1); 230453018216SPaolo Bonzini } 230553018216SPaolo Bonzini } 230653018216SPaolo Bonzini } 230753018216SPaolo Bonzini 23088e7ea787SAndreas Färber if (bios_name == NULL) { 23098e7ea787SAndreas Färber bios_name = FW_FILE_NAME; 23108e7ea787SAndreas Färber } 23118e7ea787SAndreas Färber filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name); 23124c56440dSStefan Weil if (!filename) { 231368fea5a0SThomas Huth error_report("Could not find LPAR firmware '%s'", bios_name); 23144c56440dSStefan Weil exit(1); 23154c56440dSStefan Weil } 231653018216SPaolo Bonzini fw_size = load_image_targphys(filename, 0, FW_MAX_SIZE); 231768fea5a0SThomas Huth if (fw_size <= 0) { 231868fea5a0SThomas Huth error_report("Could not load LPAR firmware '%s'", filename); 231953018216SPaolo Bonzini exit(1); 232053018216SPaolo Bonzini } 232153018216SPaolo Bonzini g_free(filename); 232253018216SPaolo Bonzini 232328e02042SDavid Gibson /* FIXME: Should register things through the MachineState's qdev 232428e02042SDavid Gibson * interface, this is a legacy from the sPAPREnvironment structure 232528e02042SDavid Gibson * which predated MachineState but had a similar function */ 23264be21d56SDavid Gibson vmstate_register(NULL, 0, &vmstate_spapr, spapr); 23274be21d56SDavid Gibson register_savevm_live(NULL, "spapr/htab", -1, 1, 23284be21d56SDavid Gibson &savevm_htab_handlers, spapr); 23294be21d56SDavid Gibson 233046503c2bSMichael Roth /* used by RTAS */ 233146503c2bSMichael Roth QTAILQ_INIT(&spapr->ccs_list); 233246503c2bSMichael Roth qemu_register_reset(spapr_ccs_reset_hook, spapr); 233346503c2bSMichael Roth 23345b2128d2SAlexander Graf qemu_register_boot_set(spapr_boot_set, spapr); 233542043e4fSLaurent Vivier 233642043e4fSLaurent Vivier if (kvm_enabled()) { 23373dc410aeSAlexey Kardashevskiy /* to stop and start vmclock */ 233842043e4fSLaurent Vivier qemu_add_vm_change_state_handler(cpu_ppc_clock_vm_state_change, 233942043e4fSLaurent Vivier &spapr->tb); 23403dc410aeSAlexey Kardashevskiy 23413dc410aeSAlexey Kardashevskiy kvmppc_spapr_enable_inkernel_multitce(); 234242043e4fSLaurent Vivier } 234353018216SPaolo Bonzini } 234453018216SPaolo Bonzini 2345135a129aSAneesh Kumar K.V static int spapr_kvm_type(const char *vm_type) 2346135a129aSAneesh Kumar K.V { 2347135a129aSAneesh Kumar K.V if (!vm_type) { 2348135a129aSAneesh Kumar K.V return 0; 2349135a129aSAneesh Kumar K.V } 2350135a129aSAneesh Kumar K.V 2351135a129aSAneesh Kumar K.V if (!strcmp(vm_type, "HV")) { 2352135a129aSAneesh Kumar K.V return 1; 2353135a129aSAneesh Kumar K.V } 2354135a129aSAneesh Kumar K.V 2355135a129aSAneesh Kumar K.V if (!strcmp(vm_type, "PR")) { 2356135a129aSAneesh Kumar K.V return 2; 2357135a129aSAneesh Kumar K.V } 2358135a129aSAneesh Kumar K.V 2359135a129aSAneesh Kumar K.V error_report("Unknown kvm-type specified '%s'", vm_type); 2360135a129aSAneesh Kumar K.V exit(1); 2361135a129aSAneesh Kumar K.V } 2362135a129aSAneesh Kumar K.V 236371461b0fSAlexey Kardashevskiy /* 2364627b84f4SGonglei * Implementation of an interface to adjust firmware path 236571461b0fSAlexey Kardashevskiy * for the bootindex property handling. 236671461b0fSAlexey Kardashevskiy */ 236771461b0fSAlexey Kardashevskiy static char *spapr_get_fw_dev_path(FWPathProvider *p, BusState *bus, 236871461b0fSAlexey Kardashevskiy DeviceState *dev) 236971461b0fSAlexey Kardashevskiy { 237071461b0fSAlexey Kardashevskiy #define CAST(type, obj, name) \ 237171461b0fSAlexey Kardashevskiy ((type *)object_dynamic_cast(OBJECT(obj), (name))) 237271461b0fSAlexey Kardashevskiy SCSIDevice *d = CAST(SCSIDevice, dev, TYPE_SCSI_DEVICE); 237371461b0fSAlexey Kardashevskiy sPAPRPHBState *phb = CAST(sPAPRPHBState, dev, TYPE_SPAPR_PCI_HOST_BRIDGE); 237471461b0fSAlexey Kardashevskiy 237571461b0fSAlexey Kardashevskiy if (d) { 237671461b0fSAlexey Kardashevskiy void *spapr = CAST(void, bus->parent, "spapr-vscsi"); 237771461b0fSAlexey Kardashevskiy VirtIOSCSI *virtio = CAST(VirtIOSCSI, bus->parent, TYPE_VIRTIO_SCSI); 237871461b0fSAlexey Kardashevskiy USBDevice *usb = CAST(USBDevice, bus->parent, TYPE_USB_DEVICE); 237971461b0fSAlexey Kardashevskiy 238071461b0fSAlexey Kardashevskiy if (spapr) { 238171461b0fSAlexey Kardashevskiy /* 238271461b0fSAlexey Kardashevskiy * Replace "channel@0/disk@0,0" with "disk@8000000000000000": 238371461b0fSAlexey Kardashevskiy * We use SRP luns of the form 8000 | (bus << 8) | (id << 5) | lun 238471461b0fSAlexey Kardashevskiy * in the top 16 bits of the 64-bit LUN 238571461b0fSAlexey Kardashevskiy */ 238671461b0fSAlexey Kardashevskiy unsigned id = 0x8000 | (d->id << 8) | d->lun; 238771461b0fSAlexey Kardashevskiy return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev), 238871461b0fSAlexey Kardashevskiy (uint64_t)id << 48); 238971461b0fSAlexey Kardashevskiy } else if (virtio) { 239071461b0fSAlexey Kardashevskiy /* 239171461b0fSAlexey Kardashevskiy * We use SRP luns of the form 01000000 | (target << 8) | lun 239271461b0fSAlexey Kardashevskiy * in the top 32 bits of the 64-bit LUN 239371461b0fSAlexey Kardashevskiy * Note: the quote above is from SLOF and it is wrong, 239471461b0fSAlexey Kardashevskiy * the actual binding is: 239571461b0fSAlexey Kardashevskiy * swap 0100 or 10 << or 20 << ( target lun-id -- srplun ) 239671461b0fSAlexey Kardashevskiy */ 239771461b0fSAlexey Kardashevskiy unsigned id = 0x1000000 | (d->id << 16) | d->lun; 239871461b0fSAlexey Kardashevskiy return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev), 239971461b0fSAlexey Kardashevskiy (uint64_t)id << 32); 240071461b0fSAlexey Kardashevskiy } else if (usb) { 240171461b0fSAlexey Kardashevskiy /* 240271461b0fSAlexey Kardashevskiy * We use SRP luns of the form 01000000 | (usb-port << 16) | lun 240371461b0fSAlexey Kardashevskiy * in the top 32 bits of the 64-bit LUN 240471461b0fSAlexey Kardashevskiy */ 240571461b0fSAlexey Kardashevskiy unsigned usb_port = atoi(usb->port->path); 240671461b0fSAlexey Kardashevskiy unsigned id = 0x1000000 | (usb_port << 16) | d->lun; 240771461b0fSAlexey Kardashevskiy return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev), 240871461b0fSAlexey Kardashevskiy (uint64_t)id << 32); 240971461b0fSAlexey Kardashevskiy } 241071461b0fSAlexey Kardashevskiy } 241171461b0fSAlexey Kardashevskiy 2412b99260ebSThomas Huth /* 2413b99260ebSThomas Huth * SLOF probes the USB devices, and if it recognizes that the device is a 2414b99260ebSThomas Huth * storage device, it changes its name to "storage" instead of "usb-host", 2415b99260ebSThomas Huth * and additionally adds a child node for the SCSI LUN, so the correct 2416b99260ebSThomas Huth * boot path in SLOF is something like .../storage@1/disk@xxx" instead. 2417b99260ebSThomas Huth */ 2418b99260ebSThomas Huth if (strcmp("usb-host", qdev_fw_name(dev)) == 0) { 2419b99260ebSThomas Huth USBDevice *usbdev = CAST(USBDevice, dev, TYPE_USB_DEVICE); 2420b99260ebSThomas Huth if (usb_host_dev_is_scsi_storage(usbdev)) { 2421b99260ebSThomas Huth return g_strdup_printf("storage@%s/disk", usbdev->port->path); 2422b99260ebSThomas Huth } 2423b99260ebSThomas Huth } 2424b99260ebSThomas Huth 242571461b0fSAlexey Kardashevskiy if (phb) { 242671461b0fSAlexey Kardashevskiy /* Replace "pci" with "pci@800000020000000" */ 242771461b0fSAlexey Kardashevskiy return g_strdup_printf("pci@%"PRIX64, phb->buid); 242871461b0fSAlexey Kardashevskiy } 242971461b0fSAlexey Kardashevskiy 243071461b0fSAlexey Kardashevskiy return NULL; 243171461b0fSAlexey Kardashevskiy } 243271461b0fSAlexey Kardashevskiy 243323825581SEduardo Habkost static char *spapr_get_kvm_type(Object *obj, Error **errp) 243423825581SEduardo Habkost { 243528e02042SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 243623825581SEduardo Habkost 243728e02042SDavid Gibson return g_strdup(spapr->kvm_type); 243823825581SEduardo Habkost } 243923825581SEduardo Habkost 244023825581SEduardo Habkost static void spapr_set_kvm_type(Object *obj, const char *value, Error **errp) 244123825581SEduardo Habkost { 244228e02042SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 244323825581SEduardo Habkost 244428e02042SDavid Gibson g_free(spapr->kvm_type); 244528e02042SDavid Gibson spapr->kvm_type = g_strdup(value); 244623825581SEduardo Habkost } 244723825581SEduardo Habkost 2448f6229214SMichael Roth static bool spapr_get_modern_hotplug_events(Object *obj, Error **errp) 2449f6229214SMichael Roth { 2450f6229214SMichael Roth sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 2451f6229214SMichael Roth 2452f6229214SMichael Roth return spapr->use_hotplug_event_source; 2453f6229214SMichael Roth } 2454f6229214SMichael Roth 2455f6229214SMichael Roth static void spapr_set_modern_hotplug_events(Object *obj, bool value, 2456f6229214SMichael Roth Error **errp) 2457f6229214SMichael Roth { 2458f6229214SMichael Roth sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 2459f6229214SMichael Roth 2460f6229214SMichael Roth spapr->use_hotplug_event_source = value; 2461f6229214SMichael Roth } 2462f6229214SMichael Roth 246323825581SEduardo Habkost static void spapr_machine_initfn(Object *obj) 246423825581SEduardo Habkost { 2465715c5407SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 2466715c5407SDavid Gibson 2467715c5407SDavid Gibson spapr->htab_fd = -1; 2468f6229214SMichael Roth spapr->use_hotplug_event_source = true; 246923825581SEduardo Habkost object_property_add_str(obj, "kvm-type", 247023825581SEduardo Habkost spapr_get_kvm_type, spapr_set_kvm_type, NULL); 247149d2e648SMarcel Apfelbaum object_property_set_description(obj, "kvm-type", 247249d2e648SMarcel Apfelbaum "Specifies the KVM virtualization mode (HV, PR)", 247349d2e648SMarcel Apfelbaum NULL); 2474f6229214SMichael Roth object_property_add_bool(obj, "modern-hotplug-events", 2475f6229214SMichael Roth spapr_get_modern_hotplug_events, 2476f6229214SMichael Roth spapr_set_modern_hotplug_events, 2477f6229214SMichael Roth NULL); 2478f6229214SMichael Roth object_property_set_description(obj, "modern-hotplug-events", 2479f6229214SMichael Roth "Use dedicated hotplug event mechanism in" 2480f6229214SMichael Roth " place of standard EPOW events when possible" 2481f6229214SMichael Roth " (required for memory hot-unplug support)", 2482f6229214SMichael Roth NULL); 248323825581SEduardo Habkost } 248423825581SEduardo Habkost 248587bbdd9cSDavid Gibson static void spapr_machine_finalizefn(Object *obj) 248687bbdd9cSDavid Gibson { 248787bbdd9cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 248887bbdd9cSDavid Gibson 248987bbdd9cSDavid Gibson g_free(spapr->kvm_type); 249087bbdd9cSDavid Gibson } 249187bbdd9cSDavid Gibson 24921c7ad77eSNicholas Piggin void spapr_do_system_reset_on_cpu(CPUState *cs, run_on_cpu_data arg) 249334316482SAlexey Kardashevskiy { 249434316482SAlexey Kardashevskiy cpu_synchronize_state(cs); 249534316482SAlexey Kardashevskiy ppc_cpu_do_system_reset(cs); 249634316482SAlexey Kardashevskiy } 249734316482SAlexey Kardashevskiy 249834316482SAlexey Kardashevskiy static void spapr_nmi(NMIState *n, int cpu_index, Error **errp) 249934316482SAlexey Kardashevskiy { 250034316482SAlexey Kardashevskiy CPUState *cs; 250134316482SAlexey Kardashevskiy 250234316482SAlexey Kardashevskiy CPU_FOREACH(cs) { 25031c7ad77eSNicholas Piggin async_run_on_cpu(cs, spapr_do_system_reset_on_cpu, RUN_ON_CPU_NULL); 250434316482SAlexey Kardashevskiy } 250534316482SAlexey Kardashevskiy } 250634316482SAlexey Kardashevskiy 250779b78a6bSMichael Roth static void spapr_add_lmbs(DeviceState *dev, uint64_t addr_start, uint64_t size, 250879b78a6bSMichael Roth uint32_t node, bool dedicated_hp_event_source, 250979b78a6bSMichael Roth Error **errp) 2510c20d332aSBharata B Rao { 2511c20d332aSBharata B Rao sPAPRDRConnector *drc; 2512c20d332aSBharata B Rao sPAPRDRConnectorClass *drck; 2513c20d332aSBharata B Rao uint32_t nr_lmbs = size/SPAPR_MEMORY_BLOCK_SIZE; 2514c20d332aSBharata B Rao int i, fdt_offset, fdt_size; 2515c20d332aSBharata B Rao void *fdt; 251679b78a6bSMichael Roth uint64_t addr = addr_start; 2517c20d332aSBharata B Rao 2518c20d332aSBharata B Rao for (i = 0; i < nr_lmbs; i++) { 2519c20d332aSBharata B Rao drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_LMB, 2520c20d332aSBharata B Rao addr/SPAPR_MEMORY_BLOCK_SIZE); 2521c20d332aSBharata B Rao g_assert(drc); 2522c20d332aSBharata B Rao 2523c20d332aSBharata B Rao fdt = create_device_tree(&fdt_size); 2524c20d332aSBharata B Rao fdt_offset = spapr_populate_memory_node(fdt, node, addr, 2525c20d332aSBharata B Rao SPAPR_MEMORY_BLOCK_SIZE); 2526c20d332aSBharata B Rao 2527c20d332aSBharata B Rao drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 2528c20d332aSBharata B Rao drck->attach(drc, dev, fdt, fdt_offset, !dev->hotplugged, errp); 2529c20d332aSBharata B Rao addr += SPAPR_MEMORY_BLOCK_SIZE; 25305c0139a8SMichael Roth if (!dev->hotplugged) { 25315c0139a8SMichael Roth /* guests expect coldplugged LMBs to be pre-allocated */ 25325c0139a8SMichael Roth drck->set_allocation_state(drc, SPAPR_DR_ALLOCATION_STATE_USABLE); 25335c0139a8SMichael Roth drck->set_isolation_state(drc, SPAPR_DR_ISOLATION_STATE_UNISOLATED); 25345c0139a8SMichael Roth } 2535c20d332aSBharata B Rao } 25365dd5238cSJianjun Duan /* send hotplug notification to the 25375dd5238cSJianjun Duan * guest only in case of hotplugged memory 25385dd5238cSJianjun Duan */ 25395dd5238cSJianjun Duan if (dev->hotplugged) { 254079b78a6bSMichael Roth if (dedicated_hp_event_source) { 254179b78a6bSMichael Roth drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_LMB, 254279b78a6bSMichael Roth addr_start / SPAPR_MEMORY_BLOCK_SIZE); 254379b78a6bSMichael Roth drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 254479b78a6bSMichael Roth spapr_hotplug_req_add_by_count_indexed(SPAPR_DR_CONNECTOR_TYPE_LMB, 254579b78a6bSMichael Roth nr_lmbs, 254679b78a6bSMichael Roth drck->get_index(drc)); 254779b78a6bSMichael Roth } else { 254879b78a6bSMichael Roth spapr_hotplug_req_add_by_count(SPAPR_DR_CONNECTOR_TYPE_LMB, 254979b78a6bSMichael Roth nr_lmbs); 255079b78a6bSMichael Roth } 2551c20d332aSBharata B Rao } 25525dd5238cSJianjun Duan } 2553c20d332aSBharata B Rao 2554c20d332aSBharata B Rao static void spapr_memory_plug(HotplugHandler *hotplug_dev, DeviceState *dev, 2555c20d332aSBharata B Rao uint32_t node, Error **errp) 2556c20d332aSBharata B Rao { 2557c20d332aSBharata B Rao Error *local_err = NULL; 2558c20d332aSBharata B Rao sPAPRMachineState *ms = SPAPR_MACHINE(hotplug_dev); 2559c20d332aSBharata B Rao PCDIMMDevice *dimm = PC_DIMM(dev); 2560c20d332aSBharata B Rao PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); 2561c20d332aSBharata B Rao MemoryRegion *mr = ddc->get_memory_region(dimm); 2562c20d332aSBharata B Rao uint64_t align = memory_region_get_alignment(mr); 2563c20d332aSBharata B Rao uint64_t size = memory_region_size(mr); 2564c20d332aSBharata B Rao uint64_t addr; 2565df587133SThomas Huth char *mem_dev; 2566c20d332aSBharata B Rao 2567c20d332aSBharata B Rao if (size % SPAPR_MEMORY_BLOCK_SIZE) { 2568c20d332aSBharata B Rao error_setg(&local_err, "Hotplugged memory size must be a multiple of " 2569c20d332aSBharata B Rao "%lld MB", SPAPR_MEMORY_BLOCK_SIZE/M_BYTE); 2570c20d332aSBharata B Rao goto out; 2571c20d332aSBharata B Rao } 2572c20d332aSBharata B Rao 2573df587133SThomas Huth mem_dev = object_property_get_str(OBJECT(dimm), PC_DIMM_MEMDEV_PROP, NULL); 2574df587133SThomas Huth if (mem_dev && !kvmppc_is_mem_backend_page_size_ok(mem_dev)) { 2575df587133SThomas Huth error_setg(&local_err, "Memory backend has bad page size. " 2576df587133SThomas Huth "Use 'memory-backend-file' with correct mem-path."); 2577df587133SThomas Huth goto out; 2578df587133SThomas Huth } 2579df587133SThomas Huth 2580d6a9b0b8SMichael S. Tsirkin pc_dimm_memory_plug(dev, &ms->hotplug_memory, mr, align, &local_err); 2581c20d332aSBharata B Rao if (local_err) { 2582c20d332aSBharata B Rao goto out; 2583c20d332aSBharata B Rao } 2584c20d332aSBharata B Rao 2585c20d332aSBharata B Rao addr = object_property_get_int(OBJECT(dimm), PC_DIMM_ADDR_PROP, &local_err); 2586c20d332aSBharata B Rao if (local_err) { 2587c20d332aSBharata B Rao pc_dimm_memory_unplug(dev, &ms->hotplug_memory, mr); 2588c20d332aSBharata B Rao goto out; 2589c20d332aSBharata B Rao } 2590c20d332aSBharata B Rao 259179b78a6bSMichael Roth spapr_add_lmbs(dev, addr, size, node, 259279b78a6bSMichael Roth spapr_ovec_test(ms->ov5_cas, OV5_HP_EVT), 259379b78a6bSMichael Roth &error_abort); 2594c20d332aSBharata B Rao 2595c20d332aSBharata B Rao out: 2596c20d332aSBharata B Rao error_propagate(errp, local_err); 2597c20d332aSBharata B Rao } 2598c20d332aSBharata B Rao 2599cf632463SBharata B Rao typedef struct sPAPRDIMMState { 2600cf632463SBharata B Rao uint32_t nr_lmbs; 2601cf632463SBharata B Rao } sPAPRDIMMState; 2602cf632463SBharata B Rao 2603cf632463SBharata B Rao static void spapr_lmb_release(DeviceState *dev, void *opaque) 2604cf632463SBharata B Rao { 2605cf632463SBharata B Rao sPAPRDIMMState *ds = (sPAPRDIMMState *)opaque; 2606cf632463SBharata B Rao HotplugHandler *hotplug_ctrl; 2607cf632463SBharata B Rao 2608cf632463SBharata B Rao if (--ds->nr_lmbs) { 2609cf632463SBharata B Rao return; 2610cf632463SBharata B Rao } 2611cf632463SBharata B Rao 2612cf632463SBharata B Rao g_free(ds); 2613cf632463SBharata B Rao 2614cf632463SBharata B Rao /* 2615cf632463SBharata B Rao * Now that all the LMBs have been removed by the guest, call the 2616cf632463SBharata B Rao * pc-dimm unplug handler to cleanup up the pc-dimm device. 2617cf632463SBharata B Rao */ 2618cf632463SBharata B Rao hotplug_ctrl = qdev_get_hotplug_handler(dev); 2619cf632463SBharata B Rao hotplug_handler_unplug(hotplug_ctrl, dev, &error_abort); 2620cf632463SBharata B Rao } 2621cf632463SBharata B Rao 2622cf632463SBharata B Rao static void spapr_del_lmbs(DeviceState *dev, uint64_t addr_start, uint64_t size, 2623cf632463SBharata B Rao Error **errp) 2624cf632463SBharata B Rao { 2625cf632463SBharata B Rao sPAPRDRConnector *drc; 2626cf632463SBharata B Rao sPAPRDRConnectorClass *drck; 2627cf632463SBharata B Rao uint32_t nr_lmbs = size / SPAPR_MEMORY_BLOCK_SIZE; 2628cf632463SBharata B Rao int i; 2629cf632463SBharata B Rao sPAPRDIMMState *ds = g_malloc0(sizeof(sPAPRDIMMState)); 2630cf632463SBharata B Rao uint64_t addr = addr_start; 2631cf632463SBharata B Rao 2632cf632463SBharata B Rao ds->nr_lmbs = nr_lmbs; 2633cf632463SBharata B Rao for (i = 0; i < nr_lmbs; i++) { 2634cf632463SBharata B Rao drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_LMB, 2635cf632463SBharata B Rao addr / SPAPR_MEMORY_BLOCK_SIZE); 2636cf632463SBharata B Rao g_assert(drc); 2637cf632463SBharata B Rao 2638cf632463SBharata B Rao drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 2639cf632463SBharata B Rao drck->detach(drc, dev, spapr_lmb_release, ds, errp); 2640cf632463SBharata B Rao addr += SPAPR_MEMORY_BLOCK_SIZE; 2641cf632463SBharata B Rao } 2642cf632463SBharata B Rao 2643cf632463SBharata B Rao drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_LMB, 2644cf632463SBharata B Rao addr_start / SPAPR_MEMORY_BLOCK_SIZE); 2645cf632463SBharata B Rao drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 2646cf632463SBharata B Rao spapr_hotplug_req_remove_by_count_indexed(SPAPR_DR_CONNECTOR_TYPE_LMB, 2647cf632463SBharata B Rao nr_lmbs, 2648cf632463SBharata B Rao drck->get_index(drc)); 2649cf632463SBharata B Rao } 2650cf632463SBharata B Rao 2651cf632463SBharata B Rao static void spapr_memory_unplug(HotplugHandler *hotplug_dev, DeviceState *dev, 2652cf632463SBharata B Rao Error **errp) 2653cf632463SBharata B Rao { 2654cf632463SBharata B Rao sPAPRMachineState *ms = SPAPR_MACHINE(hotplug_dev); 2655cf632463SBharata B Rao PCDIMMDevice *dimm = PC_DIMM(dev); 2656cf632463SBharata B Rao PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); 2657cf632463SBharata B Rao MemoryRegion *mr = ddc->get_memory_region(dimm); 2658cf632463SBharata B Rao 2659cf632463SBharata B Rao pc_dimm_memory_unplug(dev, &ms->hotplug_memory, mr); 2660cf632463SBharata B Rao object_unparent(OBJECT(dev)); 2661cf632463SBharata B Rao } 2662cf632463SBharata B Rao 2663cf632463SBharata B Rao static void spapr_memory_unplug_request(HotplugHandler *hotplug_dev, 2664cf632463SBharata B Rao DeviceState *dev, Error **errp) 2665cf632463SBharata B Rao { 2666cf632463SBharata B Rao Error *local_err = NULL; 2667cf632463SBharata B Rao PCDIMMDevice *dimm = PC_DIMM(dev); 2668cf632463SBharata B Rao PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); 2669cf632463SBharata B Rao MemoryRegion *mr = ddc->get_memory_region(dimm); 2670cf632463SBharata B Rao uint64_t size = memory_region_size(mr); 2671cf632463SBharata B Rao uint64_t addr; 2672cf632463SBharata B Rao 2673cf632463SBharata B Rao addr = object_property_get_int(OBJECT(dimm), PC_DIMM_ADDR_PROP, &local_err); 2674cf632463SBharata B Rao if (local_err) { 2675cf632463SBharata B Rao goto out; 2676cf632463SBharata B Rao } 2677cf632463SBharata B Rao 2678cf632463SBharata B Rao spapr_del_lmbs(dev, addr, size, &error_abort); 2679cf632463SBharata B Rao out: 2680cf632463SBharata B Rao error_propagate(errp, local_err); 2681cf632463SBharata B Rao } 2682cf632463SBharata B Rao 2683af81cf32SBharata B Rao void *spapr_populate_hotplug_cpu_dt(CPUState *cs, int *fdt_offset, 2684af81cf32SBharata B Rao sPAPRMachineState *spapr) 2685af81cf32SBharata B Rao { 2686af81cf32SBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(cs); 2687af81cf32SBharata B Rao DeviceClass *dc = DEVICE_GET_CLASS(cs); 2688af81cf32SBharata B Rao int id = ppc_get_vcpu_dt_id(cpu); 2689af81cf32SBharata B Rao void *fdt; 2690af81cf32SBharata B Rao int offset, fdt_size; 2691af81cf32SBharata B Rao char *nodename; 2692af81cf32SBharata B Rao 2693af81cf32SBharata B Rao fdt = create_device_tree(&fdt_size); 2694af81cf32SBharata B Rao nodename = g_strdup_printf("%s@%x", dc->fw_name, id); 2695af81cf32SBharata B Rao offset = fdt_add_subnode(fdt, 0, nodename); 2696af81cf32SBharata B Rao 2697af81cf32SBharata B Rao spapr_populate_cpu_dt(cs, fdt, offset, spapr); 2698af81cf32SBharata B Rao g_free(nodename); 2699af81cf32SBharata B Rao 2700af81cf32SBharata B Rao *fdt_offset = offset; 2701af81cf32SBharata B Rao return fdt; 2702af81cf32SBharata B Rao } 2703af81cf32SBharata B Rao 2704115debf2SIgor Mammedov static void spapr_core_unplug(HotplugHandler *hotplug_dev, DeviceState *dev, 2705115debf2SIgor Mammedov Error **errp) 2706ff9006ddSIgor Mammedov { 2707535455fdSIgor Mammedov MachineState *ms = MACHINE(qdev_get_machine()); 2708ff9006ddSIgor Mammedov CPUCore *cc = CPU_CORE(dev); 2709535455fdSIgor Mammedov CPUArchId *core_slot = spapr_find_cpu_slot(ms, cc->core_id, NULL); 2710ff9006ddSIgor Mammedov 2711535455fdSIgor Mammedov core_slot->cpu = NULL; 2712ff9006ddSIgor Mammedov object_unparent(OBJECT(dev)); 2713ff9006ddSIgor Mammedov } 2714ff9006ddSIgor Mammedov 2715115debf2SIgor Mammedov static void spapr_core_release(DeviceState *dev, void *opaque) 2716115debf2SIgor Mammedov { 2717115debf2SIgor Mammedov HotplugHandler *hotplug_ctrl; 2718115debf2SIgor Mammedov 2719115debf2SIgor Mammedov hotplug_ctrl = qdev_get_hotplug_handler(dev); 2720115debf2SIgor Mammedov hotplug_handler_unplug(hotplug_ctrl, dev, &error_abort); 2721115debf2SIgor Mammedov } 2722115debf2SIgor Mammedov 2723115debf2SIgor Mammedov static 2724115debf2SIgor Mammedov void spapr_core_unplug_request(HotplugHandler *hotplug_dev, DeviceState *dev, 2725ff9006ddSIgor Mammedov Error **errp) 2726ff9006ddSIgor Mammedov { 2727535455fdSIgor Mammedov int index; 2728535455fdSIgor Mammedov sPAPRDRConnector *drc; 2729ff9006ddSIgor Mammedov sPAPRDRConnectorClass *drck; 2730ff9006ddSIgor Mammedov Error *local_err = NULL; 2731535455fdSIgor Mammedov CPUCore *cc = CPU_CORE(dev); 2732535455fdSIgor Mammedov int smt = kvmppc_smt_threads(); 2733ff9006ddSIgor Mammedov 2734535455fdSIgor Mammedov if (!spapr_find_cpu_slot(MACHINE(hotplug_dev), cc->core_id, &index)) { 2735535455fdSIgor Mammedov error_setg(errp, "Unable to find CPU core with core-id: %d", 2736535455fdSIgor Mammedov cc->core_id); 2737535455fdSIgor Mammedov return; 2738535455fdSIgor Mammedov } 2739ff9006ddSIgor Mammedov if (index == 0) { 2740ff9006ddSIgor Mammedov error_setg(errp, "Boot CPU core may not be unplugged"); 2741ff9006ddSIgor Mammedov return; 2742ff9006ddSIgor Mammedov } 2743ff9006ddSIgor Mammedov 2744535455fdSIgor Mammedov drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_CPU, index * smt); 2745ff9006ddSIgor Mammedov g_assert(drc); 2746ff9006ddSIgor Mammedov 2747ff9006ddSIgor Mammedov drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 2748ff9006ddSIgor Mammedov drck->detach(drc, dev, spapr_core_release, NULL, &local_err); 2749ff9006ddSIgor Mammedov if (local_err) { 2750ff9006ddSIgor Mammedov error_propagate(errp, local_err); 2751ff9006ddSIgor Mammedov return; 2752ff9006ddSIgor Mammedov } 2753ff9006ddSIgor Mammedov 2754ff9006ddSIgor Mammedov spapr_hotplug_req_remove_by_index(drc); 2755ff9006ddSIgor Mammedov } 2756ff9006ddSIgor Mammedov 2757ff9006ddSIgor Mammedov static void spapr_core_plug(HotplugHandler *hotplug_dev, DeviceState *dev, 2758ff9006ddSIgor Mammedov Error **errp) 2759ff9006ddSIgor Mammedov { 2760ff9006ddSIgor Mammedov sPAPRMachineState *spapr = SPAPR_MACHINE(OBJECT(hotplug_dev)); 2761ff9006ddSIgor Mammedov MachineClass *mc = MACHINE_GET_CLASS(spapr); 2762ff9006ddSIgor Mammedov sPAPRCPUCore *core = SPAPR_CPU_CORE(OBJECT(dev)); 2763ff9006ddSIgor Mammedov CPUCore *cc = CPU_CORE(dev); 2764ff9006ddSIgor Mammedov CPUState *cs = CPU(core->threads); 2765ff9006ddSIgor Mammedov sPAPRDRConnector *drc; 2766ff9006ddSIgor Mammedov Error *local_err = NULL; 2767ff9006ddSIgor Mammedov void *fdt = NULL; 2768ff9006ddSIgor Mammedov int fdt_offset = 0; 2769ff9006ddSIgor Mammedov int smt = kvmppc_smt_threads(); 2770535455fdSIgor Mammedov CPUArchId *core_slot; 2771535455fdSIgor Mammedov int index; 2772ff9006ddSIgor Mammedov 2773535455fdSIgor Mammedov core_slot = spapr_find_cpu_slot(MACHINE(hotplug_dev), cc->core_id, &index); 2774535455fdSIgor Mammedov if (!core_slot) { 2775535455fdSIgor Mammedov error_setg(errp, "Unable to find CPU core with core-id: %d", 2776535455fdSIgor Mammedov cc->core_id); 2777535455fdSIgor Mammedov return; 2778535455fdSIgor Mammedov } 2779ff9006ddSIgor Mammedov drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_CPU, index * smt); 2780ff9006ddSIgor Mammedov 2781c5514d0eSIgor Mammedov g_assert(drc || !mc->has_hotpluggable_cpus); 2782ff9006ddSIgor Mammedov 2783ff9006ddSIgor Mammedov /* 2784ff9006ddSIgor Mammedov * Setup CPU DT entries only for hotplugged CPUs. For boot time or 2785ff9006ddSIgor Mammedov * coldplugged CPUs DT entries are setup in spapr_build_fdt(). 2786ff9006ddSIgor Mammedov */ 2787ff9006ddSIgor Mammedov if (dev->hotplugged) { 2788ff9006ddSIgor Mammedov fdt = spapr_populate_hotplug_cpu_dt(cs, &fdt_offset, spapr); 2789ff9006ddSIgor Mammedov } 2790ff9006ddSIgor Mammedov 2791ff9006ddSIgor Mammedov if (drc) { 2792ff9006ddSIgor Mammedov sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 2793ff9006ddSIgor Mammedov drck->attach(drc, dev, fdt, fdt_offset, !dev->hotplugged, &local_err); 2794ff9006ddSIgor Mammedov if (local_err) { 2795ff9006ddSIgor Mammedov g_free(fdt); 2796ff9006ddSIgor Mammedov error_propagate(errp, local_err); 2797ff9006ddSIgor Mammedov return; 2798ff9006ddSIgor Mammedov } 2799ff9006ddSIgor Mammedov } 2800ff9006ddSIgor Mammedov 2801ff9006ddSIgor Mammedov if (dev->hotplugged) { 2802ff9006ddSIgor Mammedov /* 2803ff9006ddSIgor Mammedov * Send hotplug notification interrupt to the guest only in case 2804ff9006ddSIgor Mammedov * of hotplugged CPUs. 2805ff9006ddSIgor Mammedov */ 2806ff9006ddSIgor Mammedov spapr_hotplug_req_add_by_index(drc); 2807ff9006ddSIgor Mammedov } else { 2808ff9006ddSIgor Mammedov /* 2809ff9006ddSIgor Mammedov * Set the right DRC states for cold plugged CPU. 2810ff9006ddSIgor Mammedov */ 2811ff9006ddSIgor Mammedov if (drc) { 2812ff9006ddSIgor Mammedov sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 2813ff9006ddSIgor Mammedov drck->set_allocation_state(drc, SPAPR_DR_ALLOCATION_STATE_USABLE); 2814ff9006ddSIgor Mammedov drck->set_isolation_state(drc, SPAPR_DR_ISOLATION_STATE_UNISOLATED); 2815ff9006ddSIgor Mammedov } 2816ff9006ddSIgor Mammedov } 2817535455fdSIgor Mammedov core_slot->cpu = OBJECT(dev); 2818ff9006ddSIgor Mammedov } 2819ff9006ddSIgor Mammedov 2820ff9006ddSIgor Mammedov static void spapr_core_pre_plug(HotplugHandler *hotplug_dev, DeviceState *dev, 2821ff9006ddSIgor Mammedov Error **errp) 2822ff9006ddSIgor Mammedov { 2823ff9006ddSIgor Mammedov MachineState *machine = MACHINE(OBJECT(hotplug_dev)); 2824ff9006ddSIgor Mammedov MachineClass *mc = MACHINE_GET_CLASS(hotplug_dev); 2825ff9006ddSIgor Mammedov Error *local_err = NULL; 2826ff9006ddSIgor Mammedov CPUCore *cc = CPU_CORE(dev); 2827*0b8497f0SIgor Mammedov sPAPRCPUCore *sc = SPAPR_CPU_CORE(dev); 2828ff9006ddSIgor Mammedov char *base_core_type = spapr_get_cpu_core_type(machine->cpu_model); 2829ff9006ddSIgor Mammedov const char *type = object_get_typename(OBJECT(dev)); 2830535455fdSIgor Mammedov CPUArchId *core_slot; 2831*0b8497f0SIgor Mammedov int node_id; 2832535455fdSIgor Mammedov int index; 2833ff9006ddSIgor Mammedov 2834c5514d0eSIgor Mammedov if (dev->hotplugged && !mc->has_hotpluggable_cpus) { 2835ff9006ddSIgor Mammedov error_setg(&local_err, "CPU hotplug not supported for this machine"); 2836ff9006ddSIgor Mammedov goto out; 2837ff9006ddSIgor Mammedov } 2838ff9006ddSIgor Mammedov 2839ff9006ddSIgor Mammedov if (strcmp(base_core_type, type)) { 2840ff9006ddSIgor Mammedov error_setg(&local_err, "CPU core type should be %s", base_core_type); 2841ff9006ddSIgor Mammedov goto out; 2842ff9006ddSIgor Mammedov } 2843ff9006ddSIgor Mammedov 2844ff9006ddSIgor Mammedov if (cc->core_id % smp_threads) { 2845ff9006ddSIgor Mammedov error_setg(&local_err, "invalid core id %d", cc->core_id); 2846ff9006ddSIgor Mammedov goto out; 2847ff9006ddSIgor Mammedov } 2848ff9006ddSIgor Mammedov 28498149e299SDavid Gibson if (cc->nr_threads != smp_threads) { 28508149e299SDavid Gibson error_setg(errp, "invalid nr-threads %d, must be %d", 28518149e299SDavid Gibson cc->nr_threads, smp_threads); 28528149e299SDavid Gibson return; 28538149e299SDavid Gibson } 28548149e299SDavid Gibson 2855535455fdSIgor Mammedov core_slot = spapr_find_cpu_slot(MACHINE(hotplug_dev), cc->core_id, &index); 2856535455fdSIgor Mammedov if (!core_slot) { 2857ff9006ddSIgor Mammedov error_setg(&local_err, "core id %d out of range", cc->core_id); 2858ff9006ddSIgor Mammedov goto out; 2859ff9006ddSIgor Mammedov } 2860ff9006ddSIgor Mammedov 2861535455fdSIgor Mammedov if (core_slot->cpu) { 2862ff9006ddSIgor Mammedov error_setg(&local_err, "core %d already populated", cc->core_id); 2863ff9006ddSIgor Mammedov goto out; 2864ff9006ddSIgor Mammedov } 2865ff9006ddSIgor Mammedov 2866*0b8497f0SIgor Mammedov node_id = numa_get_node_for_cpu(cc->core_id); 2867*0b8497f0SIgor Mammedov if (node_id == nb_numa_nodes) { 2868*0b8497f0SIgor Mammedov /* by default CPUState::numa_node was 0 if it's not set via CLI 2869*0b8497f0SIgor Mammedov * keep it this way for now but in future we probably should 2870*0b8497f0SIgor Mammedov * refuse to start up with incomplete numa mapping */ 2871*0b8497f0SIgor Mammedov node_id = 0; 2872*0b8497f0SIgor Mammedov } 2873*0b8497f0SIgor Mammedov if (sc->node_id == CPU_UNSET_NUMA_NODE_ID) { 2874*0b8497f0SIgor Mammedov sc->node_id = node_id; 2875*0b8497f0SIgor Mammedov } else if (sc->node_id != node_id) { 2876*0b8497f0SIgor Mammedov error_setg(&local_err, "node-id %d must match numa node specified" 2877*0b8497f0SIgor Mammedov "with -numa option for cpu-index %d", sc->node_id, cc->core_id); 2878*0b8497f0SIgor Mammedov goto out; 2879*0b8497f0SIgor Mammedov } 2880*0b8497f0SIgor Mammedov 2881ff9006ddSIgor Mammedov out: 2882ff9006ddSIgor Mammedov g_free(base_core_type); 2883ff9006ddSIgor Mammedov error_propagate(errp, local_err); 2884ff9006ddSIgor Mammedov } 2885ff9006ddSIgor Mammedov 2886c20d332aSBharata B Rao static void spapr_machine_device_plug(HotplugHandler *hotplug_dev, 2887c20d332aSBharata B Rao DeviceState *dev, Error **errp) 2888c20d332aSBharata B Rao { 2889c20d332aSBharata B Rao sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(qdev_get_machine()); 2890c20d332aSBharata B Rao 2891c20d332aSBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { 2892b556854bSBharata B Rao int node; 2893c20d332aSBharata B Rao 2894c20d332aSBharata B Rao if (!smc->dr_lmb_enabled) { 2895c20d332aSBharata B Rao error_setg(errp, "Memory hotplug not supported for this machine"); 2896c20d332aSBharata B Rao return; 2897c20d332aSBharata B Rao } 2898c20d332aSBharata B Rao node = object_property_get_int(OBJECT(dev), PC_DIMM_NODE_PROP, errp); 2899c20d332aSBharata B Rao if (*errp) { 2900c20d332aSBharata B Rao return; 2901c20d332aSBharata B Rao } 29021a5512bbSGonglei if (node < 0 || node >= MAX_NODES) { 29031a5512bbSGonglei error_setg(errp, "Invaild node %d", node); 29041a5512bbSGonglei return; 29051a5512bbSGonglei } 2906c20d332aSBharata B Rao 2907b556854bSBharata B Rao /* 2908b556854bSBharata B Rao * Currently PowerPC kernel doesn't allow hot-adding memory to 2909b556854bSBharata B Rao * memory-less node, but instead will silently add the memory 2910b556854bSBharata B Rao * to the first node that has some memory. This causes two 2911b556854bSBharata B Rao * unexpected behaviours for the user. 2912b556854bSBharata B Rao * 2913b556854bSBharata B Rao * - Memory gets hotplugged to a different node than what the user 2914b556854bSBharata B Rao * specified. 2915b556854bSBharata B Rao * - Since pc-dimm subsystem in QEMU still thinks that memory belongs 2916b556854bSBharata B Rao * to memory-less node, a reboot will set things accordingly 2917b556854bSBharata B Rao * and the previously hotplugged memory now ends in the right node. 2918b556854bSBharata B Rao * This appears as if some memory moved from one node to another. 2919b556854bSBharata B Rao * 2920b556854bSBharata B Rao * So until kernel starts supporting memory hotplug to memory-less 2921b556854bSBharata B Rao * nodes, just prevent such attempts upfront in QEMU. 2922b556854bSBharata B Rao */ 2923b556854bSBharata B Rao if (nb_numa_nodes && !numa_info[node].node_mem) { 2924b556854bSBharata B Rao error_setg(errp, "Can't hotplug memory to memory-less node %d", 2925b556854bSBharata B Rao node); 2926b556854bSBharata B Rao return; 2927b556854bSBharata B Rao } 2928b556854bSBharata B Rao 2929c20d332aSBharata B Rao spapr_memory_plug(hotplug_dev, dev, node, errp); 2930af81cf32SBharata B Rao } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 2931af81cf32SBharata B Rao spapr_core_plug(hotplug_dev, dev, errp); 2932c20d332aSBharata B Rao } 2933c20d332aSBharata B Rao } 2934c20d332aSBharata B Rao 2935c20d332aSBharata B Rao static void spapr_machine_device_unplug(HotplugHandler *hotplug_dev, 2936c20d332aSBharata B Rao DeviceState *dev, Error **errp) 2937c20d332aSBharata B Rao { 2938cf632463SBharata B Rao sPAPRMachineState *sms = SPAPR_MACHINE(qdev_get_machine()); 29393c0c47e3SDavid Gibson MachineClass *mc = MACHINE_GET_CLASS(qdev_get_machine()); 29406f4b5c3eSBharata B Rao 2941c20d332aSBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { 2942cf632463SBharata B Rao if (spapr_ovec_test(sms->ov5_cas, OV5_HP_EVT)) { 2943cf632463SBharata B Rao spapr_memory_unplug(hotplug_dev, dev, errp); 2944cf632463SBharata B Rao } else { 2945cf632463SBharata B Rao error_setg(errp, "Memory hot unplug not supported for this guest"); 2946cf632463SBharata B Rao } 2947cf632463SBharata B Rao } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 2948c5514d0eSIgor Mammedov if (!mc->has_hotpluggable_cpus) { 2949cf632463SBharata B Rao error_setg(errp, "CPU hot unplug not supported on this machine"); 2950cf632463SBharata B Rao return; 2951cf632463SBharata B Rao } 2952cf632463SBharata B Rao spapr_core_unplug(hotplug_dev, dev, errp); 2953cf632463SBharata B Rao } 2954cf632463SBharata B Rao } 2955cf632463SBharata B Rao 2956cf632463SBharata B Rao static void spapr_machine_device_unplug_request(HotplugHandler *hotplug_dev, 2957cf632463SBharata B Rao DeviceState *dev, Error **errp) 2958cf632463SBharata B Rao { 2959cf632463SBharata B Rao sPAPRMachineState *sms = SPAPR_MACHINE(qdev_get_machine()); 2960cf632463SBharata B Rao MachineClass *mc = MACHINE_GET_CLASS(qdev_get_machine()); 2961cf632463SBharata B Rao 2962cf632463SBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { 2963cf632463SBharata B Rao if (spapr_ovec_test(sms->ov5_cas, OV5_HP_EVT)) { 2964cf632463SBharata B Rao spapr_memory_unplug_request(hotplug_dev, dev, errp); 2965cf632463SBharata B Rao } else { 2966cf632463SBharata B Rao /* NOTE: this means there is a window after guest reset, prior to 2967cf632463SBharata B Rao * CAS negotiation, where unplug requests will fail due to the 2968cf632463SBharata B Rao * capability not being detected yet. This is a bit different than 2969cf632463SBharata B Rao * the case with PCI unplug, where the events will be queued and 2970cf632463SBharata B Rao * eventually handled by the guest after boot 2971cf632463SBharata B Rao */ 2972cf632463SBharata B Rao error_setg(errp, "Memory hot unplug not supported for this guest"); 2973cf632463SBharata B Rao } 29746f4b5c3eSBharata B Rao } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 2975c5514d0eSIgor Mammedov if (!mc->has_hotpluggable_cpus) { 29766f4b5c3eSBharata B Rao error_setg(errp, "CPU hot unplug not supported on this machine"); 29776f4b5c3eSBharata B Rao return; 29786f4b5c3eSBharata B Rao } 2979115debf2SIgor Mammedov spapr_core_unplug_request(hotplug_dev, dev, errp); 2980c20d332aSBharata B Rao } 2981c20d332aSBharata B Rao } 2982c20d332aSBharata B Rao 298394a94e4cSBharata B Rao static void spapr_machine_device_pre_plug(HotplugHandler *hotplug_dev, 298494a94e4cSBharata B Rao DeviceState *dev, Error **errp) 298594a94e4cSBharata B Rao { 298694a94e4cSBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 298794a94e4cSBharata B Rao spapr_core_pre_plug(hotplug_dev, dev, errp); 298894a94e4cSBharata B Rao } 298994a94e4cSBharata B Rao } 299094a94e4cSBharata B Rao 29917ebaf795SBharata B Rao static HotplugHandler *spapr_get_hotplug_handler(MachineState *machine, 2992c20d332aSBharata B Rao DeviceState *dev) 2993c20d332aSBharata B Rao { 299494a94e4cSBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM) || 299594a94e4cSBharata B Rao object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 2996c20d332aSBharata B Rao return HOTPLUG_HANDLER(machine); 2997c20d332aSBharata B Rao } 2998c20d332aSBharata B Rao return NULL; 2999c20d332aSBharata B Rao } 3000c20d332aSBharata B Rao 3001ea089eebSIgor Mammedov static CpuInstanceProperties 3002ea089eebSIgor Mammedov spapr_cpu_index_to_props(MachineState *machine, unsigned cpu_index) 300320bb648dSDavid Gibson { 3004ea089eebSIgor Mammedov CPUArchId *core_slot; 3005ea089eebSIgor Mammedov MachineClass *mc = MACHINE_GET_CLASS(machine); 3006ea089eebSIgor Mammedov 3007ea089eebSIgor Mammedov /* make sure possible_cpu are intialized */ 3008ea089eebSIgor Mammedov mc->possible_cpu_arch_ids(machine); 3009ea089eebSIgor Mammedov /* get CPU core slot containing thread that matches cpu_index */ 3010ea089eebSIgor Mammedov core_slot = spapr_find_cpu_slot(machine, cpu_index, NULL); 3011ea089eebSIgor Mammedov assert(core_slot); 3012ea089eebSIgor Mammedov return core_slot->props; 301320bb648dSDavid Gibson } 301420bb648dSDavid Gibson 3015535455fdSIgor Mammedov static const CPUArchIdList *spapr_possible_cpu_arch_ids(MachineState *machine) 3016535455fdSIgor Mammedov { 3017535455fdSIgor Mammedov int i; 3018535455fdSIgor Mammedov int spapr_max_cores = max_cpus / smp_threads; 3019535455fdSIgor Mammedov MachineClass *mc = MACHINE_GET_CLASS(machine); 3020535455fdSIgor Mammedov 3021c5514d0eSIgor Mammedov if (!mc->has_hotpluggable_cpus) { 3022535455fdSIgor Mammedov spapr_max_cores = QEMU_ALIGN_UP(smp_cpus, smp_threads) / smp_threads; 3023535455fdSIgor Mammedov } 3024535455fdSIgor Mammedov if (machine->possible_cpus) { 3025535455fdSIgor Mammedov assert(machine->possible_cpus->len == spapr_max_cores); 3026535455fdSIgor Mammedov return machine->possible_cpus; 3027535455fdSIgor Mammedov } 3028535455fdSIgor Mammedov 3029535455fdSIgor Mammedov machine->possible_cpus = g_malloc0(sizeof(CPUArchIdList) + 3030535455fdSIgor Mammedov sizeof(CPUArchId) * spapr_max_cores); 3031535455fdSIgor Mammedov machine->possible_cpus->len = spapr_max_cores; 3032535455fdSIgor Mammedov for (i = 0; i < machine->possible_cpus->len; i++) { 3033535455fdSIgor Mammedov int core_id = i * smp_threads; 3034535455fdSIgor Mammedov 3035f2d672c2SIgor Mammedov machine->possible_cpus->cpus[i].vcpus_count = smp_threads; 3036535455fdSIgor Mammedov machine->possible_cpus->cpus[i].arch_id = core_id; 3037535455fdSIgor Mammedov machine->possible_cpus->cpus[i].props.has_core_id = true; 3038535455fdSIgor Mammedov machine->possible_cpus->cpus[i].props.core_id = core_id; 3039ea089eebSIgor Mammedov 3040ea089eebSIgor Mammedov /* default distribution of CPUs over NUMA nodes */ 3041ea089eebSIgor Mammedov if (nb_numa_nodes) { 3042ea089eebSIgor Mammedov /* preset values but do not enable them i.e. 'has_node_id = false', 3043ea089eebSIgor Mammedov * numa init code will enable them later if manual mapping wasn't 3044ea089eebSIgor Mammedov * present on CLI */ 3045ea089eebSIgor Mammedov machine->possible_cpus->cpus[i].props.node_id = 3046ea089eebSIgor Mammedov core_id / smp_threads / smp_cores % nb_numa_nodes; 3047ea089eebSIgor Mammedov } 3048535455fdSIgor Mammedov } 3049535455fdSIgor Mammedov return machine->possible_cpus; 3050535455fdSIgor Mammedov } 3051535455fdSIgor Mammedov 30526737d9adSDavid Gibson static void spapr_phb_placement(sPAPRMachineState *spapr, uint32_t index, 3053daa23699SDavid Gibson uint64_t *buid, hwaddr *pio, 3054daa23699SDavid Gibson hwaddr *mmio32, hwaddr *mmio64, 30556737d9adSDavid Gibson unsigned n_dma, uint32_t *liobns, Error **errp) 30566737d9adSDavid Gibson { 3057357d1e3bSDavid Gibson /* 3058357d1e3bSDavid Gibson * New-style PHB window placement. 3059357d1e3bSDavid Gibson * 3060357d1e3bSDavid Gibson * Goals: Gives large (1TiB), naturally aligned 64-bit MMIO window 3061357d1e3bSDavid Gibson * for each PHB, in addition to 2GiB 32-bit MMIO and 64kiB PIO 3062357d1e3bSDavid Gibson * windows. 3063357d1e3bSDavid Gibson * 3064357d1e3bSDavid Gibson * Some guest kernels can't work with MMIO windows above 1<<46 3065357d1e3bSDavid Gibson * (64TiB), so we place up to 31 PHBs in the area 32TiB..64TiB 3066357d1e3bSDavid Gibson * 3067357d1e3bSDavid Gibson * 32TiB..(33TiB+1984kiB) contains the 64kiB PIO windows for each 3068357d1e3bSDavid Gibson * PHB stacked together. (32TiB+2GiB)..(32TiB+64GiB) contains the 3069357d1e3bSDavid Gibson * 2GiB 32-bit MMIO windows for each PHB. Then 33..64TiB has the 3070357d1e3bSDavid Gibson * 1TiB 64-bit MMIO windows for each PHB. 3071357d1e3bSDavid Gibson */ 30726737d9adSDavid Gibson const uint64_t base_buid = 0x800000020000000ULL; 307325e6a118SMichael S. Tsirkin #define SPAPR_MAX_PHBS ((SPAPR_PCI_LIMIT - SPAPR_PCI_BASE) / \ 307425e6a118SMichael S. Tsirkin SPAPR_PCI_MEM64_WIN_SIZE - 1) 30756737d9adSDavid Gibson int i; 30766737d9adSDavid Gibson 3077357d1e3bSDavid Gibson /* Sanity check natural alignments */ 3078357d1e3bSDavid Gibson QEMU_BUILD_BUG_ON((SPAPR_PCI_BASE % SPAPR_PCI_MEM64_WIN_SIZE) != 0); 3079357d1e3bSDavid Gibson QEMU_BUILD_BUG_ON((SPAPR_PCI_LIMIT % SPAPR_PCI_MEM64_WIN_SIZE) != 0); 3080357d1e3bSDavid Gibson QEMU_BUILD_BUG_ON((SPAPR_PCI_MEM64_WIN_SIZE % SPAPR_PCI_MEM32_WIN_SIZE) != 0); 3081357d1e3bSDavid Gibson QEMU_BUILD_BUG_ON((SPAPR_PCI_MEM32_WIN_SIZE % SPAPR_PCI_IO_WIN_SIZE) != 0); 3082357d1e3bSDavid Gibson /* Sanity check bounds */ 308325e6a118SMichael S. Tsirkin QEMU_BUILD_BUG_ON((SPAPR_MAX_PHBS * SPAPR_PCI_IO_WIN_SIZE) > 308425e6a118SMichael S. Tsirkin SPAPR_PCI_MEM32_WIN_SIZE); 308525e6a118SMichael S. Tsirkin QEMU_BUILD_BUG_ON((SPAPR_MAX_PHBS * SPAPR_PCI_MEM32_WIN_SIZE) > 308625e6a118SMichael S. Tsirkin SPAPR_PCI_MEM64_WIN_SIZE); 30872efff1c0SDavid Gibson 308825e6a118SMichael S. Tsirkin if (index >= SPAPR_MAX_PHBS) { 308925e6a118SMichael S. Tsirkin error_setg(errp, "\"index\" for PAPR PHB is too large (max %llu)", 309025e6a118SMichael S. Tsirkin SPAPR_MAX_PHBS - 1); 30916737d9adSDavid Gibson return; 30926737d9adSDavid Gibson } 30936737d9adSDavid Gibson 30946737d9adSDavid Gibson *buid = base_buid + index; 30956737d9adSDavid Gibson for (i = 0; i < n_dma; ++i) { 30966737d9adSDavid Gibson liobns[i] = SPAPR_PCI_LIOBN(index, i); 30976737d9adSDavid Gibson } 30986737d9adSDavid Gibson 3099357d1e3bSDavid Gibson *pio = SPAPR_PCI_BASE + index * SPAPR_PCI_IO_WIN_SIZE; 3100357d1e3bSDavid Gibson *mmio32 = SPAPR_PCI_BASE + (index + 1) * SPAPR_PCI_MEM32_WIN_SIZE; 3101357d1e3bSDavid Gibson *mmio64 = SPAPR_PCI_BASE + (index + 1) * SPAPR_PCI_MEM64_WIN_SIZE; 31026737d9adSDavid Gibson } 31036737d9adSDavid Gibson 31047844e12bSCédric Le Goater static ICSState *spapr_ics_get(XICSFabric *dev, int irq) 31057844e12bSCédric Le Goater { 31067844e12bSCédric Le Goater sPAPRMachineState *spapr = SPAPR_MACHINE(dev); 31077844e12bSCédric Le Goater 31087844e12bSCédric Le Goater return ics_valid_irq(spapr->ics, irq) ? spapr->ics : NULL; 31097844e12bSCédric Le Goater } 31107844e12bSCédric Le Goater 31117844e12bSCédric Le Goater static void spapr_ics_resend(XICSFabric *dev) 31127844e12bSCédric Le Goater { 31137844e12bSCédric Le Goater sPAPRMachineState *spapr = SPAPR_MACHINE(dev); 31147844e12bSCédric Le Goater 31157844e12bSCédric Le Goater ics_resend(spapr->ics); 31167844e12bSCédric Le Goater } 31177844e12bSCédric Le Goater 311806747ba6SCédric Le Goater static ICPState *spapr_icp_get(XICSFabric *xi, int cpu_dt_id) 3119b2fc59aaSCédric Le Goater { 31205bc8d26dSCédric Le Goater PowerPCCPU *cpu = ppc_get_vcpu_by_dt_id(cpu_dt_id); 3121b2fc59aaSCédric Le Goater 31225bc8d26dSCédric Le Goater return cpu ? ICP(cpu->intc) : NULL; 3123b2fc59aaSCédric Le Goater } 3124b2fc59aaSCédric Le Goater 31256449da45SCédric Le Goater static void spapr_pic_print_info(InterruptStatsProvider *obj, 31266449da45SCédric Le Goater Monitor *mon) 31276449da45SCédric Le Goater { 31286449da45SCédric Le Goater sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 31295bc8d26dSCédric Le Goater CPUState *cs; 31306449da45SCédric Le Goater 31315bc8d26dSCédric Le Goater CPU_FOREACH(cs) { 31325bc8d26dSCédric Le Goater PowerPCCPU *cpu = POWERPC_CPU(cs); 31335bc8d26dSCédric Le Goater 31345bc8d26dSCédric Le Goater icp_pic_print_info(ICP(cpu->intc), mon); 31356449da45SCédric Le Goater } 31366449da45SCédric Le Goater 31376449da45SCédric Le Goater ics_pic_print_info(spapr->ics, mon); 31386449da45SCédric Le Goater } 31396449da45SCédric Le Goater 314029ee3247SAlexey Kardashevskiy static void spapr_machine_class_init(ObjectClass *oc, void *data) 314153018216SPaolo Bonzini { 314229ee3247SAlexey Kardashevskiy MachineClass *mc = MACHINE_CLASS(oc); 3143224245bfSDavid Gibson sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(oc); 314471461b0fSAlexey Kardashevskiy FWPathProviderClass *fwc = FW_PATH_PROVIDER_CLASS(oc); 314534316482SAlexey Kardashevskiy NMIClass *nc = NMI_CLASS(oc); 3146c20d332aSBharata B Rao HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(oc); 31471d1be34dSDavid Gibson PPCVirtualHypervisorClass *vhc = PPC_VIRTUAL_HYPERVISOR_CLASS(oc); 31487844e12bSCédric Le Goater XICSFabricClass *xic = XICS_FABRIC_CLASS(oc); 31496449da45SCédric Le Goater InterruptStatsProviderClass *ispc = INTERRUPT_STATS_PROVIDER_CLASS(oc); 315029ee3247SAlexey Kardashevskiy 31510eb9054cSDavid Gibson mc->desc = "pSeries Logical Partition (PAPR compliant)"; 3152fc9f38c3SDavid Gibson 3153fc9f38c3SDavid Gibson /* 3154fc9f38c3SDavid Gibson * We set up the default / latest behaviour here. The class_init 3155fc9f38c3SDavid Gibson * functions for the specific versioned machine types can override 3156fc9f38c3SDavid Gibson * these details for backwards compatibility 3157fc9f38c3SDavid Gibson */ 3158958db90cSMarcel Apfelbaum mc->init = ppc_spapr_init; 3159958db90cSMarcel Apfelbaum mc->reset = ppc_spapr_reset; 3160958db90cSMarcel Apfelbaum mc->block_default_type = IF_SCSI; 31616244bb7eSGreg Kurz mc->max_cpus = 1024; 3162958db90cSMarcel Apfelbaum mc->no_parallel = 1; 31635b2128d2SAlexander Graf mc->default_boot_order = ""; 3164a34944feSNikunj A Dadhania mc->default_ram_size = 512 * M_BYTE; 3165958db90cSMarcel Apfelbaum mc->kvm_type = spapr_kvm_type; 31669e3f9733SAlexander Graf mc->has_dynamic_sysbus = true; 3167e4024630SLaurent Vivier mc->pci_allow_0_address = true; 31687ebaf795SBharata B Rao mc->get_hotplug_handler = spapr_get_hotplug_handler; 316994a94e4cSBharata B Rao hc->pre_plug = spapr_machine_device_pre_plug; 3170c20d332aSBharata B Rao hc->plug = spapr_machine_device_plug; 3171c20d332aSBharata B Rao hc->unplug = spapr_machine_device_unplug; 3172ea089eebSIgor Mammedov mc->cpu_index_to_instance_props = spapr_cpu_index_to_props; 3173535455fdSIgor Mammedov mc->possible_cpu_arch_ids = spapr_possible_cpu_arch_ids; 3174cf632463SBharata B Rao hc->unplug_request = spapr_machine_device_unplug_request; 317500b4fbe2SMarcel Apfelbaum 3176fc9f38c3SDavid Gibson smc->dr_lmb_enabled = true; 31773daa4a9fSThomas Huth smc->tcg_default_cpu = "POWER8"; 3178c5514d0eSIgor Mammedov mc->has_hotpluggable_cpus = true; 317971461b0fSAlexey Kardashevskiy fwc->get_dev_path = spapr_get_fw_dev_path; 318034316482SAlexey Kardashevskiy nc->nmi_monitor_handler = spapr_nmi; 31816737d9adSDavid Gibson smc->phb_placement = spapr_phb_placement; 31821d1be34dSDavid Gibson vhc->hypercall = emulate_spapr_hypercall; 3183e57ca75cSDavid Gibson vhc->hpt_mask = spapr_hpt_mask; 3184e57ca75cSDavid Gibson vhc->map_hptes = spapr_map_hptes; 3185e57ca75cSDavid Gibson vhc->unmap_hptes = spapr_unmap_hptes; 3186e57ca75cSDavid Gibson vhc->store_hpte = spapr_store_hpte; 31879861bb3eSSuraj Jitindar Singh vhc->get_patbe = spapr_get_patbe; 31887844e12bSCédric Le Goater xic->ics_get = spapr_ics_get; 31897844e12bSCédric Le Goater xic->ics_resend = spapr_ics_resend; 3190b2fc59aaSCédric Le Goater xic->icp_get = spapr_icp_get; 31916449da45SCédric Le Goater ispc->print_info = spapr_pic_print_info; 319255641213SLaurent Vivier /* Force NUMA node memory size to be a multiple of 319355641213SLaurent Vivier * SPAPR_MEMORY_BLOCK_SIZE (256M) since that's the granularity 319455641213SLaurent Vivier * in which LMBs are represented and hot-added 319555641213SLaurent Vivier */ 319655641213SLaurent Vivier mc->numa_mem_align_shift = 28; 319753018216SPaolo Bonzini } 319853018216SPaolo Bonzini 319929ee3247SAlexey Kardashevskiy static const TypeInfo spapr_machine_info = { 320029ee3247SAlexey Kardashevskiy .name = TYPE_SPAPR_MACHINE, 320129ee3247SAlexey Kardashevskiy .parent = TYPE_MACHINE, 32024aee7362SDavid Gibson .abstract = true, 32036ca1502eSAlexey Kardashevskiy .instance_size = sizeof(sPAPRMachineState), 320423825581SEduardo Habkost .instance_init = spapr_machine_initfn, 320587bbdd9cSDavid Gibson .instance_finalize = spapr_machine_finalizefn, 3206183930c0SDavid Gibson .class_size = sizeof(sPAPRMachineClass), 320729ee3247SAlexey Kardashevskiy .class_init = spapr_machine_class_init, 320871461b0fSAlexey Kardashevskiy .interfaces = (InterfaceInfo[]) { 320971461b0fSAlexey Kardashevskiy { TYPE_FW_PATH_PROVIDER }, 321034316482SAlexey Kardashevskiy { TYPE_NMI }, 3211c20d332aSBharata B Rao { TYPE_HOTPLUG_HANDLER }, 32121d1be34dSDavid Gibson { TYPE_PPC_VIRTUAL_HYPERVISOR }, 32137844e12bSCédric Le Goater { TYPE_XICS_FABRIC }, 32146449da45SCédric Le Goater { TYPE_INTERRUPT_STATS_PROVIDER }, 321571461b0fSAlexey Kardashevskiy { } 321671461b0fSAlexey Kardashevskiy }, 321729ee3247SAlexey Kardashevskiy }; 321829ee3247SAlexey Kardashevskiy 3219fccbc785SDavid Gibson #define DEFINE_SPAPR_MACHINE(suffix, verstr, latest) \ 32205013c547SDavid Gibson static void spapr_machine_##suffix##_class_init(ObjectClass *oc, \ 32215013c547SDavid Gibson void *data) \ 32225013c547SDavid Gibson { \ 32235013c547SDavid Gibson MachineClass *mc = MACHINE_CLASS(oc); \ 32245013c547SDavid Gibson spapr_machine_##suffix##_class_options(mc); \ 3225fccbc785SDavid Gibson if (latest) { \ 3226fccbc785SDavid Gibson mc->alias = "pseries"; \ 3227fccbc785SDavid Gibson mc->is_default = 1; \ 3228fccbc785SDavid Gibson } \ 32295013c547SDavid Gibson } \ 32305013c547SDavid Gibson static void spapr_machine_##suffix##_instance_init(Object *obj) \ 32315013c547SDavid Gibson { \ 32325013c547SDavid Gibson MachineState *machine = MACHINE(obj); \ 32335013c547SDavid Gibson spapr_machine_##suffix##_instance_options(machine); \ 32345013c547SDavid Gibson } \ 32355013c547SDavid Gibson static const TypeInfo spapr_machine_##suffix##_info = { \ 32365013c547SDavid Gibson .name = MACHINE_TYPE_NAME("pseries-" verstr), \ 32375013c547SDavid Gibson .parent = TYPE_SPAPR_MACHINE, \ 32385013c547SDavid Gibson .class_init = spapr_machine_##suffix##_class_init, \ 32395013c547SDavid Gibson .instance_init = spapr_machine_##suffix##_instance_init, \ 32405013c547SDavid Gibson }; \ 32415013c547SDavid Gibson static void spapr_machine_register_##suffix(void) \ 32425013c547SDavid Gibson { \ 32435013c547SDavid Gibson type_register(&spapr_machine_##suffix##_info); \ 32445013c547SDavid Gibson } \ 32450e6aac87SEduardo Habkost type_init(spapr_machine_register_##suffix) 32465013c547SDavid Gibson 32471c5f29bbSDavid Gibson /* 32483fa14fbeSDavid Gibson * pseries-2.10 3249db800b21SDavid Gibson */ 32503fa14fbeSDavid Gibson static void spapr_machine_2_10_instance_options(MachineState *machine) 3251db800b21SDavid Gibson { 3252db800b21SDavid Gibson } 3253db800b21SDavid Gibson 32543fa14fbeSDavid Gibson static void spapr_machine_2_10_class_options(MachineClass *mc) 3255db800b21SDavid Gibson { 3256db800b21SDavid Gibson /* Defaults for the latest behaviour inherited from the base class */ 3257db800b21SDavid Gibson } 3258db800b21SDavid Gibson 32593fa14fbeSDavid Gibson DEFINE_SPAPR_MACHINE(2_10, "2.10", true); 32603fa14fbeSDavid Gibson 32613fa14fbeSDavid Gibson /* 32623fa14fbeSDavid Gibson * pseries-2.9 32633fa14fbeSDavid Gibson */ 32643fa14fbeSDavid Gibson #define SPAPR_COMPAT_2_9 \ 32653fa14fbeSDavid Gibson HW_COMPAT_2_9 32663fa14fbeSDavid Gibson 32673fa14fbeSDavid Gibson static void spapr_machine_2_9_instance_options(MachineState *machine) 32683fa14fbeSDavid Gibson { 32693fa14fbeSDavid Gibson spapr_machine_2_10_instance_options(machine); 32703fa14fbeSDavid Gibson } 32713fa14fbeSDavid Gibson 32723fa14fbeSDavid Gibson static void spapr_machine_2_9_class_options(MachineClass *mc) 32733fa14fbeSDavid Gibson { 32743fa14fbeSDavid Gibson spapr_machine_2_10_class_options(mc); 32753fa14fbeSDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_9); 32763bfe5716SLaurent Vivier mc->numa_auto_assign_ram = numa_legacy_auto_assign_ram; 32773fa14fbeSDavid Gibson } 32783fa14fbeSDavid Gibson 32793fa14fbeSDavid Gibson DEFINE_SPAPR_MACHINE(2_9, "2.9", false); 3280fa325e6cSDavid Gibson 3281fa325e6cSDavid Gibson /* 3282fa325e6cSDavid Gibson * pseries-2.8 3283fa325e6cSDavid Gibson */ 3284fa325e6cSDavid Gibson #define SPAPR_COMPAT_2_8 \ 328582516263SDavid Gibson HW_COMPAT_2_8 \ 328682516263SDavid Gibson { \ 328782516263SDavid Gibson .driver = TYPE_SPAPR_PCI_HOST_BRIDGE, \ 328882516263SDavid Gibson .property = "pcie-extended-configuration-space", \ 328982516263SDavid Gibson .value = "off", \ 329082516263SDavid Gibson }, 3291fa325e6cSDavid Gibson 3292fa325e6cSDavid Gibson static void spapr_machine_2_8_instance_options(MachineState *machine) 3293fa325e6cSDavid Gibson { 3294fa325e6cSDavid Gibson spapr_machine_2_9_instance_options(machine); 3295fa325e6cSDavid Gibson } 3296fa325e6cSDavid Gibson 3297fa325e6cSDavid Gibson static void spapr_machine_2_8_class_options(MachineClass *mc) 3298fa325e6cSDavid Gibson { 3299fa325e6cSDavid Gibson spapr_machine_2_9_class_options(mc); 3300fa325e6cSDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_8); 330155641213SLaurent Vivier mc->numa_mem_align_shift = 23; 3302fa325e6cSDavid Gibson } 3303fa325e6cSDavid Gibson 3304fa325e6cSDavid Gibson DEFINE_SPAPR_MACHINE(2_8, "2.8", false); 3305db800b21SDavid Gibson 3306db800b21SDavid Gibson /* 33071ea1eefcSBharata B Rao * pseries-2.7 33081ea1eefcSBharata B Rao */ 3309db800b21SDavid Gibson #define SPAPR_COMPAT_2_7 \ 3310db800b21SDavid Gibson HW_COMPAT_2_7 \ 3311357d1e3bSDavid Gibson { \ 3312357d1e3bSDavid Gibson .driver = TYPE_SPAPR_PCI_HOST_BRIDGE, \ 3313357d1e3bSDavid Gibson .property = "mem_win_size", \ 3314357d1e3bSDavid Gibson .value = stringify(SPAPR_PCI_2_7_MMIO_WIN_SIZE),\ 3315357d1e3bSDavid Gibson }, \ 3316357d1e3bSDavid Gibson { \ 3317357d1e3bSDavid Gibson .driver = TYPE_SPAPR_PCI_HOST_BRIDGE, \ 3318357d1e3bSDavid Gibson .property = "mem64_win_size", \ 3319357d1e3bSDavid Gibson .value = "0", \ 3320146c11f1SDavid Gibson }, \ 3321146c11f1SDavid Gibson { \ 3322146c11f1SDavid Gibson .driver = TYPE_POWERPC_CPU, \ 3323146c11f1SDavid Gibson .property = "pre-2.8-migration", \ 3324146c11f1SDavid Gibson .value = "on", \ 33255c4537bdSDavid Gibson }, \ 33265c4537bdSDavid Gibson { \ 33275c4537bdSDavid Gibson .driver = TYPE_SPAPR_PCI_HOST_BRIDGE, \ 33285c4537bdSDavid Gibson .property = "pre-2.8-migration", \ 33295c4537bdSDavid Gibson .value = "on", \ 3330357d1e3bSDavid Gibson }, 3331357d1e3bSDavid Gibson 3332357d1e3bSDavid Gibson static void phb_placement_2_7(sPAPRMachineState *spapr, uint32_t index, 3333357d1e3bSDavid Gibson uint64_t *buid, hwaddr *pio, 3334357d1e3bSDavid Gibson hwaddr *mmio32, hwaddr *mmio64, 3335357d1e3bSDavid Gibson unsigned n_dma, uint32_t *liobns, Error **errp) 3336357d1e3bSDavid Gibson { 3337357d1e3bSDavid Gibson /* Legacy PHB placement for pseries-2.7 and earlier machine types */ 3338357d1e3bSDavid Gibson const uint64_t base_buid = 0x800000020000000ULL; 3339357d1e3bSDavid Gibson const hwaddr phb_spacing = 0x1000000000ULL; /* 64 GiB */ 3340357d1e3bSDavid Gibson const hwaddr mmio_offset = 0xa0000000; /* 2 GiB + 512 MiB */ 3341357d1e3bSDavid Gibson const hwaddr pio_offset = 0x80000000; /* 2 GiB */ 3342357d1e3bSDavid Gibson const uint32_t max_index = 255; 3343357d1e3bSDavid Gibson const hwaddr phb0_alignment = 0x10000000000ULL; /* 1 TiB */ 3344357d1e3bSDavid Gibson 3345357d1e3bSDavid Gibson uint64_t ram_top = MACHINE(spapr)->ram_size; 3346357d1e3bSDavid Gibson hwaddr phb0_base, phb_base; 3347357d1e3bSDavid Gibson int i; 3348357d1e3bSDavid Gibson 3349357d1e3bSDavid Gibson /* Do we have hotpluggable memory? */ 3350357d1e3bSDavid Gibson if (MACHINE(spapr)->maxram_size > ram_top) { 3351357d1e3bSDavid Gibson /* Can't just use maxram_size, because there may be an 3352357d1e3bSDavid Gibson * alignment gap between normal and hotpluggable memory 3353357d1e3bSDavid Gibson * regions */ 3354357d1e3bSDavid Gibson ram_top = spapr->hotplug_memory.base + 3355357d1e3bSDavid Gibson memory_region_size(&spapr->hotplug_memory.mr); 3356357d1e3bSDavid Gibson } 3357357d1e3bSDavid Gibson 3358357d1e3bSDavid Gibson phb0_base = QEMU_ALIGN_UP(ram_top, phb0_alignment); 3359357d1e3bSDavid Gibson 3360357d1e3bSDavid Gibson if (index > max_index) { 3361357d1e3bSDavid Gibson error_setg(errp, "\"index\" for PAPR PHB is too large (max %u)", 3362357d1e3bSDavid Gibson max_index); 3363357d1e3bSDavid Gibson return; 3364357d1e3bSDavid Gibson } 3365357d1e3bSDavid Gibson 3366357d1e3bSDavid Gibson *buid = base_buid + index; 3367357d1e3bSDavid Gibson for (i = 0; i < n_dma; ++i) { 3368357d1e3bSDavid Gibson liobns[i] = SPAPR_PCI_LIOBN(index, i); 3369357d1e3bSDavid Gibson } 3370357d1e3bSDavid Gibson 3371357d1e3bSDavid Gibson phb_base = phb0_base + index * phb_spacing; 3372357d1e3bSDavid Gibson *pio = phb_base + pio_offset; 3373357d1e3bSDavid Gibson *mmio32 = phb_base + mmio_offset; 3374357d1e3bSDavid Gibson /* 3375357d1e3bSDavid Gibson * We don't set the 64-bit MMIO window, relying on the PHB's 3376357d1e3bSDavid Gibson * fallback behaviour of automatically splitting a large "32-bit" 3377357d1e3bSDavid Gibson * window into contiguous 32-bit and 64-bit windows 3378357d1e3bSDavid Gibson */ 3379357d1e3bSDavid Gibson } 3380db800b21SDavid Gibson 33811ea1eefcSBharata B Rao static void spapr_machine_2_7_instance_options(MachineState *machine) 33821ea1eefcSBharata B Rao { 3383f6229214SMichael Roth sPAPRMachineState *spapr = SPAPR_MACHINE(machine); 3384f6229214SMichael Roth 3385672de881SMichael Roth spapr_machine_2_8_instance_options(machine); 3386f6229214SMichael Roth spapr->use_hotplug_event_source = false; 33871ea1eefcSBharata B Rao } 33881ea1eefcSBharata B Rao 33891ea1eefcSBharata B Rao static void spapr_machine_2_7_class_options(MachineClass *mc) 33901ea1eefcSBharata B Rao { 33913daa4a9fSThomas Huth sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); 33923daa4a9fSThomas Huth 3393db800b21SDavid Gibson spapr_machine_2_8_class_options(mc); 33943daa4a9fSThomas Huth smc->tcg_default_cpu = "POWER7"; 3395db800b21SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_7); 3396357d1e3bSDavid Gibson smc->phb_placement = phb_placement_2_7; 33971ea1eefcSBharata B Rao } 33981ea1eefcSBharata B Rao 3399db800b21SDavid Gibson DEFINE_SPAPR_MACHINE(2_7, "2.7", false); 34001ea1eefcSBharata B Rao 34011ea1eefcSBharata B Rao /* 34024b23699cSDavid Gibson * pseries-2.6 34034b23699cSDavid Gibson */ 34041ea1eefcSBharata B Rao #define SPAPR_COMPAT_2_6 \ 3405ae4de14cSAlexey Kardashevskiy HW_COMPAT_2_6 \ 3406ae4de14cSAlexey Kardashevskiy { \ 3407ae4de14cSAlexey Kardashevskiy .driver = TYPE_SPAPR_PCI_HOST_BRIDGE,\ 3408ae4de14cSAlexey Kardashevskiy .property = "ddw",\ 3409ae4de14cSAlexey Kardashevskiy .value = stringify(off),\ 3410ae4de14cSAlexey Kardashevskiy }, 34111ea1eefcSBharata B Rao 34124b23699cSDavid Gibson static void spapr_machine_2_6_instance_options(MachineState *machine) 34134b23699cSDavid Gibson { 3414672de881SMichael Roth spapr_machine_2_7_instance_options(machine); 34154b23699cSDavid Gibson } 34164b23699cSDavid Gibson 34174b23699cSDavid Gibson static void spapr_machine_2_6_class_options(MachineClass *mc) 34184b23699cSDavid Gibson { 34191ea1eefcSBharata B Rao spapr_machine_2_7_class_options(mc); 3420c5514d0eSIgor Mammedov mc->has_hotpluggable_cpus = false; 34211ea1eefcSBharata B Rao SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_6); 34224b23699cSDavid Gibson } 34234b23699cSDavid Gibson 34241ea1eefcSBharata B Rao DEFINE_SPAPR_MACHINE(2_6, "2.6", false); 34254b23699cSDavid Gibson 34264b23699cSDavid Gibson /* 34271c5f29bbSDavid Gibson * pseries-2.5 34281c5f29bbSDavid Gibson */ 34294b23699cSDavid Gibson #define SPAPR_COMPAT_2_5 \ 343057c522f4SThomas Huth HW_COMPAT_2_5 \ 343157c522f4SThomas Huth { \ 343257c522f4SThomas Huth .driver = "spapr-vlan", \ 343357c522f4SThomas Huth .property = "use-rx-buffer-pools", \ 343457c522f4SThomas Huth .value = "off", \ 343557c522f4SThomas Huth }, 34364b23699cSDavid Gibson 34375013c547SDavid Gibson static void spapr_machine_2_5_instance_options(MachineState *machine) 34381c5f29bbSDavid Gibson { 3439672de881SMichael Roth spapr_machine_2_6_instance_options(machine); 34405013c547SDavid Gibson } 34415013c547SDavid Gibson 34425013c547SDavid Gibson static void spapr_machine_2_5_class_options(MachineClass *mc) 34435013c547SDavid Gibson { 344457040d45SThomas Huth sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); 344557040d45SThomas Huth 34464b23699cSDavid Gibson spapr_machine_2_6_class_options(mc); 344757040d45SThomas Huth smc->use_ohci_by_default = true; 34484b23699cSDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_5); 34491c5f29bbSDavid Gibson } 34501c5f29bbSDavid Gibson 34514b23699cSDavid Gibson DEFINE_SPAPR_MACHINE(2_5, "2.5", false); 34521c5f29bbSDavid Gibson 34531c5f29bbSDavid Gibson /* 34541c5f29bbSDavid Gibson * pseries-2.4 34551c5f29bbSDavid Gibson */ 345680fd50f9SCornelia Huck #define SPAPR_COMPAT_2_4 \ 345780fd50f9SCornelia Huck HW_COMPAT_2_4 345880fd50f9SCornelia Huck 34595013c547SDavid Gibson static void spapr_machine_2_4_instance_options(MachineState *machine) 34601c5f29bbSDavid Gibson { 34615013c547SDavid Gibson spapr_machine_2_5_instance_options(machine); 34625013c547SDavid Gibson } 34631c5f29bbSDavid Gibson 34645013c547SDavid Gibson static void spapr_machine_2_4_class_options(MachineClass *mc) 34655013c547SDavid Gibson { 3466fc9f38c3SDavid Gibson sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); 3467fc9f38c3SDavid Gibson 3468fc9f38c3SDavid Gibson spapr_machine_2_5_class_options(mc); 3469fc9f38c3SDavid Gibson smc->dr_lmb_enabled = false; 3470f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_4); 34711c5f29bbSDavid Gibson } 34721c5f29bbSDavid Gibson 3473fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_4, "2.4", false); 34741c5f29bbSDavid Gibson 34751c5f29bbSDavid Gibson /* 34761c5f29bbSDavid Gibson * pseries-2.3 34771c5f29bbSDavid Gibson */ 347838ff32c6SEduardo Habkost #define SPAPR_COMPAT_2_3 \ 34797619c7b0SMichael Roth HW_COMPAT_2_3 \ 34807619c7b0SMichael Roth {\ 34817619c7b0SMichael Roth .driver = "spapr-pci-host-bridge",\ 34827619c7b0SMichael Roth .property = "dynamic-reconfiguration",\ 34837619c7b0SMichael Roth .value = "off",\ 34847619c7b0SMichael Roth }, 348538ff32c6SEduardo Habkost 34865013c547SDavid Gibson static void spapr_machine_2_3_instance_options(MachineState *machine) 34871c5f29bbSDavid Gibson { 34885013c547SDavid Gibson spapr_machine_2_4_instance_options(machine); 34891c5f29bbSDavid Gibson savevm_skip_section_footers(); 34901c5f29bbSDavid Gibson global_state_set_optional(); 349109b5e30dSGreg Kurz savevm_skip_configuration(); 34921c5f29bbSDavid Gibson } 34931c5f29bbSDavid Gibson 34945013c547SDavid Gibson static void spapr_machine_2_3_class_options(MachineClass *mc) 34951c5f29bbSDavid Gibson { 3496fc9f38c3SDavid Gibson spapr_machine_2_4_class_options(mc); 3497f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_3); 34981c5f29bbSDavid Gibson } 3499fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_3, "2.3", false); 35001c5f29bbSDavid Gibson 35011c5f29bbSDavid Gibson /* 35021c5f29bbSDavid Gibson * pseries-2.2 35031c5f29bbSDavid Gibson */ 35041c5f29bbSDavid Gibson 3505b194df47SAlexey Kardashevskiy #define SPAPR_COMPAT_2_2 \ 35064dfd8eaaSEduardo Habkost HW_COMPAT_2_2 \ 3507b194df47SAlexey Kardashevskiy {\ 3508b194df47SAlexey Kardashevskiy .driver = TYPE_SPAPR_PCI_HOST_BRIDGE,\ 3509b194df47SAlexey Kardashevskiy .property = "mem_win_size",\ 3510b194df47SAlexey Kardashevskiy .value = "0x20000000",\ 3511dd754bafSEduardo Habkost }, 3512b194df47SAlexey Kardashevskiy 35135013c547SDavid Gibson static void spapr_machine_2_2_instance_options(MachineState *machine) 3514b0e966d0SJason Wang { 35155013c547SDavid Gibson spapr_machine_2_3_instance_options(machine); 3516cba0e779SGreg Kurz machine->suppress_vmdesc = true; 3517b0e966d0SJason Wang } 3518b0e966d0SJason Wang 35195013c547SDavid Gibson static void spapr_machine_2_2_class_options(MachineClass *mc) 3520b0e966d0SJason Wang { 3521fc9f38c3SDavid Gibson spapr_machine_2_3_class_options(mc); 3522f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_2); 35231c5f29bbSDavid Gibson } 3524fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_2, "2.2", false); 35251c5f29bbSDavid Gibson 35261c5f29bbSDavid Gibson /* 35271c5f29bbSDavid Gibson * pseries-2.1 35281c5f29bbSDavid Gibson */ 35291c5f29bbSDavid Gibson #define SPAPR_COMPAT_2_1 \ 35301c5f29bbSDavid Gibson HW_COMPAT_2_1 35311c5f29bbSDavid Gibson 35325013c547SDavid Gibson static void spapr_machine_2_1_instance_options(MachineState *machine) 35331c5f29bbSDavid Gibson { 35345013c547SDavid Gibson spapr_machine_2_2_instance_options(machine); 35351c5f29bbSDavid Gibson } 35361c5f29bbSDavid Gibson 35375013c547SDavid Gibson static void spapr_machine_2_1_class_options(MachineClass *mc) 3538b0e966d0SJason Wang { 3539fc9f38c3SDavid Gibson spapr_machine_2_2_class_options(mc); 3540f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_1); 35416026db45SAlexey Kardashevskiy } 3542fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_1, "2.1", false); 35436026db45SAlexey Kardashevskiy 354429ee3247SAlexey Kardashevskiy static void spapr_machine_register_types(void) 354529ee3247SAlexey Kardashevskiy { 354629ee3247SAlexey Kardashevskiy type_register_static(&spapr_machine_info); 354729ee3247SAlexey Kardashevskiy } 354829ee3247SAlexey Kardashevskiy 354929ee3247SAlexey Kardashevskiy type_init(spapr_machine_register_types) 3550