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" 60c4e13492SFelipe Franciosi #include "hw/virtio/vhost-scsi-common.h" 6153018216SPaolo Bonzini 6253018216SPaolo Bonzini #include "exec/address-spaces.h" 6353018216SPaolo Bonzini #include "hw/usb.h" 6453018216SPaolo Bonzini #include "qemu/config-file.h" 65135a129aSAneesh Kumar K.V #include "qemu/error-report.h" 662a6593cbSAlexey Kardashevskiy #include "trace.h" 6734316482SAlexey Kardashevskiy #include "hw/nmi.h" 686449da45SCédric Le Goater #include "hw/intc/intc.h" 6953018216SPaolo Bonzini 7068a27b20SMichael S. Tsirkin #include "hw/compat.h" 71f348b6d1SVeronia Bahaa #include "qemu/cutils.h" 7294a94e4cSBharata B Rao #include "hw/ppc/spapr_cpu_core.h" 732474bfd4SIgor Mammedov #include "qmp-commands.h" 7468a27b20SMichael S. Tsirkin 7553018216SPaolo Bonzini #include <libfdt.h> 7653018216SPaolo Bonzini 7753018216SPaolo Bonzini /* SLOF memory layout: 7853018216SPaolo Bonzini * 7953018216SPaolo Bonzini * SLOF raw image loaded at 0, copies its romfs right below the flat 8053018216SPaolo Bonzini * device-tree, then position SLOF itself 31M below that 8153018216SPaolo Bonzini * 8253018216SPaolo Bonzini * So we set FW_OVERHEAD to 40MB which should account for all of that 8353018216SPaolo Bonzini * and more 8453018216SPaolo Bonzini * 8553018216SPaolo Bonzini * We load our kernel at 4M, leaving space for SLOF initial image 8653018216SPaolo Bonzini */ 8738b02bd8SAlexey Kardashevskiy #define FDT_MAX_SIZE 0x100000 8853018216SPaolo Bonzini #define RTAS_MAX_SIZE 0x10000 89b7d1f77aSBenjamin Herrenschmidt #define RTAS_MAX_ADDR 0x80000000 /* RTAS must stay below that */ 9053018216SPaolo Bonzini #define FW_MAX_SIZE 0x400000 9153018216SPaolo Bonzini #define FW_FILE_NAME "slof.bin" 9253018216SPaolo Bonzini #define FW_OVERHEAD 0x2800000 9353018216SPaolo Bonzini #define KERNEL_LOAD_ADDR FW_MAX_SIZE 9453018216SPaolo Bonzini 9553018216SPaolo Bonzini #define MIN_RMA_SLOF 128UL 9653018216SPaolo Bonzini 9753018216SPaolo Bonzini #define PHANDLE_XICP 0x00001111 9853018216SPaolo Bonzini 9953018216SPaolo Bonzini #define HTAB_SIZE(spapr) (1ULL << ((spapr)->htab_shift)) 10053018216SPaolo Bonzini 10171cd4dacSCédric Le Goater static ICSState *spapr_ics_create(sPAPRMachineState *spapr, 10271cd4dacSCédric Le Goater const char *type_ics, 103817bb6a4SCédric Le Goater int nr_irqs, Error **errp) 104c04d6cfaSAnthony Liguori { 105175d2aa0SGreg Kurz Error *local_err = NULL; 10671cd4dacSCédric Le Goater Object *obj; 107c04d6cfaSAnthony Liguori 10871cd4dacSCédric Le Goater obj = object_new(type_ics); 109175d2aa0SGreg Kurz object_property_add_child(OBJECT(spapr), "ics", obj, &error_abort); 11071cd4dacSCédric Le Goater object_property_add_const_link(obj, "xics", OBJECT(spapr), &error_abort); 111175d2aa0SGreg Kurz object_property_set_int(obj, nr_irqs, "nr-irqs", &local_err); 112175d2aa0SGreg Kurz if (local_err) { 113175d2aa0SGreg Kurz goto error; 114175d2aa0SGreg Kurz } 11571cd4dacSCédric Le Goater object_property_set_bool(obj, true, "realized", &local_err); 116175d2aa0SGreg Kurz if (local_err) { 117175d2aa0SGreg Kurz goto error; 118c04d6cfaSAnthony Liguori } 119c04d6cfaSAnthony Liguori 12071cd4dacSCédric Le Goater return ICS_SIMPLE(obj); 121175d2aa0SGreg Kurz 122175d2aa0SGreg Kurz error: 123175d2aa0SGreg Kurz error_propagate(errp, local_err); 124175d2aa0SGreg Kurz return NULL; 1255bc8d26dSCédric Le Goater } 1265bc8d26dSCédric Le Goater 12771cd4dacSCédric Le Goater static void xics_system_init(MachineState *machine, int nr_irqs, Error **errp) 128c04d6cfaSAnthony Liguori { 12971cd4dacSCédric Le Goater sPAPRMachineState *spapr = SPAPR_MACHINE(machine); 130c04d6cfaSAnthony Liguori 13111ad93f6SDavid Gibson if (kvm_enabled()) { 1322192a930SCédric Le Goater if (machine_kernel_irqchip_allowed(machine) && 13371cd4dacSCédric Le Goater !xics_kvm_init(spapr, errp)) { 13471cd4dacSCédric Le Goater spapr->icp_type = TYPE_KVM_ICP; 1353d85885aSGreg Kurz spapr->ics = spapr_ics_create(spapr, TYPE_ICS_KVM, nr_irqs, errp); 13611ad93f6SDavid Gibson } 13771cd4dacSCédric Le Goater if (machine_kernel_irqchip_required(machine) && !spapr->ics) { 1383d85885aSGreg Kurz error_prepend(errp, "kernel_irqchip requested but unavailable: "); 1393d85885aSGreg Kurz return; 14011ad93f6SDavid Gibson } 141b83baa60SMarkus Armbruster } 14211ad93f6SDavid Gibson 14371cd4dacSCédric Le Goater if (!spapr->ics) { 144f63ebfe0SGreg Kurz xics_spapr_init(spapr); 14571cd4dacSCédric Le Goater spapr->icp_type = TYPE_ICP; 14671cd4dacSCédric Le Goater spapr->ics = spapr_ics_create(spapr, TYPE_ICS_SIMPLE, nr_irqs, errp); 1473d85885aSGreg Kurz if (!spapr->ics) { 1483d85885aSGreg Kurz return; 1493d85885aSGreg Kurz } 150c04d6cfaSAnthony Liguori } 151c04d6cfaSAnthony Liguori } 152c04d6cfaSAnthony Liguori 153833d4668SAlexey Kardashevskiy static int spapr_fixup_cpu_smt_dt(void *fdt, int offset, PowerPCCPU *cpu, 154833d4668SAlexey Kardashevskiy int smt_threads) 155833d4668SAlexey Kardashevskiy { 156833d4668SAlexey Kardashevskiy int i, ret = 0; 157833d4668SAlexey Kardashevskiy uint32_t servers_prop[smt_threads]; 158833d4668SAlexey Kardashevskiy uint32_t gservers_prop[smt_threads * 2]; 159833d4668SAlexey Kardashevskiy int index = ppc_get_vcpu_dt_id(cpu); 160833d4668SAlexey Kardashevskiy 161d6e166c0SDavid Gibson if (cpu->compat_pvr) { 162d6e166c0SDavid Gibson ret = fdt_setprop_cell(fdt, offset, "cpu-version", cpu->compat_pvr); 1636d9412eaSAlexey Kardashevskiy if (ret < 0) { 1646d9412eaSAlexey Kardashevskiy return ret; 1656d9412eaSAlexey Kardashevskiy } 1666d9412eaSAlexey Kardashevskiy } 1676d9412eaSAlexey Kardashevskiy 168833d4668SAlexey Kardashevskiy /* Build interrupt servers and gservers properties */ 169833d4668SAlexey Kardashevskiy for (i = 0; i < smt_threads; i++) { 170833d4668SAlexey Kardashevskiy servers_prop[i] = cpu_to_be32(index + i); 171833d4668SAlexey Kardashevskiy /* Hack, direct the group queues back to cpu 0 */ 172833d4668SAlexey Kardashevskiy gservers_prop[i*2] = cpu_to_be32(index + i); 173833d4668SAlexey Kardashevskiy gservers_prop[i*2 + 1] = 0; 174833d4668SAlexey Kardashevskiy } 175833d4668SAlexey Kardashevskiy ret = fdt_setprop(fdt, offset, "ibm,ppc-interrupt-server#s", 176833d4668SAlexey Kardashevskiy servers_prop, sizeof(servers_prop)); 177833d4668SAlexey Kardashevskiy if (ret < 0) { 178833d4668SAlexey Kardashevskiy return ret; 179833d4668SAlexey Kardashevskiy } 180833d4668SAlexey Kardashevskiy ret = fdt_setprop(fdt, offset, "ibm,ppc-interrupt-gserver#s", 181833d4668SAlexey Kardashevskiy gservers_prop, sizeof(gservers_prop)); 182833d4668SAlexey Kardashevskiy 183833d4668SAlexey Kardashevskiy return ret; 184833d4668SAlexey Kardashevskiy } 185833d4668SAlexey Kardashevskiy 18699861ecbSIgor Mammedov static int spapr_fixup_cpu_numa_dt(void *fdt, int offset, PowerPCCPU *cpu) 1870da6f3feSBharata B Rao { 1880da6f3feSBharata B Rao int index = ppc_get_vcpu_dt_id(cpu); 1890da6f3feSBharata B Rao uint32_t associativity[] = {cpu_to_be32(0x5), 1900da6f3feSBharata B Rao cpu_to_be32(0x0), 1910da6f3feSBharata B Rao cpu_to_be32(0x0), 1920da6f3feSBharata B Rao cpu_to_be32(0x0), 19315f8b142SIgor Mammedov cpu_to_be32(cpu->node_id), 1940da6f3feSBharata B Rao cpu_to_be32(index)}; 1950da6f3feSBharata B Rao 1960da6f3feSBharata B Rao /* Advertise NUMA via ibm,associativity */ 19799861ecbSIgor Mammedov return fdt_setprop(fdt, offset, "ibm,associativity", associativity, 1980da6f3feSBharata B Rao sizeof(associativity)); 1990da6f3feSBharata B Rao } 2000da6f3feSBharata B Rao 20186d5771aSSam Bobroff /* Populate the "ibm,pa-features" property */ 202e957f6a9SSam Bobroff static void spapr_populate_pa_features(CPUPPCState *env, void *fdt, int offset, 203e957f6a9SSam Bobroff bool legacy_guest) 20486d5771aSSam Bobroff { 20586d5771aSSam Bobroff uint8_t pa_features_206[] = { 6, 0, 20686d5771aSSam Bobroff 0xf6, 0x1f, 0xc7, 0x00, 0x80, 0xc0 }; 20786d5771aSSam Bobroff uint8_t pa_features_207[] = { 24, 0, 20886d5771aSSam Bobroff 0xf6, 0x1f, 0xc7, 0xc0, 0x80, 0xf0, 20986d5771aSSam Bobroff 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 21086d5771aSSam Bobroff 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 21186d5771aSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x00, 0x00 }; 2129fb4541fSSam Bobroff uint8_t pa_features_300[] = { 66, 0, 2139fb4541fSSam Bobroff /* 0: MMU|FPU|SLB|RUN|DABR|NX, 1: fri[nzpm]|DABRX|SPRG3|SLB0|PP110 */ 2149fb4541fSSam Bobroff /* 2: VPM|DS205|PPR|DS202|DS206, 3: LSD|URG, SSO, 5: LE|CFAR|EB|LSQ */ 21586d5771aSSam Bobroff 0xf6, 0x1f, 0xc7, 0xc0, 0x80, 0xf0, /* 0 - 5 */ 2169fb4541fSSam Bobroff /* 6: DS207 */ 21786d5771aSSam Bobroff 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, /* 6 - 11 */ 2189fb4541fSSam Bobroff /* 16: Vector */ 21986d5771aSSam Bobroff 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, /* 12 - 17 */ 2209fb4541fSSam Bobroff /* 18: Vec. Scalar, 20: Vec. XOR, 22: HTM */ 2219bf502feSDavid Gibson 0x80, 0x00, 0x80, 0x00, 0x00, 0x00, /* 18 - 23 */ 2229fb4541fSSam Bobroff /* 24: Ext. Dec, 26: 64 bit ftrs, 28: PM ftrs */ 2239fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, /* 24 - 29 */ 2249fb4541fSSam Bobroff /* 30: MMR, 32: LE atomic, 34: EBB + ext EBB */ 2259fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0xC0, 0x00, /* 30 - 35 */ 2269fb4541fSSam Bobroff /* 36: SPR SO, 38: Copy/Paste, 40: Radix MMU */ 2279fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, /* 36 - 41 */ 2289fb4541fSSam Bobroff /* 42: PM, 44: PC RA, 46: SC vec'd */ 2299fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, /* 42 - 47 */ 2309fb4541fSSam Bobroff /* 48: SIMD, 50: QP BFP, 52: String */ 2319fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, /* 48 - 53 */ 2329fb4541fSSam Bobroff /* 54: DecFP, 56: DecI, 58: SHA */ 2339fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, /* 54 - 59 */ 2349fb4541fSSam Bobroff /* 60: NM atomic, 62: RNG */ 2359fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x00, 0x00, /* 60 - 65 */ 2369fb4541fSSam Bobroff }; 23786d5771aSSam Bobroff uint8_t *pa_features; 23886d5771aSSam Bobroff size_t pa_size; 23986d5771aSSam Bobroff 24086d5771aSSam Bobroff switch (POWERPC_MMU_VER(env->mmu_model)) { 24186d5771aSSam Bobroff case POWERPC_MMU_VER_2_06: 24286d5771aSSam Bobroff pa_features = pa_features_206; 24386d5771aSSam Bobroff pa_size = sizeof(pa_features_206); 24486d5771aSSam Bobroff break; 24586d5771aSSam Bobroff case POWERPC_MMU_VER_2_07: 24686d5771aSSam Bobroff pa_features = pa_features_207; 24786d5771aSSam Bobroff pa_size = sizeof(pa_features_207); 24886d5771aSSam Bobroff break; 24986d5771aSSam Bobroff case POWERPC_MMU_VER_3_00: 25086d5771aSSam Bobroff pa_features = pa_features_300; 25186d5771aSSam Bobroff pa_size = sizeof(pa_features_300); 25286d5771aSSam Bobroff break; 25386d5771aSSam Bobroff default: 25486d5771aSSam Bobroff return; 25586d5771aSSam Bobroff } 25686d5771aSSam Bobroff 25786d5771aSSam Bobroff if (env->ci_large_pages) { 25886d5771aSSam Bobroff /* 25986d5771aSSam Bobroff * Note: we keep CI large pages off by default because a 64K capable 26086d5771aSSam Bobroff * guest provisioned with large pages might otherwise try to map a qemu 26186d5771aSSam Bobroff * framebuffer (or other kind of memory mapped PCI BAR) using 64K pages 26286d5771aSSam Bobroff * even if that qemu runs on a 4k host. 26386d5771aSSam Bobroff * We dd this bit back here if we are confident this is not an issue 26486d5771aSSam Bobroff */ 26586d5771aSSam Bobroff pa_features[3] |= 0x20; 26686d5771aSSam Bobroff } 26786d5771aSSam Bobroff if (kvmppc_has_cap_htm() && pa_size > 24) { 26886d5771aSSam Bobroff pa_features[24] |= 0x80; /* Transactional memory support */ 26986d5771aSSam Bobroff } 270e957f6a9SSam Bobroff if (legacy_guest && pa_size > 40) { 271e957f6a9SSam Bobroff /* Workaround for broken kernels that attempt (guest) radix 272e957f6a9SSam Bobroff * mode when they can't handle it, if they see the radix bit set 273e957f6a9SSam Bobroff * in pa-features. So hide it from them. */ 274e957f6a9SSam Bobroff pa_features[40 + 2] &= ~0x80; /* Radix MMU */ 275e957f6a9SSam Bobroff } 27686d5771aSSam Bobroff 27786d5771aSSam Bobroff _FDT((fdt_setprop(fdt, offset, "ibm,pa-features", pa_features, pa_size))); 27886d5771aSSam Bobroff } 27986d5771aSSam Bobroff 28028e02042SDavid Gibson static int spapr_fixup_cpu_dt(void *fdt, sPAPRMachineState *spapr) 28153018216SPaolo Bonzini { 28282677ed2SAlexey Kardashevskiy int ret = 0, offset, cpus_offset; 28382677ed2SAlexey Kardashevskiy CPUState *cs; 28453018216SPaolo Bonzini char cpu_model[32]; 28553018216SPaolo Bonzini int smt = kvmppc_smt_threads(); 28653018216SPaolo Bonzini uint32_t pft_size_prop[] = {0, cpu_to_be32(spapr->htab_shift)}; 28753018216SPaolo Bonzini 28882677ed2SAlexey Kardashevskiy CPU_FOREACH(cs) { 28982677ed2SAlexey Kardashevskiy PowerPCCPU *cpu = POWERPC_CPU(cs); 290e957f6a9SSam Bobroff CPUPPCState *env = &cpu->env; 29182677ed2SAlexey Kardashevskiy DeviceClass *dc = DEVICE_GET_CLASS(cs); 29282677ed2SAlexey Kardashevskiy int index = ppc_get_vcpu_dt_id(cpu); 29312dbeb16SDavid Gibson int compat_smt = MIN(smp_threads, ppc_compat_max_threads(cpu)); 29453018216SPaolo Bonzini 2950f20ba62SAlexey Kardashevskiy if ((index % smt) != 0) { 29653018216SPaolo Bonzini continue; 29753018216SPaolo Bonzini } 29853018216SPaolo Bonzini 29982677ed2SAlexey Kardashevskiy snprintf(cpu_model, 32, "%s@%x", dc->fw_name, index); 30053018216SPaolo Bonzini 30182677ed2SAlexey Kardashevskiy cpus_offset = fdt_path_offset(fdt, "/cpus"); 30282677ed2SAlexey Kardashevskiy if (cpus_offset < 0) { 30382677ed2SAlexey Kardashevskiy cpus_offset = fdt_add_subnode(fdt, fdt_path_offset(fdt, "/"), 30482677ed2SAlexey Kardashevskiy "cpus"); 30582677ed2SAlexey Kardashevskiy if (cpus_offset < 0) { 30682677ed2SAlexey Kardashevskiy return cpus_offset; 30782677ed2SAlexey Kardashevskiy } 30882677ed2SAlexey Kardashevskiy } 30982677ed2SAlexey Kardashevskiy offset = fdt_subnode_offset(fdt, cpus_offset, cpu_model); 31082677ed2SAlexey Kardashevskiy if (offset < 0) { 31182677ed2SAlexey Kardashevskiy offset = fdt_add_subnode(fdt, cpus_offset, cpu_model); 31253018216SPaolo Bonzini if (offset < 0) { 31353018216SPaolo Bonzini return offset; 31453018216SPaolo Bonzini } 31582677ed2SAlexey Kardashevskiy } 31653018216SPaolo Bonzini 3170da6f3feSBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,pft-size", 3180da6f3feSBharata B Rao pft_size_prop, sizeof(pft_size_prop)); 31953018216SPaolo Bonzini if (ret < 0) { 32053018216SPaolo Bonzini return ret; 32153018216SPaolo Bonzini } 32253018216SPaolo Bonzini 32399861ecbSIgor Mammedov if (nb_numa_nodes > 1) { 32499861ecbSIgor Mammedov ret = spapr_fixup_cpu_numa_dt(fdt, offset, cpu); 32553018216SPaolo Bonzini if (ret < 0) { 32653018216SPaolo Bonzini return ret; 32753018216SPaolo Bonzini } 32899861ecbSIgor Mammedov } 329833d4668SAlexey Kardashevskiy 33012dbeb16SDavid Gibson ret = spapr_fixup_cpu_smt_dt(fdt, offset, cpu, compat_smt); 331833d4668SAlexey Kardashevskiy if (ret < 0) { 332833d4668SAlexey Kardashevskiy return ret; 333833d4668SAlexey Kardashevskiy } 334e957f6a9SSam Bobroff 335e957f6a9SSam Bobroff spapr_populate_pa_features(env, fdt, offset, 336e957f6a9SSam Bobroff spapr->cas_legacy_guest_workaround); 33753018216SPaolo Bonzini } 33853018216SPaolo Bonzini return ret; 33953018216SPaolo Bonzini } 34053018216SPaolo Bonzini 341b082d65aSAlexey Kardashevskiy static hwaddr spapr_node0_size(void) 342b082d65aSAlexey Kardashevskiy { 343fb164994SDavid Gibson MachineState *machine = MACHINE(qdev_get_machine()); 344fb164994SDavid Gibson 345b082d65aSAlexey Kardashevskiy if (nb_numa_nodes) { 346b082d65aSAlexey Kardashevskiy int i; 347b082d65aSAlexey Kardashevskiy for (i = 0; i < nb_numa_nodes; ++i) { 348b082d65aSAlexey Kardashevskiy if (numa_info[i].node_mem) { 349fb164994SDavid Gibson return MIN(pow2floor(numa_info[i].node_mem), 350fb164994SDavid Gibson machine->ram_size); 351b082d65aSAlexey Kardashevskiy } 352b082d65aSAlexey Kardashevskiy } 353b082d65aSAlexey Kardashevskiy } 354fb164994SDavid Gibson return machine->ram_size; 355b082d65aSAlexey Kardashevskiy } 356b082d65aSAlexey Kardashevskiy 357a1d59c0fSAlexey Kardashevskiy static void add_str(GString *s, const gchar *s1) 358a1d59c0fSAlexey Kardashevskiy { 359a1d59c0fSAlexey Kardashevskiy g_string_append_len(s, s1, strlen(s1) + 1); 360a1d59c0fSAlexey Kardashevskiy } 36153018216SPaolo Bonzini 36203d196b7SBharata B Rao static int spapr_populate_memory_node(void *fdt, int nodeid, hwaddr start, 36326a8c353SAlexey Kardashevskiy hwaddr size) 36426a8c353SAlexey Kardashevskiy { 36526a8c353SAlexey Kardashevskiy uint32_t associativity[] = { 36626a8c353SAlexey Kardashevskiy cpu_to_be32(0x4), /* length */ 36726a8c353SAlexey Kardashevskiy cpu_to_be32(0x0), cpu_to_be32(0x0), 368c3b4f589SAlexey Kardashevskiy cpu_to_be32(0x0), cpu_to_be32(nodeid) 36926a8c353SAlexey Kardashevskiy }; 37026a8c353SAlexey Kardashevskiy char mem_name[32]; 37126a8c353SAlexey Kardashevskiy uint64_t mem_reg_property[2]; 37226a8c353SAlexey Kardashevskiy int off; 37326a8c353SAlexey Kardashevskiy 37426a8c353SAlexey Kardashevskiy mem_reg_property[0] = cpu_to_be64(start); 37526a8c353SAlexey Kardashevskiy mem_reg_property[1] = cpu_to_be64(size); 37626a8c353SAlexey Kardashevskiy 37726a8c353SAlexey Kardashevskiy sprintf(mem_name, "memory@" TARGET_FMT_lx, start); 37826a8c353SAlexey Kardashevskiy off = fdt_add_subnode(fdt, 0, mem_name); 37926a8c353SAlexey Kardashevskiy _FDT(off); 38026a8c353SAlexey Kardashevskiy _FDT((fdt_setprop_string(fdt, off, "device_type", "memory"))); 38126a8c353SAlexey Kardashevskiy _FDT((fdt_setprop(fdt, off, "reg", mem_reg_property, 38226a8c353SAlexey Kardashevskiy sizeof(mem_reg_property)))); 38326a8c353SAlexey Kardashevskiy _FDT((fdt_setprop(fdt, off, "ibm,associativity", associativity, 38426a8c353SAlexey Kardashevskiy sizeof(associativity)))); 38503d196b7SBharata B Rao return off; 38626a8c353SAlexey Kardashevskiy } 38726a8c353SAlexey Kardashevskiy 38828e02042SDavid Gibson static int spapr_populate_memory(sPAPRMachineState *spapr, void *fdt) 38953018216SPaolo Bonzini { 390fb164994SDavid Gibson MachineState *machine = MACHINE(spapr); 3917db8a127SAlexey Kardashevskiy hwaddr mem_start, node_size; 3927db8a127SAlexey Kardashevskiy int i, nb_nodes = nb_numa_nodes; 3937db8a127SAlexey Kardashevskiy NodeInfo *nodes = numa_info; 3947db8a127SAlexey Kardashevskiy NodeInfo ramnode; 39553018216SPaolo Bonzini 3967db8a127SAlexey Kardashevskiy /* No NUMA nodes, assume there is just one node with whole RAM */ 3977db8a127SAlexey Kardashevskiy if (!nb_numa_nodes) { 3987db8a127SAlexey Kardashevskiy nb_nodes = 1; 399fb164994SDavid Gibson ramnode.node_mem = machine->ram_size; 4007db8a127SAlexey Kardashevskiy nodes = &ramnode; 4015fe269b1SPaul Mackerras } 40253018216SPaolo Bonzini 4037db8a127SAlexey Kardashevskiy for (i = 0, mem_start = 0; i < nb_nodes; ++i) { 4047db8a127SAlexey Kardashevskiy if (!nodes[i].node_mem) { 4057db8a127SAlexey Kardashevskiy continue; 40653018216SPaolo Bonzini } 407fb164994SDavid Gibson if (mem_start >= machine->ram_size) { 4085fe269b1SPaul Mackerras node_size = 0; 4095fe269b1SPaul Mackerras } else { 4107db8a127SAlexey Kardashevskiy node_size = nodes[i].node_mem; 411fb164994SDavid Gibson if (node_size > machine->ram_size - mem_start) { 412fb164994SDavid Gibson node_size = machine->ram_size - mem_start; 4135fe269b1SPaul Mackerras } 4145fe269b1SPaul Mackerras } 4157db8a127SAlexey Kardashevskiy if (!mem_start) { 4167db8a127SAlexey Kardashevskiy /* ppc_spapr_init() checks for rma_size <= node0_size already */ 417e8f986fcSBharata B Rao spapr_populate_memory_node(fdt, i, 0, spapr->rma_size); 4187db8a127SAlexey Kardashevskiy mem_start += spapr->rma_size; 4197db8a127SAlexey Kardashevskiy node_size -= spapr->rma_size; 4207db8a127SAlexey Kardashevskiy } 4216010818cSAlexey Kardashevskiy for ( ; node_size; ) { 4226010818cSAlexey Kardashevskiy hwaddr sizetmp = pow2floor(node_size); 4236010818cSAlexey Kardashevskiy 4246010818cSAlexey Kardashevskiy /* mem_start != 0 here */ 4256010818cSAlexey Kardashevskiy if (ctzl(mem_start) < ctzl(sizetmp)) { 4266010818cSAlexey Kardashevskiy sizetmp = 1ULL << ctzl(mem_start); 4276010818cSAlexey Kardashevskiy } 4286010818cSAlexey Kardashevskiy 4296010818cSAlexey Kardashevskiy spapr_populate_memory_node(fdt, i, mem_start, sizetmp); 4306010818cSAlexey Kardashevskiy node_size -= sizetmp; 4316010818cSAlexey Kardashevskiy mem_start += sizetmp; 4326010818cSAlexey Kardashevskiy } 43353018216SPaolo Bonzini } 43453018216SPaolo Bonzini 43553018216SPaolo Bonzini return 0; 43653018216SPaolo Bonzini } 43753018216SPaolo Bonzini 4380da6f3feSBharata B Rao static void spapr_populate_cpu_dt(CPUState *cs, void *fdt, int offset, 4390da6f3feSBharata B Rao sPAPRMachineState *spapr) 4400da6f3feSBharata B Rao { 4410da6f3feSBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(cs); 4420da6f3feSBharata B Rao CPUPPCState *env = &cpu->env; 4430da6f3feSBharata B Rao PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(cs); 4440da6f3feSBharata B Rao int index = ppc_get_vcpu_dt_id(cpu); 4450da6f3feSBharata B Rao uint32_t segs[] = {cpu_to_be32(28), cpu_to_be32(40), 4460da6f3feSBharata B Rao 0xffffffff, 0xffffffff}; 447afd10a0fSBharata B Rao uint32_t tbfreq = kvm_enabled() ? kvmppc_get_tbfreq() 448afd10a0fSBharata B Rao : SPAPR_TIMEBASE_FREQ; 4490da6f3feSBharata B Rao uint32_t cpufreq = kvm_enabled() ? kvmppc_get_clockfreq() : 1000000000; 4500da6f3feSBharata B Rao uint32_t page_sizes_prop[64]; 4510da6f3feSBharata B Rao size_t page_sizes_prop_size; 45222419c2aSDavid Gibson uint32_t vcpus_per_socket = smp_threads * smp_cores; 4530da6f3feSBharata B Rao uint32_t pft_size_prop[] = {0, cpu_to_be32(spapr->htab_shift)}; 45412dbeb16SDavid Gibson int compat_smt = MIN(smp_threads, ppc_compat_max_threads(cpu)); 455af81cf32SBharata B Rao sPAPRDRConnector *drc; 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 460fbf55397SDavid Gibson drc = spapr_drc_by_id(TYPE_SPAPR_DRC_CPU, index); 461af81cf32SBharata B Rao if (drc) { 4620b55aa91SDavid Gibson drc_index = spapr_drc_index(drc); 463af81cf32SBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,my-drc-index", drc_index))); 464af81cf32SBharata B Rao } 4650da6f3feSBharata B Rao 4660da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "reg", index))); 4670da6f3feSBharata B Rao _FDT((fdt_setprop_string(fdt, offset, "device_type", "cpu"))); 4680da6f3feSBharata B Rao 4690da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "cpu-version", env->spr[SPR_PVR]))); 4700da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "d-cache-block-size", 4710da6f3feSBharata B Rao env->dcache_line_size))); 4720da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "d-cache-line-size", 4730da6f3feSBharata B Rao env->dcache_line_size))); 4740da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "i-cache-block-size", 4750da6f3feSBharata B Rao env->icache_line_size))); 4760da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "i-cache-line-size", 4770da6f3feSBharata B Rao env->icache_line_size))); 4780da6f3feSBharata B Rao 4790da6f3feSBharata B Rao if (pcc->l1_dcache_size) { 4800da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "d-cache-size", 4810da6f3feSBharata B Rao pcc->l1_dcache_size))); 4820da6f3feSBharata B Rao } else { 483ce9863b7SCédric Le Goater error_report("Warning: Unknown L1 dcache size for cpu"); 4840da6f3feSBharata B Rao } 4850da6f3feSBharata B Rao if (pcc->l1_icache_size) { 4860da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "i-cache-size", 4870da6f3feSBharata B Rao pcc->l1_icache_size))); 4880da6f3feSBharata B Rao } else { 489ce9863b7SCédric Le Goater error_report("Warning: Unknown L1 icache size for cpu"); 4900da6f3feSBharata B Rao } 4910da6f3feSBharata B Rao 4920da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "timebase-frequency", tbfreq))); 4930da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "clock-frequency", cpufreq))); 494fd5da5c4SThomas Huth _FDT((fdt_setprop_cell(fdt, offset, "slb-size", env->slb_nr))); 4950da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,slb-size", env->slb_nr))); 4960da6f3feSBharata B Rao _FDT((fdt_setprop_string(fdt, offset, "status", "okay"))); 4970da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "64-bit", NULL, 0))); 4980da6f3feSBharata B Rao 4990da6f3feSBharata B Rao if (env->spr_cb[SPR_PURR].oea_read) { 5000da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,purr", NULL, 0))); 5010da6f3feSBharata B Rao } 5020da6f3feSBharata B Rao 5030da6f3feSBharata B Rao if (env->mmu_model & POWERPC_MMU_1TSEG) { 5040da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,processor-segment-sizes", 5050da6f3feSBharata B Rao segs, sizeof(segs)))); 5060da6f3feSBharata B Rao } 5070da6f3feSBharata B Rao 5080da6f3feSBharata B Rao /* Advertise VMX/VSX (vector extensions) if available 5090da6f3feSBharata B Rao * 0 / no property == no vector extensions 5100da6f3feSBharata B Rao * 1 == VMX / Altivec available 5110da6f3feSBharata B Rao * 2 == VSX available */ 5120da6f3feSBharata B Rao if (env->insns_flags & PPC_ALTIVEC) { 5130da6f3feSBharata B Rao uint32_t vmx = (env->insns_flags2 & PPC2_VSX) ? 2 : 1; 5140da6f3feSBharata B Rao 5150da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,vmx", vmx))); 5160da6f3feSBharata B Rao } 5170da6f3feSBharata B Rao 5180da6f3feSBharata B Rao /* Advertise DFP (Decimal Floating Point) if available 5190da6f3feSBharata B Rao * 0 / no property == no DFP 5200da6f3feSBharata B Rao * 1 == DFP available */ 5210da6f3feSBharata B Rao if (env->insns_flags2 & PPC2_DFP) { 5220da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,dfp", 1))); 5230da6f3feSBharata B Rao } 5240da6f3feSBharata B Rao 5253654fa95SCédric Le Goater page_sizes_prop_size = ppc_create_page_sizes_prop(env, page_sizes_prop, 5260da6f3feSBharata B Rao sizeof(page_sizes_prop)); 5270da6f3feSBharata B Rao if (page_sizes_prop_size) { 5280da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,segment-page-sizes", 5290da6f3feSBharata B Rao page_sizes_prop, page_sizes_prop_size))); 5300da6f3feSBharata B Rao } 5310da6f3feSBharata B Rao 532e957f6a9SSam Bobroff spapr_populate_pa_features(env, fdt, offset, false); 53390da0d5aSBenjamin Herrenschmidt 5340da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,chip-id", 53522419c2aSDavid Gibson cs->cpu_index / vcpus_per_socket))); 5360da6f3feSBharata B Rao 5370da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,pft-size", 5380da6f3feSBharata B Rao pft_size_prop, sizeof(pft_size_prop)))); 5390da6f3feSBharata B Rao 54099861ecbSIgor Mammedov if (nb_numa_nodes > 1) { 54199861ecbSIgor Mammedov _FDT(spapr_fixup_cpu_numa_dt(fdt, offset, cpu)); 54299861ecbSIgor Mammedov } 5430da6f3feSBharata B Rao 54412dbeb16SDavid Gibson _FDT(spapr_fixup_cpu_smt_dt(fdt, offset, cpu, compat_smt)); 545c64abd1fSSam Bobroff 546c64abd1fSSam Bobroff if (pcc->radix_page_info) { 547c64abd1fSSam Bobroff for (i = 0; i < pcc->radix_page_info->count; i++) { 548c64abd1fSSam Bobroff radix_AP_encodings[i] = 549c64abd1fSSam Bobroff cpu_to_be32(pcc->radix_page_info->entries[i]); 550c64abd1fSSam Bobroff } 551c64abd1fSSam Bobroff _FDT((fdt_setprop(fdt, offset, "ibm,processor-radix-AP-encodings", 552c64abd1fSSam Bobroff radix_AP_encodings, 553c64abd1fSSam Bobroff pcc->radix_page_info->count * 554c64abd1fSSam Bobroff sizeof(radix_AP_encodings[0])))); 555c64abd1fSSam Bobroff } 5560da6f3feSBharata B Rao } 5570da6f3feSBharata B Rao 5580da6f3feSBharata B Rao static void spapr_populate_cpus_dt_node(void *fdt, sPAPRMachineState *spapr) 5590da6f3feSBharata B Rao { 5600da6f3feSBharata B Rao CPUState *cs; 5610da6f3feSBharata B Rao int cpus_offset; 5620da6f3feSBharata B Rao char *nodename; 5630da6f3feSBharata B Rao int smt = kvmppc_smt_threads(); 5640da6f3feSBharata B Rao 5650da6f3feSBharata B Rao cpus_offset = fdt_add_subnode(fdt, 0, "cpus"); 5660da6f3feSBharata B Rao _FDT(cpus_offset); 5670da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, cpus_offset, "#address-cells", 0x1))); 5680da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, cpus_offset, "#size-cells", 0x0))); 5690da6f3feSBharata B Rao 5700da6f3feSBharata B Rao /* 5710da6f3feSBharata B Rao * We walk the CPUs in reverse order to ensure that CPU DT nodes 5720da6f3feSBharata B Rao * created by fdt_add_subnode() end up in the right order in FDT 5730da6f3feSBharata B Rao * for the guest kernel the enumerate the CPUs correctly. 5740da6f3feSBharata B Rao */ 5750da6f3feSBharata B Rao CPU_FOREACH_REVERSE(cs) { 5760da6f3feSBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(cs); 5770da6f3feSBharata B Rao int index = ppc_get_vcpu_dt_id(cpu); 5780da6f3feSBharata B Rao DeviceClass *dc = DEVICE_GET_CLASS(cs); 5790da6f3feSBharata B Rao int offset; 5800da6f3feSBharata B Rao 5810da6f3feSBharata B Rao if ((index % smt) != 0) { 5820da6f3feSBharata B Rao continue; 5830da6f3feSBharata B Rao } 5840da6f3feSBharata B Rao 5850da6f3feSBharata B Rao nodename = g_strdup_printf("%s@%x", dc->fw_name, index); 5860da6f3feSBharata B Rao offset = fdt_add_subnode(fdt, cpus_offset, nodename); 5870da6f3feSBharata B Rao g_free(nodename); 5880da6f3feSBharata B Rao _FDT(offset); 5890da6f3feSBharata B Rao spapr_populate_cpu_dt(cs, fdt, offset, spapr); 5900da6f3feSBharata B Rao } 5910da6f3feSBharata B Rao 5920da6f3feSBharata B Rao } 5930da6f3feSBharata B Rao 59403d196b7SBharata B Rao /* 59503d196b7SBharata B Rao * Adds ibm,dynamic-reconfiguration-memory node. 59603d196b7SBharata B Rao * Refer to docs/specs/ppc-spapr-hotplug.txt for the documentation 59703d196b7SBharata B Rao * of this device tree node. 59803d196b7SBharata B Rao */ 59903d196b7SBharata B Rao static int spapr_populate_drconf_memory(sPAPRMachineState *spapr, void *fdt) 60003d196b7SBharata B Rao { 60103d196b7SBharata B Rao MachineState *machine = MACHINE(spapr); 60203d196b7SBharata B Rao int ret, i, offset; 60303d196b7SBharata B Rao uint64_t lmb_size = SPAPR_MEMORY_BLOCK_SIZE; 60403d196b7SBharata B Rao uint32_t prop_lmb_size[] = {0, cpu_to_be32(lmb_size)}; 605d0e5a8f2SBharata B Rao uint32_t hotplug_lmb_start = spapr->hotplug_memory.base / lmb_size; 606d0e5a8f2SBharata B Rao uint32_t nr_lmbs = (spapr->hotplug_memory.base + 607d0e5a8f2SBharata B Rao memory_region_size(&spapr->hotplug_memory.mr)) / 608d0e5a8f2SBharata B Rao lmb_size; 60903d196b7SBharata B Rao uint32_t *int_buf, *cur_index, buf_len; 6106663864eSBharata B Rao int nr_nodes = nb_numa_nodes ? nb_numa_nodes : 1; 61103d196b7SBharata B Rao 612ef001f06SThomas Huth /* 613d0e5a8f2SBharata B Rao * Don't create the node if there is no hotpluggable memory 61416c25aefSBharata B Rao */ 615d0e5a8f2SBharata B Rao if (machine->ram_size == machine->maxram_size) { 61616c25aefSBharata B Rao return 0; 61716c25aefSBharata B Rao } 61816c25aefSBharata B Rao 61916c25aefSBharata B Rao /* 620ef001f06SThomas Huth * Allocate enough buffer size to fit in ibm,dynamic-memory 621ef001f06SThomas Huth * or ibm,associativity-lookup-arrays 622ef001f06SThomas Huth */ 623ef001f06SThomas Huth buf_len = MAX(nr_lmbs * SPAPR_DR_LMB_LIST_ENTRY_SIZE + 1, nr_nodes * 4 + 2) 624ef001f06SThomas Huth * sizeof(uint32_t); 62503d196b7SBharata B Rao cur_index = int_buf = g_malloc0(buf_len); 62603d196b7SBharata B Rao 62703d196b7SBharata B Rao offset = fdt_add_subnode(fdt, 0, "ibm,dynamic-reconfiguration-memory"); 62803d196b7SBharata B Rao 62903d196b7SBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,lmb-size", prop_lmb_size, 63003d196b7SBharata B Rao sizeof(prop_lmb_size)); 63103d196b7SBharata B Rao if (ret < 0) { 63203d196b7SBharata B Rao goto out; 63303d196b7SBharata B Rao } 63403d196b7SBharata B Rao 63503d196b7SBharata B Rao ret = fdt_setprop_cell(fdt, offset, "ibm,memory-flags-mask", 0xff); 63603d196b7SBharata B Rao if (ret < 0) { 63703d196b7SBharata B Rao goto out; 63803d196b7SBharata B Rao } 63903d196b7SBharata B Rao 64003d196b7SBharata B Rao ret = fdt_setprop_cell(fdt, offset, "ibm,memory-preservation-time", 0x0); 64103d196b7SBharata B Rao if (ret < 0) { 64203d196b7SBharata B Rao goto out; 64303d196b7SBharata B Rao } 64403d196b7SBharata B Rao 64503d196b7SBharata B Rao /* ibm,dynamic-memory */ 64603d196b7SBharata B Rao int_buf[0] = cpu_to_be32(nr_lmbs); 64703d196b7SBharata B Rao cur_index++; 64803d196b7SBharata B Rao for (i = 0; i < nr_lmbs; i++) { 649d0e5a8f2SBharata B Rao uint64_t addr = i * lmb_size; 65003d196b7SBharata B Rao uint32_t *dynamic_memory = cur_index; 65103d196b7SBharata B Rao 652d0e5a8f2SBharata B Rao if (i >= hotplug_lmb_start) { 653d0e5a8f2SBharata B Rao sPAPRDRConnector *drc; 654d0e5a8f2SBharata B Rao 655fbf55397SDavid Gibson drc = spapr_drc_by_id(TYPE_SPAPR_DRC_LMB, i); 65603d196b7SBharata B Rao g_assert(drc); 65703d196b7SBharata B Rao 65803d196b7SBharata B Rao dynamic_memory[0] = cpu_to_be32(addr >> 32); 65903d196b7SBharata B Rao dynamic_memory[1] = cpu_to_be32(addr & 0xffffffff); 6600b55aa91SDavid Gibson dynamic_memory[2] = cpu_to_be32(spapr_drc_index(drc)); 66103d196b7SBharata B Rao dynamic_memory[3] = cpu_to_be32(0); /* reserved */ 66203d196b7SBharata B Rao dynamic_memory[4] = cpu_to_be32(numa_get_node(addr, NULL)); 663d0e5a8f2SBharata B Rao if (memory_region_present(get_system_memory(), addr)) { 66403d196b7SBharata B Rao dynamic_memory[5] = cpu_to_be32(SPAPR_LMB_FLAGS_ASSIGNED); 66503d196b7SBharata B Rao } else { 66603d196b7SBharata B Rao dynamic_memory[5] = cpu_to_be32(0); 66703d196b7SBharata B Rao } 668d0e5a8f2SBharata B Rao } else { 669d0e5a8f2SBharata B Rao /* 670d0e5a8f2SBharata B Rao * LMB information for RMA, boot time RAM and gap b/n RAM and 671d0e5a8f2SBharata B Rao * hotplug memory region -- all these are marked as reserved 672d0e5a8f2SBharata B Rao * and as having no valid DRC. 673d0e5a8f2SBharata B Rao */ 674d0e5a8f2SBharata B Rao dynamic_memory[0] = cpu_to_be32(addr >> 32); 675d0e5a8f2SBharata B Rao dynamic_memory[1] = cpu_to_be32(addr & 0xffffffff); 676d0e5a8f2SBharata B Rao dynamic_memory[2] = cpu_to_be32(0); 677d0e5a8f2SBharata B Rao dynamic_memory[3] = cpu_to_be32(0); /* reserved */ 678d0e5a8f2SBharata B Rao dynamic_memory[4] = cpu_to_be32(-1); 679d0e5a8f2SBharata B Rao dynamic_memory[5] = cpu_to_be32(SPAPR_LMB_FLAGS_RESERVED | 680d0e5a8f2SBharata B Rao SPAPR_LMB_FLAGS_DRC_INVALID); 681d0e5a8f2SBharata B Rao } 68203d196b7SBharata B Rao 68303d196b7SBharata B Rao cur_index += SPAPR_DR_LMB_LIST_ENTRY_SIZE; 68403d196b7SBharata B Rao } 68503d196b7SBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,dynamic-memory", int_buf, buf_len); 68603d196b7SBharata B Rao if (ret < 0) { 68703d196b7SBharata B Rao goto out; 68803d196b7SBharata B Rao } 68903d196b7SBharata B Rao 69003d196b7SBharata B Rao /* ibm,associativity-lookup-arrays */ 69103d196b7SBharata B Rao cur_index = int_buf; 6926663864eSBharata B Rao int_buf[0] = cpu_to_be32(nr_nodes); 69303d196b7SBharata B Rao int_buf[1] = cpu_to_be32(4); /* Number of entries per associativity list */ 69403d196b7SBharata B Rao cur_index += 2; 6956663864eSBharata B Rao for (i = 0; i < nr_nodes; i++) { 69603d196b7SBharata B Rao uint32_t associativity[] = { 69703d196b7SBharata B Rao cpu_to_be32(0x0), 69803d196b7SBharata B Rao cpu_to_be32(0x0), 69903d196b7SBharata B Rao cpu_to_be32(0x0), 70003d196b7SBharata B Rao cpu_to_be32(i) 70103d196b7SBharata B Rao }; 70203d196b7SBharata B Rao memcpy(cur_index, associativity, sizeof(associativity)); 70303d196b7SBharata B Rao cur_index += 4; 70403d196b7SBharata B Rao } 70503d196b7SBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,associativity-lookup-arrays", int_buf, 70603d196b7SBharata B Rao (cur_index - int_buf) * sizeof(uint32_t)); 70703d196b7SBharata B Rao out: 70803d196b7SBharata B Rao g_free(int_buf); 70903d196b7SBharata B Rao return ret; 71003d196b7SBharata B Rao } 71103d196b7SBharata B Rao 7126787d27bSMichael Roth static int spapr_dt_cas_updates(sPAPRMachineState *spapr, void *fdt, 7136787d27bSMichael Roth sPAPROptionVector *ov5_updates) 7146787d27bSMichael Roth { 7156787d27bSMichael Roth sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(spapr); 716417ece33SMichael Roth int ret = 0, offset; 7176787d27bSMichael Roth 7186787d27bSMichael Roth /* Generate ibm,dynamic-reconfiguration-memory node if required */ 7196787d27bSMichael Roth if (spapr_ovec_test(ov5_updates, OV5_DRCONF_MEMORY)) { 7206787d27bSMichael Roth g_assert(smc->dr_lmb_enabled); 7216787d27bSMichael Roth ret = spapr_populate_drconf_memory(spapr, fdt); 722417ece33SMichael Roth if (ret) { 723417ece33SMichael Roth goto out; 724417ece33SMichael Roth } 7256787d27bSMichael Roth } 7266787d27bSMichael Roth 727417ece33SMichael Roth offset = fdt_path_offset(fdt, "/chosen"); 728417ece33SMichael Roth if (offset < 0) { 729417ece33SMichael Roth offset = fdt_add_subnode(fdt, 0, "chosen"); 730417ece33SMichael Roth if (offset < 0) { 731417ece33SMichael Roth return offset; 732417ece33SMichael Roth } 733417ece33SMichael Roth } 734417ece33SMichael Roth ret = spapr_ovec_populate_dt(fdt, offset, spapr->ov5_cas, 735417ece33SMichael Roth "ibm,architecture-vec-5"); 736417ece33SMichael Roth 737417ece33SMichael Roth out: 7386787d27bSMichael Roth return ret; 7396787d27bSMichael Roth } 7406787d27bSMichael Roth 74103d196b7SBharata B Rao int spapr_h_cas_compose_response(sPAPRMachineState *spapr, 74203d196b7SBharata B Rao target_ulong addr, target_ulong size, 7436787d27bSMichael Roth sPAPROptionVector *ov5_updates) 74403d196b7SBharata B Rao { 74503d196b7SBharata B Rao void *fdt, *fdt_skel; 74603d196b7SBharata B Rao sPAPRDeviceTreeUpdateHeader hdr = { .version_id = 1 }; 74703d196b7SBharata B Rao 74803d196b7SBharata B Rao size -= sizeof(hdr); 74903d196b7SBharata B Rao 75003d196b7SBharata B Rao /* Create sceleton */ 75103d196b7SBharata B Rao fdt_skel = g_malloc0(size); 75203d196b7SBharata B Rao _FDT((fdt_create(fdt_skel, size))); 75303d196b7SBharata B Rao _FDT((fdt_begin_node(fdt_skel, ""))); 75403d196b7SBharata B Rao _FDT((fdt_end_node(fdt_skel))); 75503d196b7SBharata B Rao _FDT((fdt_finish(fdt_skel))); 75603d196b7SBharata B Rao fdt = g_malloc0(size); 75703d196b7SBharata B Rao _FDT((fdt_open_into(fdt_skel, fdt, size))); 75803d196b7SBharata B Rao g_free(fdt_skel); 75903d196b7SBharata B Rao 76003d196b7SBharata B Rao /* Fixup cpu nodes */ 76103d196b7SBharata B Rao _FDT((spapr_fixup_cpu_dt(fdt, spapr))); 76203d196b7SBharata B Rao 7636787d27bSMichael Roth if (spapr_dt_cas_updates(spapr, fdt, ov5_updates)) { 7646787d27bSMichael Roth return -1; 76503d196b7SBharata B Rao } 76603d196b7SBharata B Rao 76703d196b7SBharata B Rao /* Pack resulting tree */ 76803d196b7SBharata B Rao _FDT((fdt_pack(fdt))); 76903d196b7SBharata B Rao 77003d196b7SBharata B Rao if (fdt_totalsize(fdt) + sizeof(hdr) > size) { 77103d196b7SBharata B Rao trace_spapr_cas_failed(size); 77203d196b7SBharata B Rao return -1; 77303d196b7SBharata B Rao } 77403d196b7SBharata B Rao 77503d196b7SBharata B Rao cpu_physical_memory_write(addr, &hdr, sizeof(hdr)); 77603d196b7SBharata B Rao cpu_physical_memory_write(addr + sizeof(hdr), fdt, fdt_totalsize(fdt)); 77703d196b7SBharata B Rao trace_spapr_cas_continue(fdt_totalsize(fdt) + sizeof(hdr)); 77803d196b7SBharata B Rao g_free(fdt); 77903d196b7SBharata B Rao 78003d196b7SBharata B Rao return 0; 78103d196b7SBharata B Rao } 78203d196b7SBharata B Rao 7833f5dabceSDavid Gibson static void spapr_dt_rtas(sPAPRMachineState *spapr, void *fdt) 7843f5dabceSDavid Gibson { 7853f5dabceSDavid Gibson int rtas; 7863f5dabceSDavid Gibson GString *hypertas = g_string_sized_new(256); 7873f5dabceSDavid Gibson GString *qemu_hypertas = g_string_sized_new(256); 7883f5dabceSDavid Gibson uint32_t refpoints[] = { cpu_to_be32(0x4), cpu_to_be32(0x4) }; 7893f5dabceSDavid Gibson uint64_t max_hotplug_addr = spapr->hotplug_memory.base + 7903f5dabceSDavid Gibson memory_region_size(&spapr->hotplug_memory.mr); 7913f5dabceSDavid Gibson uint32_t lrdr_capacity[] = { 7923f5dabceSDavid Gibson cpu_to_be32(max_hotplug_addr >> 32), 7933f5dabceSDavid Gibson cpu_to_be32(max_hotplug_addr & 0xffffffff), 7943f5dabceSDavid Gibson 0, cpu_to_be32(SPAPR_MEMORY_BLOCK_SIZE), 7953f5dabceSDavid Gibson cpu_to_be32(max_cpus / smp_threads), 7963f5dabceSDavid Gibson }; 7973f5dabceSDavid Gibson 7983f5dabceSDavid Gibson _FDT(rtas = fdt_add_subnode(fdt, 0, "rtas")); 7993f5dabceSDavid Gibson 8003f5dabceSDavid Gibson /* hypertas */ 8013f5dabceSDavid Gibson add_str(hypertas, "hcall-pft"); 8023f5dabceSDavid Gibson add_str(hypertas, "hcall-term"); 8033f5dabceSDavid Gibson add_str(hypertas, "hcall-dabr"); 8043f5dabceSDavid Gibson add_str(hypertas, "hcall-interrupt"); 8053f5dabceSDavid Gibson add_str(hypertas, "hcall-tce"); 8063f5dabceSDavid Gibson add_str(hypertas, "hcall-vio"); 8073f5dabceSDavid Gibson add_str(hypertas, "hcall-splpar"); 8083f5dabceSDavid Gibson add_str(hypertas, "hcall-bulk"); 8093f5dabceSDavid Gibson add_str(hypertas, "hcall-set-mode"); 8103f5dabceSDavid Gibson add_str(hypertas, "hcall-sprg0"); 8113f5dabceSDavid Gibson add_str(hypertas, "hcall-copy"); 8123f5dabceSDavid Gibson add_str(hypertas, "hcall-debug"); 8133f5dabceSDavid Gibson add_str(qemu_hypertas, "hcall-memop1"); 8143f5dabceSDavid Gibson 8153f5dabceSDavid Gibson if (!kvm_enabled() || kvmppc_spapr_use_multitce()) { 8163f5dabceSDavid Gibson add_str(hypertas, "hcall-multi-tce"); 8173f5dabceSDavid Gibson } 8183f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,hypertas-functions", 8193f5dabceSDavid Gibson hypertas->str, hypertas->len)); 8203f5dabceSDavid Gibson g_string_free(hypertas, TRUE); 8213f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "qemu,hypertas-functions", 8223f5dabceSDavid Gibson qemu_hypertas->str, qemu_hypertas->len)); 8233f5dabceSDavid Gibson g_string_free(qemu_hypertas, TRUE); 8243f5dabceSDavid Gibson 8253f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,associativity-reference-points", 8263f5dabceSDavid Gibson refpoints, sizeof(refpoints))); 8273f5dabceSDavid Gibson 8283f5dabceSDavid Gibson _FDT(fdt_setprop_cell(fdt, rtas, "rtas-error-log-max", 8293f5dabceSDavid Gibson RTAS_ERROR_LOG_MAX)); 8303f5dabceSDavid Gibson _FDT(fdt_setprop_cell(fdt, rtas, "rtas-event-scan-rate", 8313f5dabceSDavid Gibson RTAS_EVENT_SCAN_RATE)); 8323f5dabceSDavid Gibson 8333f5dabceSDavid Gibson if (msi_nonbroken) { 8343f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,change-msix-capable", NULL, 0)); 8353f5dabceSDavid Gibson } 8363f5dabceSDavid Gibson 8373f5dabceSDavid Gibson /* 8383f5dabceSDavid Gibson * According to PAPR, rtas ibm,os-term does not guarantee a return 8393f5dabceSDavid Gibson * back to the guest cpu. 8403f5dabceSDavid Gibson * 8413f5dabceSDavid Gibson * While an additional ibm,extended-os-term property indicates 8423f5dabceSDavid Gibson * that rtas call return will always occur. Set this property. 8433f5dabceSDavid Gibson */ 8443f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,extended-os-term", NULL, 0)); 8453f5dabceSDavid Gibson 8463f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,lrdr-capacity", 8473f5dabceSDavid Gibson lrdr_capacity, sizeof(lrdr_capacity))); 8483f5dabceSDavid Gibson 8493f5dabceSDavid Gibson spapr_dt_rtas_tokens(fdt, rtas); 8503f5dabceSDavid Gibson } 8513f5dabceSDavid Gibson 8529fb4541fSSam Bobroff /* Prepare ibm,arch-vec-5-platform-support, which indicates the MMU features 8539fb4541fSSam Bobroff * that the guest may request and thus the valid values for bytes 24..26 of 8549fb4541fSSam Bobroff * option vector 5: */ 8559fb4541fSSam Bobroff static void spapr_dt_ov5_platform_support(void *fdt, int chosen) 8569fb4541fSSam Bobroff { 857545d6e2bSSuraj Jitindar Singh PowerPCCPU *first_ppc_cpu = POWERPC_CPU(first_cpu); 858545d6e2bSSuraj Jitindar Singh 8599fb4541fSSam Bobroff char val[2 * 3] = { 8609fb4541fSSam Bobroff 24, 0x00, /* Hash/Radix, filled in below. */ 8619fb4541fSSam Bobroff 25, 0x00, /* Hash options: Segment Tables == no, GTSE == no. */ 8629fb4541fSSam Bobroff 26, 0x40, /* Radix options: GTSE == yes. */ 8639fb4541fSSam Bobroff }; 8649fb4541fSSam Bobroff 8659fb4541fSSam Bobroff if (kvm_enabled()) { 8669fb4541fSSam Bobroff if (kvmppc_has_cap_mmu_radix() && kvmppc_has_cap_mmu_hash_v3()) { 8679fb4541fSSam Bobroff val[1] = 0x80; /* OV5_MMU_BOTH */ 8689fb4541fSSam Bobroff } else if (kvmppc_has_cap_mmu_radix()) { 8699fb4541fSSam Bobroff val[1] = 0x40; /* OV5_MMU_RADIX_300 */ 8709fb4541fSSam Bobroff } else { 8719fb4541fSSam Bobroff val[1] = 0x00; /* Hash */ 8729fb4541fSSam Bobroff } 8739fb4541fSSam Bobroff } else { 874545d6e2bSSuraj Jitindar Singh if (first_ppc_cpu->env.mmu_model & POWERPC_MMU_V3) { 875545d6e2bSSuraj Jitindar Singh /* V3 MMU supports both hash and radix (with dynamic switching) */ 876545d6e2bSSuraj Jitindar Singh val[1] = 0xC0; 877545d6e2bSSuraj Jitindar Singh } else { 878545d6e2bSSuraj Jitindar Singh /* Otherwise we can only do hash */ 8799fb4541fSSam Bobroff val[1] = 0x00; 8809fb4541fSSam Bobroff } 881545d6e2bSSuraj Jitindar Singh } 8829fb4541fSSam Bobroff _FDT(fdt_setprop(fdt, chosen, "ibm,arch-vec-5-platform-support", 8839fb4541fSSam Bobroff val, sizeof(val))); 8849fb4541fSSam Bobroff } 8859fb4541fSSam Bobroff 8867c866c6aSDavid Gibson static void spapr_dt_chosen(sPAPRMachineState *spapr, void *fdt) 8877c866c6aSDavid Gibson { 8887c866c6aSDavid Gibson MachineState *machine = MACHINE(spapr); 8897c866c6aSDavid Gibson int chosen; 8907c866c6aSDavid Gibson const char *boot_device = machine->boot_order; 8917c866c6aSDavid Gibson char *stdout_path = spapr_vio_stdout_path(spapr->vio_bus); 8927c866c6aSDavid Gibson size_t cb = 0; 8937c866c6aSDavid Gibson char *bootlist = get_boot_devices_list(&cb, true); 8947c866c6aSDavid Gibson 8957c866c6aSDavid Gibson _FDT(chosen = fdt_add_subnode(fdt, 0, "chosen")); 8967c866c6aSDavid Gibson 8977c866c6aSDavid Gibson _FDT(fdt_setprop_string(fdt, chosen, "bootargs", machine->kernel_cmdline)); 8987c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "linux,initrd-start", 8997c866c6aSDavid Gibson spapr->initrd_base)); 9007c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "linux,initrd-end", 9017c866c6aSDavid Gibson spapr->initrd_base + spapr->initrd_size)); 9027c866c6aSDavid Gibson 9037c866c6aSDavid Gibson if (spapr->kernel_size) { 9047c866c6aSDavid Gibson uint64_t kprop[2] = { cpu_to_be64(KERNEL_LOAD_ADDR), 9057c866c6aSDavid Gibson cpu_to_be64(spapr->kernel_size) }; 9067c866c6aSDavid Gibson 9077c866c6aSDavid Gibson _FDT(fdt_setprop(fdt, chosen, "qemu,boot-kernel", 9087c866c6aSDavid Gibson &kprop, sizeof(kprop))); 9097c866c6aSDavid Gibson if (spapr->kernel_le) { 9107c866c6aSDavid Gibson _FDT(fdt_setprop(fdt, chosen, "qemu,boot-kernel-le", NULL, 0)); 9117c866c6aSDavid Gibson } 9127c866c6aSDavid Gibson } 9137c866c6aSDavid Gibson if (boot_menu) { 9147c866c6aSDavid Gibson _FDT((fdt_setprop_cell(fdt, chosen, "qemu,boot-menu", boot_menu))); 9157c866c6aSDavid Gibson } 9167c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "qemu,graphic-width", graphic_width)); 9177c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "qemu,graphic-height", graphic_height)); 9187c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "qemu,graphic-depth", graphic_depth)); 9197c866c6aSDavid Gibson 9207c866c6aSDavid Gibson if (cb && bootlist) { 9217c866c6aSDavid Gibson int i; 9227c866c6aSDavid Gibson 9237c866c6aSDavid Gibson for (i = 0; i < cb; i++) { 9247c866c6aSDavid Gibson if (bootlist[i] == '\n') { 9257c866c6aSDavid Gibson bootlist[i] = ' '; 9267c866c6aSDavid Gibson } 9277c866c6aSDavid Gibson } 9287c866c6aSDavid Gibson _FDT(fdt_setprop_string(fdt, chosen, "qemu,boot-list", bootlist)); 9297c866c6aSDavid Gibson } 9307c866c6aSDavid Gibson 9317c866c6aSDavid Gibson if (boot_device && strlen(boot_device)) { 9327c866c6aSDavid Gibson _FDT(fdt_setprop_string(fdt, chosen, "qemu,boot-device", boot_device)); 9337c866c6aSDavid Gibson } 9347c866c6aSDavid Gibson 9357c866c6aSDavid Gibson if (!spapr->has_graphics && stdout_path) { 9367c866c6aSDavid Gibson _FDT(fdt_setprop_string(fdt, chosen, "linux,stdout-path", stdout_path)); 9377c866c6aSDavid Gibson } 9387c866c6aSDavid Gibson 9399fb4541fSSam Bobroff spapr_dt_ov5_platform_support(fdt, chosen); 9409fb4541fSSam Bobroff 9417c866c6aSDavid Gibson g_free(stdout_path); 9427c866c6aSDavid Gibson g_free(bootlist); 9437c866c6aSDavid Gibson } 9447c866c6aSDavid Gibson 945fca5f2dcSDavid Gibson static void spapr_dt_hypervisor(sPAPRMachineState *spapr, void *fdt) 946fca5f2dcSDavid Gibson { 947fca5f2dcSDavid Gibson /* The /hypervisor node isn't in PAPR - this is a hack to allow PR 948fca5f2dcSDavid Gibson * KVM to work under pHyp with some guest co-operation */ 949fca5f2dcSDavid Gibson int hypervisor; 950fca5f2dcSDavid Gibson uint8_t hypercall[16]; 951fca5f2dcSDavid Gibson 952fca5f2dcSDavid Gibson _FDT(hypervisor = fdt_add_subnode(fdt, 0, "hypervisor")); 953fca5f2dcSDavid Gibson /* indicate KVM hypercall interface */ 954fca5f2dcSDavid Gibson _FDT(fdt_setprop_string(fdt, hypervisor, "compatible", "linux,kvm")); 955fca5f2dcSDavid Gibson if (kvmppc_has_cap_fixup_hcalls()) { 956fca5f2dcSDavid Gibson /* 957fca5f2dcSDavid Gibson * Older KVM versions with older guest kernels were broken 958fca5f2dcSDavid Gibson * with the magic page, don't allow the guest to map it. 959fca5f2dcSDavid Gibson */ 960fca5f2dcSDavid Gibson if (!kvmppc_get_hypercall(first_cpu->env_ptr, hypercall, 961fca5f2dcSDavid Gibson sizeof(hypercall))) { 962fca5f2dcSDavid Gibson _FDT(fdt_setprop(fdt, hypervisor, "hcall-instructions", 963fca5f2dcSDavid Gibson hypercall, sizeof(hypercall))); 964fca5f2dcSDavid Gibson } 965fca5f2dcSDavid Gibson } 966fca5f2dcSDavid Gibson } 967fca5f2dcSDavid Gibson 968997b6cfcSDavid Gibson static void *spapr_build_fdt(sPAPRMachineState *spapr, 96953018216SPaolo Bonzini hwaddr rtas_addr, 97053018216SPaolo Bonzini hwaddr rtas_size) 97153018216SPaolo Bonzini { 9725b2128d2SAlexander Graf MachineState *machine = MACHINE(qdev_get_machine()); 9733c0c47e3SDavid Gibson MachineClass *mc = MACHINE_GET_CLASS(machine); 974c20d332aSBharata B Rao sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(machine); 9757c866c6aSDavid Gibson int ret; 97653018216SPaolo Bonzini void *fdt; 97753018216SPaolo Bonzini sPAPRPHBState *phb; 978398a0bd5SDavid Gibson char *buf; 97971cd4dacSCédric Le Goater int smt = kvmppc_smt_threads(); 98053018216SPaolo Bonzini 981398a0bd5SDavid Gibson fdt = g_malloc0(FDT_MAX_SIZE); 982398a0bd5SDavid Gibson _FDT((fdt_create_empty_tree(fdt, FDT_MAX_SIZE))); 98353018216SPaolo Bonzini 984398a0bd5SDavid Gibson /* Root node */ 985398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "device_type", "chrp")); 986398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "model", "IBM pSeries (emulated by qemu)")); 987398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "compatible", "qemu,pseries")); 988398a0bd5SDavid Gibson 989398a0bd5SDavid Gibson /* 990398a0bd5SDavid Gibson * Add info to guest to indentify which host is it being run on 991398a0bd5SDavid Gibson * and what is the uuid of the guest 992398a0bd5SDavid Gibson */ 993398a0bd5SDavid Gibson if (kvmppc_get_host_model(&buf)) { 994398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "host-model", buf)); 995398a0bd5SDavid Gibson g_free(buf); 996398a0bd5SDavid Gibson } 997398a0bd5SDavid Gibson if (kvmppc_get_host_serial(&buf)) { 998398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "host-serial", buf)); 999398a0bd5SDavid Gibson g_free(buf); 1000398a0bd5SDavid Gibson } 1001398a0bd5SDavid Gibson 1002398a0bd5SDavid Gibson buf = qemu_uuid_unparse_strdup(&qemu_uuid); 1003398a0bd5SDavid Gibson 1004398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "vm,uuid", buf)); 1005398a0bd5SDavid Gibson if (qemu_uuid_set) { 1006398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "system-id", buf)); 1007398a0bd5SDavid Gibson } 1008398a0bd5SDavid Gibson g_free(buf); 1009398a0bd5SDavid Gibson 1010398a0bd5SDavid Gibson if (qemu_get_vm_name()) { 1011398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "ibm,partition-name", 1012398a0bd5SDavid Gibson qemu_get_vm_name())); 1013398a0bd5SDavid Gibson } 1014398a0bd5SDavid Gibson 1015398a0bd5SDavid Gibson _FDT(fdt_setprop_cell(fdt, 0, "#address-cells", 2)); 1016398a0bd5SDavid Gibson _FDT(fdt_setprop_cell(fdt, 0, "#size-cells", 2)); 101753018216SPaolo Bonzini 10189b9a1908SDavid Gibson /* /interrupt controller */ 101971cd4dacSCédric Le Goater spapr_dt_xics(DIV_ROUND_UP(max_cpus * smt, smp_threads), fdt, PHANDLE_XICP); 10209b9a1908SDavid Gibson 1021e8f986fcSBharata B Rao ret = spapr_populate_memory(spapr, fdt); 1022e8f986fcSBharata B Rao if (ret < 0) { 1023ce9863b7SCédric Le Goater error_report("couldn't setup memory nodes in fdt"); 1024e8f986fcSBharata B Rao exit(1); 102553018216SPaolo Bonzini } 102653018216SPaolo Bonzini 1027bf5a6696SDavid Gibson /* /vdevice */ 1028bf5a6696SDavid Gibson spapr_dt_vdevice(spapr->vio_bus, fdt); 102953018216SPaolo Bonzini 10304d9392beSThomas Huth if (object_resolve_path_type("", TYPE_SPAPR_RNG, NULL)) { 10314d9392beSThomas Huth ret = spapr_rng_populate_dt(fdt); 10324d9392beSThomas Huth if (ret < 0) { 1033ce9863b7SCédric Le Goater error_report("could not set up rng device in the fdt"); 10344d9392beSThomas Huth exit(1); 10354d9392beSThomas Huth } 10364d9392beSThomas Huth } 10374d9392beSThomas Huth 103853018216SPaolo Bonzini QLIST_FOREACH(phb, &spapr->phbs, list) { 103953018216SPaolo Bonzini ret = spapr_populate_pci_dt(phb, PHANDLE_XICP, fdt); 104053018216SPaolo Bonzini if (ret < 0) { 1041da34fed7SThomas Huth error_report("couldn't setup PCI devices in fdt"); 104253018216SPaolo Bonzini exit(1); 104353018216SPaolo Bonzini } 1044da34fed7SThomas Huth } 104553018216SPaolo Bonzini 10460da6f3feSBharata B Rao /* cpus */ 10470da6f3feSBharata B Rao spapr_populate_cpus_dt_node(fdt, spapr); 104853018216SPaolo Bonzini 1049c20d332aSBharata B Rao if (smc->dr_lmb_enabled) { 1050c20d332aSBharata B Rao _FDT(spapr_drc_populate_dt(fdt, 0, NULL, SPAPR_DR_CONNECTOR_TYPE_LMB)); 1051c20d332aSBharata B Rao } 1052c20d332aSBharata B Rao 1053c5514d0eSIgor Mammedov if (mc->has_hotpluggable_cpus) { 1054af81cf32SBharata B Rao int offset = fdt_path_offset(fdt, "/cpus"); 1055af81cf32SBharata B Rao ret = spapr_drc_populate_dt(fdt, offset, NULL, 1056af81cf32SBharata B Rao SPAPR_DR_CONNECTOR_TYPE_CPU); 1057af81cf32SBharata B Rao if (ret < 0) { 1058af81cf32SBharata B Rao error_report("Couldn't set up CPU DR device tree properties"); 1059af81cf32SBharata B Rao exit(1); 1060af81cf32SBharata B Rao } 1061af81cf32SBharata B Rao } 1062af81cf32SBharata B Rao 1063ffb1e275SDavid Gibson /* /event-sources */ 1064ffbb1705SMichael Roth spapr_dt_events(spapr, fdt); 1065ffb1e275SDavid Gibson 10663f5dabceSDavid Gibson /* /rtas */ 10673f5dabceSDavid Gibson spapr_dt_rtas(spapr, fdt); 10683f5dabceSDavid Gibson 10697c866c6aSDavid Gibson /* /chosen */ 10707c866c6aSDavid Gibson spapr_dt_chosen(spapr, fdt); 1071cf6e5223SDavid Gibson 1072fca5f2dcSDavid Gibson /* /hypervisor */ 1073fca5f2dcSDavid Gibson if (kvm_enabled()) { 1074fca5f2dcSDavid Gibson spapr_dt_hypervisor(spapr, fdt); 1075fca5f2dcSDavid Gibson } 1076fca5f2dcSDavid Gibson 1077cf6e5223SDavid Gibson /* Build memory reserve map */ 1078cf6e5223SDavid Gibson if (spapr->kernel_size) { 1079cf6e5223SDavid Gibson _FDT((fdt_add_mem_rsv(fdt, KERNEL_LOAD_ADDR, spapr->kernel_size))); 1080cf6e5223SDavid Gibson } 1081cf6e5223SDavid Gibson if (spapr->initrd_size) { 1082cf6e5223SDavid Gibson _FDT((fdt_add_mem_rsv(fdt, spapr->initrd_base, spapr->initrd_size))); 1083cf6e5223SDavid Gibson } 1084cf6e5223SDavid Gibson 10856787d27bSMichael Roth /* ibm,client-architecture-support updates */ 10866787d27bSMichael Roth ret = spapr_dt_cas_updates(spapr, fdt, spapr->ov5_cas); 10876787d27bSMichael Roth if (ret < 0) { 10886787d27bSMichael Roth error_report("couldn't setup CAS properties fdt"); 10896787d27bSMichael Roth exit(1); 10906787d27bSMichael Roth } 10916787d27bSMichael Roth 1092997b6cfcSDavid Gibson return fdt; 109353018216SPaolo Bonzini } 109453018216SPaolo Bonzini 109553018216SPaolo Bonzini static uint64_t translate_kernel_address(void *opaque, uint64_t addr) 109653018216SPaolo Bonzini { 109753018216SPaolo Bonzini return (addr & 0x0fffffff) + KERNEL_LOAD_ADDR; 109853018216SPaolo Bonzini } 109953018216SPaolo Bonzini 11001d1be34dSDavid Gibson static void emulate_spapr_hypercall(PPCVirtualHypervisor *vhyp, 11011d1be34dSDavid Gibson PowerPCCPU *cpu) 110253018216SPaolo Bonzini { 110353018216SPaolo Bonzini CPUPPCState *env = &cpu->env; 110453018216SPaolo Bonzini 11058d04fb55SJan Kiszka /* The TCG path should also be holding the BQL at this point */ 11068d04fb55SJan Kiszka g_assert(qemu_mutex_iothread_locked()); 11078d04fb55SJan Kiszka 110853018216SPaolo Bonzini if (msr_pr) { 110953018216SPaolo Bonzini hcall_dprintf("Hypercall made with MSR[PR]=1\n"); 111053018216SPaolo Bonzini env->gpr[3] = H_PRIVILEGE; 111153018216SPaolo Bonzini } else { 111253018216SPaolo Bonzini env->gpr[3] = spapr_hypercall(cpu, env->gpr[3], &env->gpr[4]); 111353018216SPaolo Bonzini } 111453018216SPaolo Bonzini } 111553018216SPaolo Bonzini 11169861bb3eSSuraj Jitindar Singh static uint64_t spapr_get_patbe(PPCVirtualHypervisor *vhyp) 11179861bb3eSSuraj Jitindar Singh { 11189861bb3eSSuraj Jitindar Singh sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 11199861bb3eSSuraj Jitindar Singh 11209861bb3eSSuraj Jitindar Singh return spapr->patb_entry; 11219861bb3eSSuraj Jitindar Singh } 11229861bb3eSSuraj Jitindar Singh 1123e6b8fd24SSamuel Mendoza-Jonas #define HPTE(_table, _i) (void *)(((uint64_t *)(_table)) + ((_i) * 2)) 1124e6b8fd24SSamuel Mendoza-Jonas #define HPTE_VALID(_hpte) (tswap64(*((uint64_t *)(_hpte))) & HPTE64_V_VALID) 1125e6b8fd24SSamuel Mendoza-Jonas #define HPTE_DIRTY(_hpte) (tswap64(*((uint64_t *)(_hpte))) & HPTE64_V_HPTE_DIRTY) 1126e6b8fd24SSamuel Mendoza-Jonas #define CLEAN_HPTE(_hpte) ((*(uint64_t *)(_hpte)) &= tswap64(~HPTE64_V_HPTE_DIRTY)) 1127e6b8fd24SSamuel Mendoza-Jonas #define DIRTY_HPTE(_hpte) ((*(uint64_t *)(_hpte)) |= tswap64(HPTE64_V_HPTE_DIRTY)) 1128e6b8fd24SSamuel Mendoza-Jonas 1129715c5407SDavid Gibson /* 1130715c5407SDavid Gibson * Get the fd to access the kernel htab, re-opening it if necessary 1131715c5407SDavid Gibson */ 1132715c5407SDavid Gibson static int get_htab_fd(sPAPRMachineState *spapr) 1133715c5407SDavid Gibson { 1134715c5407SDavid Gibson if (spapr->htab_fd >= 0) { 1135715c5407SDavid Gibson return spapr->htab_fd; 1136715c5407SDavid Gibson } 1137715c5407SDavid Gibson 1138715c5407SDavid Gibson spapr->htab_fd = kvmppc_get_htab_fd(false); 1139715c5407SDavid Gibson if (spapr->htab_fd < 0) { 1140715c5407SDavid Gibson error_report("Unable to open fd for reading hash table from KVM: %s", 1141715c5407SDavid Gibson strerror(errno)); 1142715c5407SDavid Gibson } 1143715c5407SDavid Gibson 1144715c5407SDavid Gibson return spapr->htab_fd; 1145715c5407SDavid Gibson } 1146715c5407SDavid Gibson 1147b4db5413SSuraj Jitindar Singh void close_htab_fd(sPAPRMachineState *spapr) 1148715c5407SDavid Gibson { 1149715c5407SDavid Gibson if (spapr->htab_fd >= 0) { 1150715c5407SDavid Gibson close(spapr->htab_fd); 1151715c5407SDavid Gibson } 1152715c5407SDavid Gibson spapr->htab_fd = -1; 1153715c5407SDavid Gibson } 1154715c5407SDavid Gibson 1155e57ca75cSDavid Gibson static hwaddr spapr_hpt_mask(PPCVirtualHypervisor *vhyp) 1156e57ca75cSDavid Gibson { 1157e57ca75cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 1158e57ca75cSDavid Gibson 1159e57ca75cSDavid Gibson return HTAB_SIZE(spapr) / HASH_PTEG_SIZE_64 - 1; 1160e57ca75cSDavid Gibson } 1161e57ca75cSDavid Gibson 1162e57ca75cSDavid Gibson static const ppc_hash_pte64_t *spapr_map_hptes(PPCVirtualHypervisor *vhyp, 1163e57ca75cSDavid Gibson hwaddr ptex, int n) 1164e57ca75cSDavid Gibson { 1165e57ca75cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 1166e57ca75cSDavid Gibson hwaddr pte_offset = ptex * HASH_PTE_SIZE_64; 1167e57ca75cSDavid Gibson 1168e57ca75cSDavid Gibson if (!spapr->htab) { 1169e57ca75cSDavid Gibson /* 1170e57ca75cSDavid Gibson * HTAB is controlled by KVM. Fetch into temporary buffer 1171e57ca75cSDavid Gibson */ 1172e57ca75cSDavid Gibson ppc_hash_pte64_t *hptes = g_malloc(n * HASH_PTE_SIZE_64); 1173e57ca75cSDavid Gibson kvmppc_read_hptes(hptes, ptex, n); 1174e57ca75cSDavid Gibson return hptes; 1175e57ca75cSDavid Gibson } 1176e57ca75cSDavid Gibson 1177e57ca75cSDavid Gibson /* 1178e57ca75cSDavid Gibson * HTAB is controlled by QEMU. Just point to the internally 1179e57ca75cSDavid Gibson * accessible PTEG. 1180e57ca75cSDavid Gibson */ 1181e57ca75cSDavid Gibson return (const ppc_hash_pte64_t *)(spapr->htab + pte_offset); 1182e57ca75cSDavid Gibson } 1183e57ca75cSDavid Gibson 1184e57ca75cSDavid Gibson static void spapr_unmap_hptes(PPCVirtualHypervisor *vhyp, 1185e57ca75cSDavid Gibson const ppc_hash_pte64_t *hptes, 1186e57ca75cSDavid Gibson hwaddr ptex, int n) 1187e57ca75cSDavid Gibson { 1188e57ca75cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 1189e57ca75cSDavid Gibson 1190e57ca75cSDavid Gibson if (!spapr->htab) { 1191e57ca75cSDavid Gibson g_free((void *)hptes); 1192e57ca75cSDavid Gibson } 1193e57ca75cSDavid Gibson 1194e57ca75cSDavid Gibson /* Nothing to do for qemu managed HPT */ 1195e57ca75cSDavid Gibson } 1196e57ca75cSDavid Gibson 1197e57ca75cSDavid Gibson static void spapr_store_hpte(PPCVirtualHypervisor *vhyp, hwaddr ptex, 1198e57ca75cSDavid Gibson uint64_t pte0, uint64_t pte1) 1199e57ca75cSDavid Gibson { 1200e57ca75cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 1201e57ca75cSDavid Gibson hwaddr offset = ptex * HASH_PTE_SIZE_64; 1202e57ca75cSDavid Gibson 1203e57ca75cSDavid Gibson if (!spapr->htab) { 1204e57ca75cSDavid Gibson kvmppc_write_hpte(ptex, pte0, pte1); 1205e57ca75cSDavid Gibson } else { 1206e57ca75cSDavid Gibson stq_p(spapr->htab + offset, pte0); 1207e57ca75cSDavid Gibson stq_p(spapr->htab + offset + HASH_PTE_SIZE_64 / 2, pte1); 1208e57ca75cSDavid Gibson } 1209e57ca75cSDavid Gibson } 1210e57ca75cSDavid Gibson 12118dfe8e7fSDavid Gibson static int spapr_hpt_shift_for_ramsize(uint64_t ramsize) 12128dfe8e7fSDavid Gibson { 12138dfe8e7fSDavid Gibson int shift; 12148dfe8e7fSDavid Gibson 12158dfe8e7fSDavid Gibson /* We aim for a hash table of size 1/128 the size of RAM (rounded 12168dfe8e7fSDavid Gibson * up). The PAPR recommendation is actually 1/64 of RAM size, but 12178dfe8e7fSDavid Gibson * that's much more than is needed for Linux guests */ 12188dfe8e7fSDavid Gibson shift = ctz64(pow2ceil(ramsize)) - 7; 12198dfe8e7fSDavid Gibson shift = MAX(shift, 18); /* Minimum architected size */ 12208dfe8e7fSDavid Gibson shift = MIN(shift, 46); /* Maximum architected size */ 12218dfe8e7fSDavid Gibson return shift; 12228dfe8e7fSDavid Gibson } 12238dfe8e7fSDavid Gibson 122406ec79e8SBharata B Rao void spapr_free_hpt(sPAPRMachineState *spapr) 122506ec79e8SBharata B Rao { 122606ec79e8SBharata B Rao g_free(spapr->htab); 122706ec79e8SBharata B Rao spapr->htab = NULL; 122806ec79e8SBharata B Rao spapr->htab_shift = 0; 122906ec79e8SBharata B Rao close_htab_fd(spapr); 123006ec79e8SBharata B Rao } 123106ec79e8SBharata B Rao 1232c5f54f3eSDavid Gibson static void spapr_reallocate_hpt(sPAPRMachineState *spapr, int shift, 1233c5f54f3eSDavid Gibson Error **errp) 123453018216SPaolo Bonzini { 1235c5f54f3eSDavid Gibson long rc; 123653018216SPaolo Bonzini 1237c5f54f3eSDavid Gibson /* Clean up any HPT info from a previous boot */ 123806ec79e8SBharata B Rao spapr_free_hpt(spapr); 123953018216SPaolo Bonzini 1240c5f54f3eSDavid Gibson rc = kvmppc_reset_htab(shift); 1241c5f54f3eSDavid Gibson if (rc < 0) { 1242c5f54f3eSDavid Gibson /* kernel-side HPT needed, but couldn't allocate one */ 1243c5f54f3eSDavid Gibson error_setg_errno(errp, errno, 1244c5f54f3eSDavid Gibson "Failed to allocate KVM HPT of order %d (try smaller maxmem?)", 1245c5f54f3eSDavid Gibson shift); 1246c5f54f3eSDavid Gibson /* This is almost certainly fatal, but if the caller really 1247c5f54f3eSDavid Gibson * wants to carry on with shift == 0, it's welcome to try */ 1248c5f54f3eSDavid Gibson } else if (rc > 0) { 1249c5f54f3eSDavid Gibson /* kernel-side HPT allocated */ 1250c5f54f3eSDavid Gibson if (rc != shift) { 1251c5f54f3eSDavid Gibson error_setg(errp, 1252c5f54f3eSDavid Gibson "Requested order %d HPT, but kernel allocated order %ld (try smaller maxmem?)", 1253c5f54f3eSDavid Gibson shift, rc); 12547735fedaSBharata B Rao } 12557735fedaSBharata B Rao 125653018216SPaolo Bonzini spapr->htab_shift = shift; 1257c18ad9a5SDavid Gibson spapr->htab = NULL; 1258b817772aSBharata B Rao } else { 1259c5f54f3eSDavid Gibson /* kernel-side HPT not needed, allocate in userspace instead */ 1260c5f54f3eSDavid Gibson size_t size = 1ULL << shift; 1261c5f54f3eSDavid Gibson int i; 126201a57972SSamuel Mendoza-Jonas 1263c5f54f3eSDavid Gibson spapr->htab = qemu_memalign(size, size); 1264c5f54f3eSDavid Gibson if (!spapr->htab) { 1265c5f54f3eSDavid Gibson error_setg_errno(errp, errno, 1266c5f54f3eSDavid Gibson "Could not allocate HPT of order %d", shift); 1267c5f54f3eSDavid Gibson return; 1268b817772aSBharata B Rao } 1269b817772aSBharata B Rao 1270c5f54f3eSDavid Gibson memset(spapr->htab, 0, size); 1271c5f54f3eSDavid Gibson spapr->htab_shift = shift; 1272b817772aSBharata B Rao 1273c5f54f3eSDavid Gibson for (i = 0; i < size / HASH_PTE_SIZE_64; i++) { 1274c5f54f3eSDavid Gibson DIRTY_HPTE(HPTE(spapr->htab, i)); 12757735fedaSBharata B Rao } 127653018216SPaolo Bonzini } 127753018216SPaolo Bonzini } 127853018216SPaolo Bonzini 1279b4db5413SSuraj Jitindar Singh void spapr_setup_hpt_and_vrma(sPAPRMachineState *spapr) 1280b4db5413SSuraj Jitindar Singh { 1281b4db5413SSuraj Jitindar Singh spapr_reallocate_hpt(spapr, 1282b4db5413SSuraj Jitindar Singh spapr_hpt_shift_for_ramsize(MACHINE(spapr)->maxram_size), 1283b4db5413SSuraj Jitindar Singh &error_fatal); 1284b4db5413SSuraj Jitindar Singh if (spapr->vrma_adjust) { 1285b4db5413SSuraj Jitindar Singh spapr->rma_size = kvmppc_rma_size(spapr_node0_size(), 1286b4db5413SSuraj Jitindar Singh spapr->htab_shift); 1287b4db5413SSuraj Jitindar Singh } 1288b4db5413SSuraj Jitindar Singh /* We're setting up a hash table, so that means we're not radix */ 1289b4db5413SSuraj Jitindar Singh spapr->patb_entry = 0; 1290b4db5413SSuraj Jitindar Singh } 1291b4db5413SSuraj Jitindar Singh 12924f01a637SDavid Gibson static void find_unknown_sysbus_device(SysBusDevice *sbdev, void *opaque) 12939e3f9733SAlexander Graf { 12949e3f9733SAlexander Graf bool matched = false; 12959e3f9733SAlexander Graf 12969e3f9733SAlexander Graf if (object_dynamic_cast(OBJECT(sbdev), TYPE_SPAPR_PCI_HOST_BRIDGE)) { 12979e3f9733SAlexander Graf matched = true; 12989e3f9733SAlexander Graf } 12999e3f9733SAlexander Graf 13009e3f9733SAlexander Graf if (!matched) { 13019e3f9733SAlexander Graf error_report("Device %s is not supported by this machine yet.", 13029e3f9733SAlexander Graf qdev_fw_name(DEVICE(sbdev))); 13039e3f9733SAlexander Graf exit(1); 13049e3f9733SAlexander Graf } 13059e3f9733SAlexander Graf } 13069e3f9733SAlexander Graf 130753018216SPaolo Bonzini static void ppc_spapr_reset(void) 130853018216SPaolo Bonzini { 1309c5f54f3eSDavid Gibson MachineState *machine = MACHINE(qdev_get_machine()); 1310c5f54f3eSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(machine); 1311182735efSAndreas Färber PowerPCCPU *first_ppc_cpu; 1312b7d1f77aSBenjamin Herrenschmidt uint32_t rtas_limit; 1313cae172abSDavid Gibson hwaddr rtas_addr, fdt_addr; 1314997b6cfcSDavid Gibson void *fdt; 1315997b6cfcSDavid Gibson int rc; 1316259186a7SAndreas Färber 13179e3f9733SAlexander Graf /* Check for unknown sysbus devices */ 13189e3f9733SAlexander Graf foreach_dynamic_sysbus_device(find_unknown_sysbus_device, NULL); 13199e3f9733SAlexander Graf 1320b4db5413SSuraj Jitindar Singh if (kvm_enabled() && kvmppc_has_cap_mmu_radix()) { 1321b4db5413SSuraj Jitindar Singh /* If using KVM with radix mode available, VCPUs can be started 1322b4db5413SSuraj Jitindar Singh * without a HPT because KVM will start them in radix mode. 1323b4db5413SSuraj Jitindar Singh * Set the GR bit in PATB so that we know there is no HPT. */ 1324b4db5413SSuraj Jitindar Singh spapr->patb_entry = PATBE1_GR; 1325b4db5413SSuraj Jitindar Singh } else { 13269861bb3eSSuraj Jitindar Singh spapr->patb_entry = 0; 1327b4db5413SSuraj Jitindar Singh spapr_setup_hpt_and_vrma(spapr); 1328c5f54f3eSDavid Gibson } 132953018216SPaolo Bonzini 133053018216SPaolo Bonzini qemu_devices_reset(); 133153018216SPaolo Bonzini 1332b7d1f77aSBenjamin Herrenschmidt /* 1333b7d1f77aSBenjamin Herrenschmidt * We place the device tree and RTAS just below either the top of the RMA, 1334b7d1f77aSBenjamin Herrenschmidt * or just below 2GB, whichever is lowere, so that it can be 1335b7d1f77aSBenjamin Herrenschmidt * processed with 32-bit real mode code if necessary 1336b7d1f77aSBenjamin Herrenschmidt */ 1337b7d1f77aSBenjamin Herrenschmidt rtas_limit = MIN(spapr->rma_size, RTAS_MAX_ADDR); 1338cae172abSDavid Gibson rtas_addr = rtas_limit - RTAS_MAX_SIZE; 1339cae172abSDavid Gibson fdt_addr = rtas_addr - FDT_MAX_SIZE; 1340b7d1f77aSBenjamin Herrenschmidt 13416787d27bSMichael Roth /* if this reset wasn't generated by CAS, we should reset our 13426787d27bSMichael Roth * negotiated options and start from scratch */ 13436787d27bSMichael Roth if (!spapr->cas_reboot) { 13446787d27bSMichael Roth spapr_ovec_cleanup(spapr->ov5_cas); 13456787d27bSMichael Roth spapr->ov5_cas = spapr_ovec_new(); 13466787d27bSMichael Roth } 13476787d27bSMichael Roth 1348cae172abSDavid Gibson fdt = spapr_build_fdt(spapr, rtas_addr, spapr->rtas_size); 134953018216SPaolo Bonzini 13502cac78c1SDavid Gibson spapr_load_rtas(spapr, fdt, rtas_addr); 1351b7d1f77aSBenjamin Herrenschmidt 1352997b6cfcSDavid Gibson rc = fdt_pack(fdt); 1353997b6cfcSDavid Gibson 1354997b6cfcSDavid Gibson /* Should only fail if we've built a corrupted tree */ 1355997b6cfcSDavid Gibson assert(rc == 0); 1356997b6cfcSDavid Gibson 1357997b6cfcSDavid Gibson if (fdt_totalsize(fdt) > FDT_MAX_SIZE) { 1358997b6cfcSDavid Gibson error_report("FDT too big ! 0x%x bytes (max is 0x%x)", 1359997b6cfcSDavid Gibson fdt_totalsize(fdt), FDT_MAX_SIZE); 1360997b6cfcSDavid Gibson exit(1); 1361997b6cfcSDavid Gibson } 1362997b6cfcSDavid Gibson 1363997b6cfcSDavid Gibson /* Load the fdt */ 1364997b6cfcSDavid Gibson qemu_fdt_dumpdtb(fdt, fdt_totalsize(fdt)); 1365cae172abSDavid Gibson cpu_physical_memory_write(fdt_addr, fdt, fdt_totalsize(fdt)); 1366997b6cfcSDavid Gibson g_free(fdt); 1367997b6cfcSDavid Gibson 136853018216SPaolo Bonzini /* Set up the entry state */ 1369182735efSAndreas Färber first_ppc_cpu = POWERPC_CPU(first_cpu); 1370cae172abSDavid Gibson first_ppc_cpu->env.gpr[3] = fdt_addr; 1371182735efSAndreas Färber first_ppc_cpu->env.gpr[5] = 0; 1372182735efSAndreas Färber first_cpu->halted = 0; 13731b718907SDavid Gibson first_ppc_cpu->env.nip = SPAPR_ENTRY_POINT; 137453018216SPaolo Bonzini 13756787d27bSMichael Roth spapr->cas_reboot = false; 137653018216SPaolo Bonzini } 137753018216SPaolo Bonzini 137828e02042SDavid Gibson static void spapr_create_nvram(sPAPRMachineState *spapr) 137953018216SPaolo Bonzini { 13802ff3de68SMarkus Armbruster DeviceState *dev = qdev_create(&spapr->vio_bus->bus, "spapr-nvram"); 13813978b863SPaolo Bonzini DriveInfo *dinfo = drive_get(IF_PFLASH, 0, 0); 138253018216SPaolo Bonzini 13833978b863SPaolo Bonzini if (dinfo) { 13846231a6daSMarkus Armbruster qdev_prop_set_drive(dev, "drive", blk_by_legacy_dinfo(dinfo), 13856231a6daSMarkus Armbruster &error_fatal); 138653018216SPaolo Bonzini } 138753018216SPaolo Bonzini 138853018216SPaolo Bonzini qdev_init_nofail(dev); 138953018216SPaolo Bonzini 139053018216SPaolo Bonzini spapr->nvram = (struct sPAPRNVRAM *)dev; 139153018216SPaolo Bonzini } 139253018216SPaolo Bonzini 139328e02042SDavid Gibson static void spapr_rtc_create(sPAPRMachineState *spapr) 139428df36a1SDavid Gibson { 1395147ff807SCédric Le Goater object_initialize(&spapr->rtc, sizeof(spapr->rtc), TYPE_SPAPR_RTC); 1396147ff807SCédric Le Goater object_property_add_child(OBJECT(spapr), "rtc", OBJECT(&spapr->rtc), 1397147ff807SCédric Le Goater &error_fatal); 1398147ff807SCédric Le Goater object_property_set_bool(OBJECT(&spapr->rtc), true, "realized", 1399147ff807SCédric Le Goater &error_fatal); 1400147ff807SCédric Le Goater object_property_add_alias(OBJECT(spapr), "rtc-time", OBJECT(&spapr->rtc), 1401147ff807SCédric Le Goater "date", &error_fatal); 140228df36a1SDavid Gibson } 140328df36a1SDavid Gibson 140453018216SPaolo Bonzini /* Returns whether we want to use VGA or not */ 140514c6a894SDavid Gibson static bool spapr_vga_init(PCIBus *pci_bus, Error **errp) 140653018216SPaolo Bonzini { 140753018216SPaolo Bonzini switch (vga_interface_type) { 140853018216SPaolo Bonzini case VGA_NONE: 14097effdaa3SMark Wu return false; 14107effdaa3SMark Wu case VGA_DEVICE: 14117effdaa3SMark Wu return true; 141253018216SPaolo Bonzini case VGA_STD: 1413b798c190SBenjamin Herrenschmidt case VGA_VIRTIO: 141453018216SPaolo Bonzini return pci_vga_init(pci_bus) != NULL; 141553018216SPaolo Bonzini default: 141614c6a894SDavid Gibson error_setg(errp, 141714c6a894SDavid Gibson "Unsupported VGA mode, only -vga std or -vga virtio is supported"); 141814c6a894SDavid Gibson return false; 141953018216SPaolo Bonzini } 142053018216SPaolo Bonzini } 142153018216SPaolo Bonzini 1422880ae7deSDavid Gibson static int spapr_post_load(void *opaque, int version_id) 1423880ae7deSDavid Gibson { 142428e02042SDavid Gibson sPAPRMachineState *spapr = (sPAPRMachineState *)opaque; 1425880ae7deSDavid Gibson int err = 0; 1426880ae7deSDavid Gibson 1427a7ff1212SCédric Le Goater if (!object_dynamic_cast(OBJECT(spapr->ics), TYPE_ICS_KVM)) { 14285bc8d26dSCédric Le Goater CPUState *cs; 14295bc8d26dSCédric Le Goater CPU_FOREACH(cs) { 14305bc8d26dSCédric Le Goater PowerPCCPU *cpu = POWERPC_CPU(cs); 14315bc8d26dSCédric Le Goater icp_resend(ICP(cpu->intc)); 1432a7ff1212SCédric Le Goater } 1433a7ff1212SCédric Le Goater } 1434a7ff1212SCédric Le Goater 1435631b22eaSStefan Weil /* In earlier versions, there was no separate qdev for the PAPR 1436880ae7deSDavid Gibson * RTC, so the RTC offset was stored directly in sPAPREnvironment. 1437880ae7deSDavid Gibson * So when migrating from those versions, poke the incoming offset 1438880ae7deSDavid Gibson * value into the RTC device */ 1439880ae7deSDavid Gibson if (version_id < 3) { 1440147ff807SCédric Le Goater err = spapr_rtc_import_offset(&spapr->rtc, spapr->rtc_offset); 1441880ae7deSDavid Gibson } 1442880ae7deSDavid Gibson 1443880ae7deSDavid Gibson return err; 1444880ae7deSDavid Gibson } 1445880ae7deSDavid Gibson 1446880ae7deSDavid Gibson static bool version_before_3(void *opaque, int version_id) 1447880ae7deSDavid Gibson { 1448880ae7deSDavid Gibson return version_id < 3; 1449880ae7deSDavid Gibson } 1450880ae7deSDavid Gibson 145162ef3760SMichael Roth static bool spapr_ov5_cas_needed(void *opaque) 145262ef3760SMichael Roth { 145362ef3760SMichael Roth sPAPRMachineState *spapr = opaque; 145462ef3760SMichael Roth sPAPROptionVector *ov5_mask = spapr_ovec_new(); 145562ef3760SMichael Roth sPAPROptionVector *ov5_legacy = spapr_ovec_new(); 145662ef3760SMichael Roth sPAPROptionVector *ov5_removed = spapr_ovec_new(); 145762ef3760SMichael Roth bool cas_needed; 145862ef3760SMichael Roth 145962ef3760SMichael Roth /* Prior to the introduction of sPAPROptionVector, we had two option 146062ef3760SMichael Roth * vectors we dealt with: OV5_FORM1_AFFINITY, and OV5_DRCONF_MEMORY. 146162ef3760SMichael Roth * Both of these options encode machine topology into the device-tree 146262ef3760SMichael Roth * in such a way that the now-booted OS should still be able to interact 146362ef3760SMichael Roth * appropriately with QEMU regardless of what options were actually 146462ef3760SMichael Roth * negotiatied on the source side. 146562ef3760SMichael Roth * 146662ef3760SMichael Roth * As such, we can avoid migrating the CAS-negotiated options if these 146762ef3760SMichael Roth * are the only options available on the current machine/platform. 146862ef3760SMichael Roth * Since these are the only options available for pseries-2.7 and 146962ef3760SMichael Roth * earlier, this allows us to maintain old->new/new->old migration 147062ef3760SMichael Roth * compatibility. 147162ef3760SMichael Roth * 147262ef3760SMichael Roth * For QEMU 2.8+, there are additional CAS-negotiatable options available 147362ef3760SMichael Roth * via default pseries-2.8 machines and explicit command-line parameters. 147462ef3760SMichael Roth * Some of these options, like OV5_HP_EVT, *do* require QEMU to be aware 147562ef3760SMichael Roth * of the actual CAS-negotiated values to continue working properly. For 147662ef3760SMichael Roth * example, availability of memory unplug depends on knowing whether 147762ef3760SMichael Roth * OV5_HP_EVT was negotiated via CAS. 147862ef3760SMichael Roth * 147962ef3760SMichael Roth * Thus, for any cases where the set of available CAS-negotiatable 148062ef3760SMichael Roth * options extends beyond OV5_FORM1_AFFINITY and OV5_DRCONF_MEMORY, we 148162ef3760SMichael Roth * include the CAS-negotiated options in the migration stream. 148262ef3760SMichael Roth */ 148362ef3760SMichael Roth spapr_ovec_set(ov5_mask, OV5_FORM1_AFFINITY); 148462ef3760SMichael Roth spapr_ovec_set(ov5_mask, OV5_DRCONF_MEMORY); 148562ef3760SMichael Roth 148662ef3760SMichael Roth /* spapr_ovec_diff returns true if bits were removed. we avoid using 148762ef3760SMichael Roth * the mask itself since in the future it's possible "legacy" bits may be 148862ef3760SMichael Roth * removed via machine options, which could generate a false positive 148962ef3760SMichael Roth * that breaks migration. 149062ef3760SMichael Roth */ 149162ef3760SMichael Roth spapr_ovec_intersect(ov5_legacy, spapr->ov5, ov5_mask); 149262ef3760SMichael Roth cas_needed = spapr_ovec_diff(ov5_removed, spapr->ov5, ov5_legacy); 149362ef3760SMichael Roth 149462ef3760SMichael Roth spapr_ovec_cleanup(ov5_mask); 149562ef3760SMichael Roth spapr_ovec_cleanup(ov5_legacy); 149662ef3760SMichael Roth spapr_ovec_cleanup(ov5_removed); 149762ef3760SMichael Roth 149862ef3760SMichael Roth return cas_needed; 149962ef3760SMichael Roth } 150062ef3760SMichael Roth 150162ef3760SMichael Roth static const VMStateDescription vmstate_spapr_ov5_cas = { 150262ef3760SMichael Roth .name = "spapr_option_vector_ov5_cas", 150362ef3760SMichael Roth .version_id = 1, 150462ef3760SMichael Roth .minimum_version_id = 1, 150562ef3760SMichael Roth .needed = spapr_ov5_cas_needed, 150662ef3760SMichael Roth .fields = (VMStateField[]) { 150762ef3760SMichael Roth VMSTATE_STRUCT_POINTER_V(ov5_cas, sPAPRMachineState, 1, 150862ef3760SMichael Roth vmstate_spapr_ovec, sPAPROptionVector), 150962ef3760SMichael Roth VMSTATE_END_OF_LIST() 151062ef3760SMichael Roth }, 151162ef3760SMichael Roth }; 151262ef3760SMichael Roth 15139861bb3eSSuraj Jitindar Singh static bool spapr_patb_entry_needed(void *opaque) 15149861bb3eSSuraj Jitindar Singh { 15159861bb3eSSuraj Jitindar Singh sPAPRMachineState *spapr = opaque; 15169861bb3eSSuraj Jitindar Singh 15179861bb3eSSuraj Jitindar Singh return !!spapr->patb_entry; 15189861bb3eSSuraj Jitindar Singh } 15199861bb3eSSuraj Jitindar Singh 15209861bb3eSSuraj Jitindar Singh static const VMStateDescription vmstate_spapr_patb_entry = { 15219861bb3eSSuraj Jitindar Singh .name = "spapr_patb_entry", 15229861bb3eSSuraj Jitindar Singh .version_id = 1, 15239861bb3eSSuraj Jitindar Singh .minimum_version_id = 1, 15249861bb3eSSuraj Jitindar Singh .needed = spapr_patb_entry_needed, 15259861bb3eSSuraj Jitindar Singh .fields = (VMStateField[]) { 15269861bb3eSSuraj Jitindar Singh VMSTATE_UINT64(patb_entry, sPAPRMachineState), 15279861bb3eSSuraj Jitindar Singh VMSTATE_END_OF_LIST() 15289861bb3eSSuraj Jitindar Singh }, 15299861bb3eSSuraj Jitindar Singh }; 15309861bb3eSSuraj Jitindar Singh 15314be21d56SDavid Gibson static const VMStateDescription vmstate_spapr = { 15324be21d56SDavid Gibson .name = "spapr", 1533880ae7deSDavid Gibson .version_id = 3, 15344be21d56SDavid Gibson .minimum_version_id = 1, 1535880ae7deSDavid Gibson .post_load = spapr_post_load, 15364be21d56SDavid Gibson .fields = (VMStateField[]) { 1537880ae7deSDavid Gibson /* used to be @next_irq */ 1538880ae7deSDavid Gibson VMSTATE_UNUSED_BUFFER(version_before_3, 0, 4), 15394be21d56SDavid Gibson 15404be21d56SDavid Gibson /* RTC offset */ 154128e02042SDavid Gibson VMSTATE_UINT64_TEST(rtc_offset, sPAPRMachineState, version_before_3), 1542880ae7deSDavid Gibson 154328e02042SDavid Gibson VMSTATE_PPC_TIMEBASE_V(tb, sPAPRMachineState, 2), 15444be21d56SDavid Gibson VMSTATE_END_OF_LIST() 15454be21d56SDavid Gibson }, 154662ef3760SMichael Roth .subsections = (const VMStateDescription*[]) { 154762ef3760SMichael Roth &vmstate_spapr_ov5_cas, 15489861bb3eSSuraj Jitindar Singh &vmstate_spapr_patb_entry, 154962ef3760SMichael Roth NULL 155062ef3760SMichael Roth } 15514be21d56SDavid Gibson }; 15524be21d56SDavid Gibson 15534be21d56SDavid Gibson static int htab_save_setup(QEMUFile *f, void *opaque) 15544be21d56SDavid Gibson { 155528e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 15564be21d56SDavid Gibson 15574be21d56SDavid Gibson /* "Iteration" header */ 15584be21d56SDavid Gibson qemu_put_be32(f, spapr->htab_shift); 15594be21d56SDavid Gibson 1560e68cb8b4SAlexey Kardashevskiy if (spapr->htab) { 1561e68cb8b4SAlexey Kardashevskiy spapr->htab_save_index = 0; 1562e68cb8b4SAlexey Kardashevskiy spapr->htab_first_pass = true; 1563e68cb8b4SAlexey Kardashevskiy } else { 1564e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 15654be21d56SDavid Gibson } 15664be21d56SDavid Gibson 1567e68cb8b4SAlexey Kardashevskiy 1568e68cb8b4SAlexey Kardashevskiy return 0; 1569e68cb8b4SAlexey Kardashevskiy } 15704be21d56SDavid Gibson 157128e02042SDavid Gibson static void htab_save_first_pass(QEMUFile *f, sPAPRMachineState *spapr, 15724be21d56SDavid Gibson int64_t max_ns) 15734be21d56SDavid Gibson { 1574378bc217SDavid Gibson bool has_timeout = max_ns != -1; 15754be21d56SDavid Gibson int htabslots = HTAB_SIZE(spapr) / HASH_PTE_SIZE_64; 15764be21d56SDavid Gibson int index = spapr->htab_save_index; 1577bc72ad67SAlex Bligh int64_t starttime = qemu_clock_get_ns(QEMU_CLOCK_REALTIME); 15784be21d56SDavid Gibson 15794be21d56SDavid Gibson assert(spapr->htab_first_pass); 15804be21d56SDavid Gibson 15814be21d56SDavid Gibson do { 15824be21d56SDavid Gibson int chunkstart; 15834be21d56SDavid Gibson 15844be21d56SDavid Gibson /* Consume invalid HPTEs */ 15854be21d56SDavid Gibson while ((index < htabslots) 15864be21d56SDavid Gibson && !HPTE_VALID(HPTE(spapr->htab, index))) { 15874be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 158824ec2863SMarc-André Lureau index++; 15894be21d56SDavid Gibson } 15904be21d56SDavid Gibson 15914be21d56SDavid Gibson /* Consume valid HPTEs */ 15924be21d56SDavid Gibson chunkstart = index; 1593338c25b6SSamuel Mendoza-Jonas while ((index < htabslots) && (index - chunkstart < USHRT_MAX) 15944be21d56SDavid Gibson && HPTE_VALID(HPTE(spapr->htab, index))) { 15954be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 159624ec2863SMarc-André Lureau index++; 15974be21d56SDavid Gibson } 15984be21d56SDavid Gibson 15994be21d56SDavid Gibson if (index > chunkstart) { 16004be21d56SDavid Gibson int n_valid = index - chunkstart; 16014be21d56SDavid Gibson 16024be21d56SDavid Gibson qemu_put_be32(f, chunkstart); 16034be21d56SDavid Gibson qemu_put_be16(f, n_valid); 16044be21d56SDavid Gibson qemu_put_be16(f, 0); 16054be21d56SDavid Gibson qemu_put_buffer(f, HPTE(spapr->htab, chunkstart), 16064be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_valid); 16074be21d56SDavid Gibson 1608378bc217SDavid Gibson if (has_timeout && 1609378bc217SDavid Gibson (qemu_clock_get_ns(QEMU_CLOCK_REALTIME) - starttime) > max_ns) { 16104be21d56SDavid Gibson break; 16114be21d56SDavid Gibson } 16124be21d56SDavid Gibson } 16134be21d56SDavid Gibson } while ((index < htabslots) && !qemu_file_rate_limit(f)); 16144be21d56SDavid Gibson 16154be21d56SDavid Gibson if (index >= htabslots) { 16164be21d56SDavid Gibson assert(index == htabslots); 16174be21d56SDavid Gibson index = 0; 16184be21d56SDavid Gibson spapr->htab_first_pass = false; 16194be21d56SDavid Gibson } 16204be21d56SDavid Gibson spapr->htab_save_index = index; 16214be21d56SDavid Gibson } 16224be21d56SDavid Gibson 162328e02042SDavid Gibson static int htab_save_later_pass(QEMUFile *f, sPAPRMachineState *spapr, 16244be21d56SDavid Gibson int64_t max_ns) 16254be21d56SDavid Gibson { 16264be21d56SDavid Gibson bool final = max_ns < 0; 16274be21d56SDavid Gibson int htabslots = HTAB_SIZE(spapr) / HASH_PTE_SIZE_64; 16284be21d56SDavid Gibson int examined = 0, sent = 0; 16294be21d56SDavid Gibson int index = spapr->htab_save_index; 1630bc72ad67SAlex Bligh int64_t starttime = qemu_clock_get_ns(QEMU_CLOCK_REALTIME); 16314be21d56SDavid Gibson 16324be21d56SDavid Gibson assert(!spapr->htab_first_pass); 16334be21d56SDavid Gibson 16344be21d56SDavid Gibson do { 16354be21d56SDavid Gibson int chunkstart, invalidstart; 16364be21d56SDavid Gibson 16374be21d56SDavid Gibson /* Consume non-dirty HPTEs */ 16384be21d56SDavid Gibson while ((index < htabslots) 16394be21d56SDavid Gibson && !HPTE_DIRTY(HPTE(spapr->htab, index))) { 16404be21d56SDavid Gibson index++; 16414be21d56SDavid Gibson examined++; 16424be21d56SDavid Gibson } 16434be21d56SDavid Gibson 16444be21d56SDavid Gibson chunkstart = index; 16454be21d56SDavid Gibson /* Consume valid dirty HPTEs */ 1646338c25b6SSamuel Mendoza-Jonas while ((index < htabslots) && (index - chunkstart < USHRT_MAX) 16474be21d56SDavid Gibson && HPTE_DIRTY(HPTE(spapr->htab, index)) 16484be21d56SDavid Gibson && HPTE_VALID(HPTE(spapr->htab, index))) { 16494be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 16504be21d56SDavid Gibson index++; 16514be21d56SDavid Gibson examined++; 16524be21d56SDavid Gibson } 16534be21d56SDavid Gibson 16544be21d56SDavid Gibson invalidstart = index; 16554be21d56SDavid Gibson /* Consume invalid dirty HPTEs */ 1656338c25b6SSamuel Mendoza-Jonas while ((index < htabslots) && (index - invalidstart < USHRT_MAX) 16574be21d56SDavid Gibson && HPTE_DIRTY(HPTE(spapr->htab, index)) 16584be21d56SDavid Gibson && !HPTE_VALID(HPTE(spapr->htab, index))) { 16594be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 16604be21d56SDavid Gibson index++; 16614be21d56SDavid Gibson examined++; 16624be21d56SDavid Gibson } 16634be21d56SDavid Gibson 16644be21d56SDavid Gibson if (index > chunkstart) { 16654be21d56SDavid Gibson int n_valid = invalidstart - chunkstart; 16664be21d56SDavid Gibson int n_invalid = index - invalidstart; 16674be21d56SDavid Gibson 16684be21d56SDavid Gibson qemu_put_be32(f, chunkstart); 16694be21d56SDavid Gibson qemu_put_be16(f, n_valid); 16704be21d56SDavid Gibson qemu_put_be16(f, n_invalid); 16714be21d56SDavid Gibson qemu_put_buffer(f, HPTE(spapr->htab, chunkstart), 16724be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_valid); 16734be21d56SDavid Gibson sent += index - chunkstart; 16744be21d56SDavid Gibson 1675bc72ad67SAlex Bligh if (!final && (qemu_clock_get_ns(QEMU_CLOCK_REALTIME) - starttime) > max_ns) { 16764be21d56SDavid Gibson break; 16774be21d56SDavid Gibson } 16784be21d56SDavid Gibson } 16794be21d56SDavid Gibson 16804be21d56SDavid Gibson if (examined >= htabslots) { 16814be21d56SDavid Gibson break; 16824be21d56SDavid Gibson } 16834be21d56SDavid Gibson 16844be21d56SDavid Gibson if (index >= htabslots) { 16854be21d56SDavid Gibson assert(index == htabslots); 16864be21d56SDavid Gibson index = 0; 16874be21d56SDavid Gibson } 16884be21d56SDavid Gibson } while ((examined < htabslots) && (!qemu_file_rate_limit(f) || final)); 16894be21d56SDavid Gibson 16904be21d56SDavid Gibson if (index >= htabslots) { 16914be21d56SDavid Gibson assert(index == htabslots); 16924be21d56SDavid Gibson index = 0; 16934be21d56SDavid Gibson } 16944be21d56SDavid Gibson 16954be21d56SDavid Gibson spapr->htab_save_index = index; 16964be21d56SDavid Gibson 1697e68cb8b4SAlexey Kardashevskiy return (examined >= htabslots) && (sent == 0) ? 1 : 0; 16984be21d56SDavid Gibson } 16994be21d56SDavid Gibson 1700e68cb8b4SAlexey Kardashevskiy #define MAX_ITERATION_NS 5000000 /* 5 ms */ 1701e68cb8b4SAlexey Kardashevskiy #define MAX_KVM_BUF_SIZE 2048 1702e68cb8b4SAlexey Kardashevskiy 17034be21d56SDavid Gibson static int htab_save_iterate(QEMUFile *f, void *opaque) 17044be21d56SDavid Gibson { 170528e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 1706715c5407SDavid Gibson int fd; 1707e68cb8b4SAlexey Kardashevskiy int rc = 0; 17084be21d56SDavid Gibson 17094be21d56SDavid Gibson /* Iteration header */ 17104be21d56SDavid Gibson qemu_put_be32(f, 0); 17114be21d56SDavid Gibson 1712e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1713e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 1714e68cb8b4SAlexey Kardashevskiy 1715715c5407SDavid Gibson fd = get_htab_fd(spapr); 1716715c5407SDavid Gibson if (fd < 0) { 1717715c5407SDavid Gibson return fd; 171801a57972SSamuel Mendoza-Jonas } 171901a57972SSamuel Mendoza-Jonas 1720715c5407SDavid Gibson rc = kvmppc_save_htab(f, fd, MAX_KVM_BUF_SIZE, MAX_ITERATION_NS); 1721e68cb8b4SAlexey Kardashevskiy if (rc < 0) { 1722e68cb8b4SAlexey Kardashevskiy return rc; 1723e68cb8b4SAlexey Kardashevskiy } 1724e68cb8b4SAlexey Kardashevskiy } else if (spapr->htab_first_pass) { 17254be21d56SDavid Gibson htab_save_first_pass(f, spapr, MAX_ITERATION_NS); 17264be21d56SDavid Gibson } else { 1727e68cb8b4SAlexey Kardashevskiy rc = htab_save_later_pass(f, spapr, MAX_ITERATION_NS); 17284be21d56SDavid Gibson } 17294be21d56SDavid Gibson 17304be21d56SDavid Gibson /* End marker */ 17314be21d56SDavid Gibson qemu_put_be32(f, 0); 17324be21d56SDavid Gibson qemu_put_be16(f, 0); 17334be21d56SDavid Gibson qemu_put_be16(f, 0); 17344be21d56SDavid Gibson 1735e68cb8b4SAlexey Kardashevskiy return rc; 17364be21d56SDavid Gibson } 17374be21d56SDavid Gibson 17384be21d56SDavid Gibson static int htab_save_complete(QEMUFile *f, void *opaque) 17394be21d56SDavid Gibson { 174028e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 1741715c5407SDavid Gibson int fd; 17424be21d56SDavid Gibson 17434be21d56SDavid Gibson /* Iteration header */ 17444be21d56SDavid Gibson qemu_put_be32(f, 0); 17454be21d56SDavid Gibson 1746e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1747e68cb8b4SAlexey Kardashevskiy int rc; 1748e68cb8b4SAlexey Kardashevskiy 1749e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 1750e68cb8b4SAlexey Kardashevskiy 1751715c5407SDavid Gibson fd = get_htab_fd(spapr); 1752715c5407SDavid Gibson if (fd < 0) { 1753715c5407SDavid Gibson return fd; 175401a57972SSamuel Mendoza-Jonas } 175501a57972SSamuel Mendoza-Jonas 1756715c5407SDavid Gibson rc = kvmppc_save_htab(f, fd, MAX_KVM_BUF_SIZE, -1); 1757e68cb8b4SAlexey Kardashevskiy if (rc < 0) { 1758e68cb8b4SAlexey Kardashevskiy return rc; 1759e68cb8b4SAlexey Kardashevskiy } 1760e68cb8b4SAlexey Kardashevskiy } else { 1761378bc217SDavid Gibson if (spapr->htab_first_pass) { 1762378bc217SDavid Gibson htab_save_first_pass(f, spapr, -1); 1763378bc217SDavid Gibson } 17644be21d56SDavid Gibson htab_save_later_pass(f, spapr, -1); 1765e68cb8b4SAlexey Kardashevskiy } 17664be21d56SDavid Gibson 17674be21d56SDavid Gibson /* End marker */ 17684be21d56SDavid Gibson qemu_put_be32(f, 0); 17694be21d56SDavid Gibson qemu_put_be16(f, 0); 17704be21d56SDavid Gibson qemu_put_be16(f, 0); 17714be21d56SDavid Gibson 17724be21d56SDavid Gibson return 0; 17734be21d56SDavid Gibson } 17744be21d56SDavid Gibson 17754be21d56SDavid Gibson static int htab_load(QEMUFile *f, void *opaque, int version_id) 17764be21d56SDavid Gibson { 177728e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 17784be21d56SDavid Gibson uint32_t section_hdr; 1779e68cb8b4SAlexey Kardashevskiy int fd = -1; 17804be21d56SDavid Gibson 17814be21d56SDavid Gibson if (version_id < 1 || version_id > 1) { 178298a5d100SDavid Gibson error_report("htab_load() bad version"); 17834be21d56SDavid Gibson return -EINVAL; 17844be21d56SDavid Gibson } 17854be21d56SDavid Gibson 17864be21d56SDavid Gibson section_hdr = qemu_get_be32(f); 17874be21d56SDavid Gibson 17884be21d56SDavid Gibson if (section_hdr) { 17899897e462SGreg Kurz Error *local_err = NULL; 1790c5f54f3eSDavid Gibson 1791c5f54f3eSDavid Gibson /* First section gives the htab size */ 1792c5f54f3eSDavid Gibson spapr_reallocate_hpt(spapr, section_hdr, &local_err); 1793c5f54f3eSDavid Gibson if (local_err) { 1794c5f54f3eSDavid Gibson error_report_err(local_err); 17954be21d56SDavid Gibson return -EINVAL; 17964be21d56SDavid Gibson } 17974be21d56SDavid Gibson return 0; 17984be21d56SDavid Gibson } 17994be21d56SDavid Gibson 1800e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1801e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 1802e68cb8b4SAlexey Kardashevskiy 1803e68cb8b4SAlexey Kardashevskiy fd = kvmppc_get_htab_fd(true); 1804e68cb8b4SAlexey Kardashevskiy if (fd < 0) { 180598a5d100SDavid Gibson error_report("Unable to open fd to restore KVM hash table: %s", 1806e68cb8b4SAlexey Kardashevskiy strerror(errno)); 1807e68cb8b4SAlexey Kardashevskiy } 1808e68cb8b4SAlexey Kardashevskiy } 1809e68cb8b4SAlexey Kardashevskiy 18104be21d56SDavid Gibson while (true) { 18114be21d56SDavid Gibson uint32_t index; 18124be21d56SDavid Gibson uint16_t n_valid, n_invalid; 18134be21d56SDavid Gibson 18144be21d56SDavid Gibson index = qemu_get_be32(f); 18154be21d56SDavid Gibson n_valid = qemu_get_be16(f); 18164be21d56SDavid Gibson n_invalid = qemu_get_be16(f); 18174be21d56SDavid Gibson 18184be21d56SDavid Gibson if ((index == 0) && (n_valid == 0) && (n_invalid == 0)) { 18194be21d56SDavid Gibson /* End of Stream */ 18204be21d56SDavid Gibson break; 18214be21d56SDavid Gibson } 18224be21d56SDavid Gibson 1823e68cb8b4SAlexey Kardashevskiy if ((index + n_valid + n_invalid) > 18244be21d56SDavid Gibson (HTAB_SIZE(spapr) / HASH_PTE_SIZE_64)) { 18254be21d56SDavid Gibson /* Bad index in stream */ 182698a5d100SDavid Gibson error_report( 182798a5d100SDavid Gibson "htab_load() bad index %d (%hd+%hd entries) in htab stream (htab_shift=%d)", 182898a5d100SDavid Gibson index, n_valid, n_invalid, spapr->htab_shift); 18294be21d56SDavid Gibson return -EINVAL; 18304be21d56SDavid Gibson } 18314be21d56SDavid Gibson 1832e68cb8b4SAlexey Kardashevskiy if (spapr->htab) { 18334be21d56SDavid Gibson if (n_valid) { 18344be21d56SDavid Gibson qemu_get_buffer(f, HPTE(spapr->htab, index), 18354be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_valid); 18364be21d56SDavid Gibson } 18374be21d56SDavid Gibson if (n_invalid) { 18384be21d56SDavid Gibson memset(HPTE(spapr->htab, index + n_valid), 0, 18394be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_invalid); 18404be21d56SDavid Gibson } 1841e68cb8b4SAlexey Kardashevskiy } else { 1842e68cb8b4SAlexey Kardashevskiy int rc; 1843e68cb8b4SAlexey Kardashevskiy 1844e68cb8b4SAlexey Kardashevskiy assert(fd >= 0); 1845e68cb8b4SAlexey Kardashevskiy 1846e68cb8b4SAlexey Kardashevskiy rc = kvmppc_load_htab_chunk(f, fd, index, n_valid, n_invalid); 1847e68cb8b4SAlexey Kardashevskiy if (rc < 0) { 1848e68cb8b4SAlexey Kardashevskiy return rc; 1849e68cb8b4SAlexey Kardashevskiy } 1850e68cb8b4SAlexey Kardashevskiy } 1851e68cb8b4SAlexey Kardashevskiy } 1852e68cb8b4SAlexey Kardashevskiy 1853e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1854e68cb8b4SAlexey Kardashevskiy assert(fd >= 0); 1855e68cb8b4SAlexey Kardashevskiy close(fd); 18564be21d56SDavid Gibson } 18574be21d56SDavid Gibson 18584be21d56SDavid Gibson return 0; 18594be21d56SDavid Gibson } 18604be21d56SDavid Gibson 1861c573fc03SThomas Huth static void htab_cleanup(void *opaque) 1862c573fc03SThomas Huth { 1863c573fc03SThomas Huth sPAPRMachineState *spapr = opaque; 1864c573fc03SThomas Huth 1865c573fc03SThomas Huth close_htab_fd(spapr); 1866c573fc03SThomas Huth } 1867c573fc03SThomas Huth 18684be21d56SDavid Gibson static SaveVMHandlers savevm_htab_handlers = { 18694be21d56SDavid Gibson .save_live_setup = htab_save_setup, 18704be21d56SDavid Gibson .save_live_iterate = htab_save_iterate, 1871a3e06c3dSDr. David Alan Gilbert .save_live_complete_precopy = htab_save_complete, 1872c573fc03SThomas Huth .cleanup = htab_cleanup, 18734be21d56SDavid Gibson .load_state = htab_load, 18744be21d56SDavid Gibson }; 18754be21d56SDavid Gibson 18765b2128d2SAlexander Graf static void spapr_boot_set(void *opaque, const char *boot_device, 18775b2128d2SAlexander Graf Error **errp) 18785b2128d2SAlexander Graf { 18795b2128d2SAlexander Graf MachineState *machine = MACHINE(qdev_get_machine()); 18805b2128d2SAlexander Graf machine->boot_order = g_strdup(boot_device); 18815b2128d2SAlexander Graf } 18825b2128d2SAlexander Graf 1883224245bfSDavid Gibson /* 1884224245bfSDavid Gibson * Reset routine for LMB DR devices. 1885224245bfSDavid Gibson * 1886224245bfSDavid Gibson * Unlike PCI DR devices, LMB DR devices explicitly register this reset 1887224245bfSDavid Gibson * routine. Reset for PCI DR devices will be handled by PHB reset routine 1888224245bfSDavid Gibson * when it walks all its children devices. LMB devices reset occurs 1889224245bfSDavid Gibson * as part of spapr_ppc_reset(). 1890224245bfSDavid Gibson */ 1891224245bfSDavid Gibson static void spapr_drc_reset(void *opaque) 1892224245bfSDavid Gibson { 1893224245bfSDavid Gibson sPAPRDRConnector *drc = opaque; 1894224245bfSDavid Gibson DeviceState *d = DEVICE(drc); 1895224245bfSDavid Gibson 1896224245bfSDavid Gibson if (d) { 1897224245bfSDavid Gibson device_reset(d); 1898224245bfSDavid Gibson } 1899224245bfSDavid Gibson } 1900224245bfSDavid Gibson 1901224245bfSDavid Gibson static void spapr_create_lmb_dr_connectors(sPAPRMachineState *spapr) 1902224245bfSDavid Gibson { 1903224245bfSDavid Gibson MachineState *machine = MACHINE(spapr); 1904224245bfSDavid Gibson uint64_t lmb_size = SPAPR_MEMORY_BLOCK_SIZE; 1905e8f986fcSBharata B Rao uint32_t nr_lmbs = (machine->maxram_size - machine->ram_size)/lmb_size; 1906224245bfSDavid Gibson int i; 1907224245bfSDavid Gibson 1908224245bfSDavid Gibson for (i = 0; i < nr_lmbs; i++) { 1909224245bfSDavid Gibson sPAPRDRConnector *drc; 1910224245bfSDavid Gibson uint64_t addr; 1911224245bfSDavid Gibson 1912e8f986fcSBharata B Rao addr = i * lmb_size + spapr->hotplug_memory.base; 19132d335818SDavid Gibson drc = spapr_dr_connector_new(OBJECT(spapr), TYPE_SPAPR_DRC_LMB, 1914224245bfSDavid Gibson addr/lmb_size); 1915224245bfSDavid Gibson qemu_register_reset(spapr_drc_reset, drc); 1916224245bfSDavid Gibson } 1917224245bfSDavid Gibson } 1918224245bfSDavid Gibson 1919224245bfSDavid Gibson /* 1920224245bfSDavid Gibson * If RAM size, maxmem size and individual node mem sizes aren't aligned 1921224245bfSDavid Gibson * to SPAPR_MEMORY_BLOCK_SIZE(256MB), then refuse to start the guest 1922224245bfSDavid Gibson * since we can't support such unaligned sizes with DRCONF_MEMORY. 1923224245bfSDavid Gibson */ 19247c150d6fSDavid Gibson static void spapr_validate_node_memory(MachineState *machine, Error **errp) 1925224245bfSDavid Gibson { 1926224245bfSDavid Gibson int i; 1927224245bfSDavid Gibson 19287c150d6fSDavid Gibson if (machine->ram_size % SPAPR_MEMORY_BLOCK_SIZE) { 19297c150d6fSDavid Gibson error_setg(errp, "Memory size 0x" RAM_ADDR_FMT 19307c150d6fSDavid Gibson " is not aligned to %llu MiB", 19317c150d6fSDavid Gibson machine->ram_size, 1932224245bfSDavid Gibson SPAPR_MEMORY_BLOCK_SIZE / M_BYTE); 19337c150d6fSDavid Gibson return; 19347c150d6fSDavid Gibson } 19357c150d6fSDavid Gibson 19367c150d6fSDavid Gibson if (machine->maxram_size % SPAPR_MEMORY_BLOCK_SIZE) { 19377c150d6fSDavid Gibson error_setg(errp, "Maximum memory size 0x" RAM_ADDR_FMT 19387c150d6fSDavid Gibson " is not aligned to %llu MiB", 19397c150d6fSDavid Gibson machine->ram_size, 19407c150d6fSDavid Gibson SPAPR_MEMORY_BLOCK_SIZE / M_BYTE); 19417c150d6fSDavid Gibson return; 1942224245bfSDavid Gibson } 1943224245bfSDavid Gibson 1944224245bfSDavid Gibson for (i = 0; i < nb_numa_nodes; i++) { 1945224245bfSDavid Gibson if (numa_info[i].node_mem % SPAPR_MEMORY_BLOCK_SIZE) { 19467c150d6fSDavid Gibson error_setg(errp, 19477c150d6fSDavid Gibson "Node %d memory size 0x%" PRIx64 19487c150d6fSDavid Gibson " is not aligned to %llu MiB", 19497c150d6fSDavid Gibson i, numa_info[i].node_mem, 1950224245bfSDavid Gibson SPAPR_MEMORY_BLOCK_SIZE / M_BYTE); 19517c150d6fSDavid Gibson return; 1952224245bfSDavid Gibson } 1953224245bfSDavid Gibson } 1954224245bfSDavid Gibson } 1955224245bfSDavid Gibson 1956535455fdSIgor Mammedov /* find cpu slot in machine->possible_cpus by core_id */ 1957535455fdSIgor Mammedov static CPUArchId *spapr_find_cpu_slot(MachineState *ms, uint32_t id, int *idx) 1958535455fdSIgor Mammedov { 1959535455fdSIgor Mammedov int index = id / smp_threads; 1960535455fdSIgor Mammedov 1961535455fdSIgor Mammedov if (index >= ms->possible_cpus->len) { 1962535455fdSIgor Mammedov return NULL; 1963535455fdSIgor Mammedov } 1964535455fdSIgor Mammedov if (idx) { 1965535455fdSIgor Mammedov *idx = index; 1966535455fdSIgor Mammedov } 1967535455fdSIgor Mammedov return &ms->possible_cpus->cpus[index]; 1968535455fdSIgor Mammedov } 1969535455fdSIgor Mammedov 19700c86d0fdSDavid Gibson static void spapr_init_cpus(sPAPRMachineState *spapr) 19710c86d0fdSDavid Gibson { 19720c86d0fdSDavid Gibson MachineState *machine = MACHINE(spapr); 19730c86d0fdSDavid Gibson MachineClass *mc = MACHINE_GET_CLASS(machine); 19740c86d0fdSDavid Gibson char *type = spapr_get_cpu_core_type(machine->cpu_model); 19750c86d0fdSDavid Gibson int smt = kvmppc_smt_threads(); 1976535455fdSIgor Mammedov const CPUArchIdList *possible_cpus; 1977535455fdSIgor Mammedov int boot_cores_nr = smp_cpus / smp_threads; 19780c86d0fdSDavid Gibson int i; 19790c86d0fdSDavid Gibson 19800c86d0fdSDavid Gibson if (!type) { 19810c86d0fdSDavid Gibson error_report("Unable to find sPAPR CPU Core definition"); 19820c86d0fdSDavid Gibson exit(1); 19830c86d0fdSDavid Gibson } 19840c86d0fdSDavid Gibson 1985535455fdSIgor Mammedov possible_cpus = mc->possible_cpu_arch_ids(machine); 1986c5514d0eSIgor Mammedov if (mc->has_hotpluggable_cpus) { 19870c86d0fdSDavid Gibson if (smp_cpus % smp_threads) { 19880c86d0fdSDavid Gibson error_report("smp_cpus (%u) must be multiple of threads (%u)", 19890c86d0fdSDavid Gibson smp_cpus, smp_threads); 19900c86d0fdSDavid Gibson exit(1); 19910c86d0fdSDavid Gibson } 19920c86d0fdSDavid Gibson if (max_cpus % smp_threads) { 19930c86d0fdSDavid Gibson error_report("max_cpus (%u) must be multiple of threads (%u)", 19940c86d0fdSDavid Gibson max_cpus, smp_threads); 19950c86d0fdSDavid Gibson exit(1); 19960c86d0fdSDavid Gibson } 19970c86d0fdSDavid Gibson } else { 19980c86d0fdSDavid Gibson if (max_cpus != smp_cpus) { 19990c86d0fdSDavid Gibson error_report("This machine version does not support CPU hotplug"); 20000c86d0fdSDavid Gibson exit(1); 20010c86d0fdSDavid Gibson } 2002535455fdSIgor Mammedov boot_cores_nr = possible_cpus->len; 20030c86d0fdSDavid Gibson } 20040c86d0fdSDavid Gibson 2005535455fdSIgor Mammedov for (i = 0; i < possible_cpus->len; i++) { 20060c86d0fdSDavid Gibson int core_id = i * smp_threads; 20070c86d0fdSDavid Gibson 2008c5514d0eSIgor Mammedov if (mc->has_hotpluggable_cpus) { 20090c86d0fdSDavid Gibson sPAPRDRConnector *drc = 20102d335818SDavid Gibson spapr_dr_connector_new(OBJECT(spapr), TYPE_SPAPR_DRC_CPU, 20110c86d0fdSDavid Gibson (core_id / smp_threads) * smt); 20120c86d0fdSDavid Gibson 20130c86d0fdSDavid Gibson qemu_register_reset(spapr_drc_reset, drc); 20140c86d0fdSDavid Gibson } 20150c86d0fdSDavid Gibson 2016535455fdSIgor Mammedov if (i < boot_cores_nr) { 20170c86d0fdSDavid Gibson Object *core = object_new(type); 20180c86d0fdSDavid Gibson int nr_threads = smp_threads; 20190c86d0fdSDavid Gibson 20200c86d0fdSDavid Gibson /* Handle the partially filled core for older machine types */ 20210c86d0fdSDavid Gibson if ((i + 1) * smp_threads >= smp_cpus) { 20220c86d0fdSDavid Gibson nr_threads = smp_cpus - i * smp_threads; 20230c86d0fdSDavid Gibson } 20240c86d0fdSDavid Gibson 20250c86d0fdSDavid Gibson object_property_set_int(core, nr_threads, "nr-threads", 20260c86d0fdSDavid Gibson &error_fatal); 20270c86d0fdSDavid Gibson object_property_set_int(core, core_id, CPU_CORE_PROP_CORE_ID, 20280c86d0fdSDavid Gibson &error_fatal); 20290c86d0fdSDavid Gibson object_property_set_bool(core, true, "realized", &error_fatal); 20300c86d0fdSDavid Gibson } 20310c86d0fdSDavid Gibson } 20320c86d0fdSDavid Gibson g_free(type); 20330c86d0fdSDavid Gibson } 20340c86d0fdSDavid Gibson 203553018216SPaolo Bonzini /* pSeries LPAR / sPAPR hardware init */ 20363ef96221SMarcel Apfelbaum static void ppc_spapr_init(MachineState *machine) 203753018216SPaolo Bonzini { 203828e02042SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(machine); 2039224245bfSDavid Gibson sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(machine); 20403ef96221SMarcel Apfelbaum const char *kernel_filename = machine->kernel_filename; 20413ef96221SMarcel Apfelbaum const char *initrd_filename = machine->initrd_filename; 204253018216SPaolo Bonzini PCIHostState *phb; 204353018216SPaolo Bonzini int i; 204453018216SPaolo Bonzini MemoryRegion *sysmem = get_system_memory(); 204553018216SPaolo Bonzini MemoryRegion *ram = g_new(MemoryRegion, 1); 2046658fa66bSAlexey Kardashevskiy MemoryRegion *rma_region; 2047658fa66bSAlexey Kardashevskiy void *rma = NULL; 204853018216SPaolo Bonzini hwaddr rma_alloc_size; 2049b082d65aSAlexey Kardashevskiy hwaddr node0_size = spapr_node0_size(); 2050b7d1f77aSBenjamin Herrenschmidt long load_limit, fw_size; 205153018216SPaolo Bonzini char *filename; 205253018216SPaolo Bonzini 2053226419d6SMichael S. Tsirkin msi_nonbroken = true; 205453018216SPaolo Bonzini 205553018216SPaolo Bonzini QLIST_INIT(&spapr->phbs); 20560cffce56SDavid Gibson QTAILQ_INIT(&spapr->pending_dimm_unplugs); 205753018216SPaolo Bonzini 205853018216SPaolo Bonzini /* Allocate RMA if necessary */ 2059658fa66bSAlexey Kardashevskiy rma_alloc_size = kvmppc_alloc_rma(&rma); 206053018216SPaolo Bonzini 206153018216SPaolo Bonzini if (rma_alloc_size == -1) { 2062730fce59SThomas Huth error_report("Unable to create RMA"); 206353018216SPaolo Bonzini exit(1); 206453018216SPaolo Bonzini } 206553018216SPaolo Bonzini 2066c4177479SAlexey Kardashevskiy if (rma_alloc_size && (rma_alloc_size < node0_size)) { 206753018216SPaolo Bonzini spapr->rma_size = rma_alloc_size; 206853018216SPaolo Bonzini } else { 2069c4177479SAlexey Kardashevskiy spapr->rma_size = node0_size; 207053018216SPaolo Bonzini 207153018216SPaolo Bonzini /* With KVM, we don't actually know whether KVM supports an 207253018216SPaolo Bonzini * unbounded RMA (PR KVM) or is limited by the hash table size 207353018216SPaolo Bonzini * (HV KVM using VRMA), so we always assume the latter 207453018216SPaolo Bonzini * 207553018216SPaolo Bonzini * In that case, we also limit the initial allocations for RTAS 207653018216SPaolo Bonzini * etc... to 256M since we have no way to know what the VRMA size 207753018216SPaolo Bonzini * is going to be as it depends on the size of the hash table 207853018216SPaolo Bonzini * isn't determined yet. 207953018216SPaolo Bonzini */ 208053018216SPaolo Bonzini if (kvm_enabled()) { 208153018216SPaolo Bonzini spapr->vrma_adjust = 1; 208253018216SPaolo Bonzini spapr->rma_size = MIN(spapr->rma_size, 0x10000000); 208353018216SPaolo Bonzini } 2084912acdf4SBenjamin Herrenschmidt 2085912acdf4SBenjamin Herrenschmidt /* Actually we don't support unbounded RMA anymore since we 2086912acdf4SBenjamin Herrenschmidt * added proper emulation of HV mode. The max we can get is 2087912acdf4SBenjamin Herrenschmidt * 16G which also happens to be what we configure for PAPR 2088912acdf4SBenjamin Herrenschmidt * mode so make sure we don't do anything bigger than that 2089912acdf4SBenjamin Herrenschmidt */ 2090912acdf4SBenjamin Herrenschmidt spapr->rma_size = MIN(spapr->rma_size, 0x400000000ull); 209153018216SPaolo Bonzini } 209253018216SPaolo Bonzini 2093c4177479SAlexey Kardashevskiy if (spapr->rma_size > node0_size) { 2094d54e4d76SDavid Gibson error_report("Numa node 0 has to span the RMA (%#08"HWADDR_PRIx")", 2095c4177479SAlexey Kardashevskiy spapr->rma_size); 2096c4177479SAlexey Kardashevskiy exit(1); 2097c4177479SAlexey Kardashevskiy } 2098c4177479SAlexey Kardashevskiy 2099b7d1f77aSBenjamin Herrenschmidt /* Setup a load limit for the ramdisk leaving room for SLOF and FDT */ 2100b7d1f77aSBenjamin Herrenschmidt load_limit = MIN(spapr->rma_size, RTAS_MAX_ADDR) - FW_OVERHEAD; 210153018216SPaolo Bonzini 21027b565160SDavid Gibson /* Set up Interrupt Controller before we create the VCPUs */ 210371cd4dacSCédric Le Goater xics_system_init(machine, XICS_IRQS_SPAPR, &error_fatal); 21047b565160SDavid Gibson 2105facdb8b6SMichael Roth /* Set up containers for ibm,client-set-architecture negotiated options */ 2106facdb8b6SMichael Roth spapr->ov5 = spapr_ovec_new(); 2107facdb8b6SMichael Roth spapr->ov5_cas = spapr_ovec_new(); 2108facdb8b6SMichael Roth 2109224245bfSDavid Gibson if (smc->dr_lmb_enabled) { 2110facdb8b6SMichael Roth spapr_ovec_set(spapr->ov5, OV5_DRCONF_MEMORY); 21117c150d6fSDavid Gibson spapr_validate_node_memory(machine, &error_fatal); 2112224245bfSDavid Gibson } 2113224245bfSDavid Gibson 2114417ece33SMichael Roth spapr_ovec_set(spapr->ov5, OV5_FORM1_AFFINITY); 2115545d6e2bSSuraj Jitindar Singh if (!kvm_enabled() || kvmppc_has_cap_mmu_radix()) { 2116545d6e2bSSuraj Jitindar Singh /* KVM and TCG always allow GTSE with radix... */ 21179fb4541fSSam Bobroff spapr_ovec_set(spapr->ov5, OV5_MMU_RADIX_GTSE); 21189fb4541fSSam Bobroff } 21199fb4541fSSam Bobroff /* ... but not with hash (currently). */ 2120417ece33SMichael Roth 2121ffbb1705SMichael Roth /* advertise support for dedicated HP event source to guests */ 2122ffbb1705SMichael Roth if (spapr->use_hotplug_event_source) { 2123ffbb1705SMichael Roth spapr_ovec_set(spapr->ov5, OV5_HP_EVT); 2124ffbb1705SMichael Roth } 2125ffbb1705SMichael Roth 212653018216SPaolo Bonzini /* init CPUs */ 212719fb2c36SBharata B Rao if (machine->cpu_model == NULL) { 21283daa4a9fSThomas Huth machine->cpu_model = kvm_enabled() ? "host" : smc->tcg_default_cpu; 212953018216SPaolo Bonzini } 213094a94e4cSBharata B Rao 2131e703d2f7SGreg Kurz ppc_cpu_parse_features(machine->cpu_model); 2132e703d2f7SGreg Kurz 21330c86d0fdSDavid Gibson spapr_init_cpus(spapr); 213453018216SPaolo Bonzini 2135026bfd89SDavid Gibson if (kvm_enabled()) { 2136026bfd89SDavid Gibson /* Enable H_LOGICAL_CI_* so SLOF can talk to in-kernel devices */ 2137026bfd89SDavid Gibson kvmppc_enable_logical_ci_hcalls(); 2138ef9971ddSAlexey Kardashevskiy kvmppc_enable_set_mode_hcall(); 21395145ad4fSNathan Whitehorn 21405145ad4fSNathan Whitehorn /* H_CLEAR_MOD/_REF are mandatory in PAPR, but off by default */ 21415145ad4fSNathan Whitehorn kvmppc_enable_clear_ref_mod_hcalls(); 2142026bfd89SDavid Gibson } 2143026bfd89SDavid Gibson 214453018216SPaolo Bonzini /* allocate RAM */ 2145f92f5da1SAlexey Kardashevskiy memory_region_allocate_system_memory(ram, NULL, "ppc_spapr.ram", 2146fb164994SDavid Gibson machine->ram_size); 2147f92f5da1SAlexey Kardashevskiy memory_region_add_subregion(sysmem, 0, ram); 214853018216SPaolo Bonzini 2149658fa66bSAlexey Kardashevskiy if (rma_alloc_size && rma) { 2150658fa66bSAlexey Kardashevskiy rma_region = g_new(MemoryRegion, 1); 2151658fa66bSAlexey Kardashevskiy memory_region_init_ram_ptr(rma_region, NULL, "ppc_spapr.rma", 2152658fa66bSAlexey Kardashevskiy rma_alloc_size, rma); 2153658fa66bSAlexey Kardashevskiy vmstate_register_ram_global(rma_region); 2154658fa66bSAlexey Kardashevskiy memory_region_add_subregion(sysmem, 0, rma_region); 2155658fa66bSAlexey Kardashevskiy } 2156658fa66bSAlexey Kardashevskiy 21574a1c9cf0SBharata B Rao /* initialize hotplug memory address space */ 21584a1c9cf0SBharata B Rao if (machine->ram_size < machine->maxram_size) { 21594a1c9cf0SBharata B Rao ram_addr_t hotplug_mem_size = machine->maxram_size - machine->ram_size; 216071c9a3ddSBharata B Rao /* 216171c9a3ddSBharata B Rao * Limit the number of hotpluggable memory slots to half the number 216271c9a3ddSBharata B Rao * slots that KVM supports, leaving the other half for PCI and other 216371c9a3ddSBharata B Rao * devices. However ensure that number of slots doesn't drop below 32. 216471c9a3ddSBharata B Rao */ 216571c9a3ddSBharata B Rao int max_memslots = kvm_enabled() ? kvm_get_max_memslots() / 2 : 216671c9a3ddSBharata B Rao SPAPR_MAX_RAM_SLOTS; 21674a1c9cf0SBharata B Rao 216871c9a3ddSBharata B Rao if (max_memslots < SPAPR_MAX_RAM_SLOTS) { 216971c9a3ddSBharata B Rao max_memslots = SPAPR_MAX_RAM_SLOTS; 217071c9a3ddSBharata B Rao } 217171c9a3ddSBharata B Rao if (machine->ram_slots > max_memslots) { 2172d54e4d76SDavid Gibson error_report("Specified number of memory slots %" 2173d54e4d76SDavid Gibson PRIu64" exceeds max supported %d", 217471c9a3ddSBharata B Rao machine->ram_slots, max_memslots); 2175d54e4d76SDavid Gibson exit(1); 21764a1c9cf0SBharata B Rao } 21774a1c9cf0SBharata B Rao 21784a1c9cf0SBharata B Rao spapr->hotplug_memory.base = ROUND_UP(machine->ram_size, 21794a1c9cf0SBharata B Rao SPAPR_HOTPLUG_MEM_ALIGN); 21804a1c9cf0SBharata B Rao memory_region_init(&spapr->hotplug_memory.mr, OBJECT(spapr), 21814a1c9cf0SBharata B Rao "hotplug-memory", hotplug_mem_size); 21824a1c9cf0SBharata B Rao memory_region_add_subregion(sysmem, spapr->hotplug_memory.base, 21834a1c9cf0SBharata B Rao &spapr->hotplug_memory.mr); 21844a1c9cf0SBharata B Rao } 21854a1c9cf0SBharata B Rao 2186224245bfSDavid Gibson if (smc->dr_lmb_enabled) { 2187224245bfSDavid Gibson spapr_create_lmb_dr_connectors(spapr); 2188224245bfSDavid Gibson } 2189224245bfSDavid Gibson 219053018216SPaolo Bonzini filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, "spapr-rtas.bin"); 21914c56440dSStefan Weil if (!filename) { 2192730fce59SThomas Huth error_report("Could not find LPAR rtas '%s'", "spapr-rtas.bin"); 21934c56440dSStefan Weil exit(1); 21944c56440dSStefan Weil } 2195b7d1f77aSBenjamin Herrenschmidt spapr->rtas_size = get_image_size(filename); 21968afc22a2SZhou Jie if (spapr->rtas_size < 0) { 21978afc22a2SZhou Jie error_report("Could not get size of LPAR rtas '%s'", filename); 21988afc22a2SZhou Jie exit(1); 21998afc22a2SZhou Jie } 2200b7d1f77aSBenjamin Herrenschmidt spapr->rtas_blob = g_malloc(spapr->rtas_size); 2201b7d1f77aSBenjamin Herrenschmidt if (load_image_size(filename, spapr->rtas_blob, spapr->rtas_size) < 0) { 2202730fce59SThomas Huth error_report("Could not load LPAR rtas '%s'", filename); 220353018216SPaolo Bonzini exit(1); 220453018216SPaolo Bonzini } 220553018216SPaolo Bonzini if (spapr->rtas_size > RTAS_MAX_SIZE) { 2206730fce59SThomas Huth error_report("RTAS too big ! 0x%zx bytes (max is 0x%x)", 22072f285bddSPeter Maydell (size_t)spapr->rtas_size, RTAS_MAX_SIZE); 220853018216SPaolo Bonzini exit(1); 220953018216SPaolo Bonzini } 221053018216SPaolo Bonzini g_free(filename); 221153018216SPaolo Bonzini 2212ffbb1705SMichael Roth /* Set up RTAS event infrastructure */ 221353018216SPaolo Bonzini spapr_events_init(spapr); 221453018216SPaolo Bonzini 221512f42174SDavid Gibson /* Set up the RTC RTAS interfaces */ 221628df36a1SDavid Gibson spapr_rtc_create(spapr); 221712f42174SDavid Gibson 221853018216SPaolo Bonzini /* Set up VIO bus */ 221953018216SPaolo Bonzini spapr->vio_bus = spapr_vio_bus_init(); 222053018216SPaolo Bonzini 222153018216SPaolo Bonzini for (i = 0; i < MAX_SERIAL_PORTS; i++) { 222253018216SPaolo Bonzini if (serial_hds[i]) { 222353018216SPaolo Bonzini spapr_vty_create(spapr->vio_bus, serial_hds[i]); 222453018216SPaolo Bonzini } 222553018216SPaolo Bonzini } 222653018216SPaolo Bonzini 222753018216SPaolo Bonzini /* We always have at least the nvram device on VIO */ 222853018216SPaolo Bonzini spapr_create_nvram(spapr); 222953018216SPaolo Bonzini 223053018216SPaolo Bonzini /* Set up PCI */ 223153018216SPaolo Bonzini spapr_pci_rtas_init(); 223253018216SPaolo Bonzini 223389dfd6e1SDavid Gibson phb = spapr_create_phb(spapr, 0); 223453018216SPaolo Bonzini 223553018216SPaolo Bonzini for (i = 0; i < nb_nics; i++) { 223653018216SPaolo Bonzini NICInfo *nd = &nd_table[i]; 223753018216SPaolo Bonzini 223853018216SPaolo Bonzini if (!nd->model) { 223953018216SPaolo Bonzini nd->model = g_strdup("ibmveth"); 224053018216SPaolo Bonzini } 224153018216SPaolo Bonzini 224253018216SPaolo Bonzini if (strcmp(nd->model, "ibmveth") == 0) { 224353018216SPaolo Bonzini spapr_vlan_create(spapr->vio_bus, nd); 224453018216SPaolo Bonzini } else { 224529b358f9SDavid Gibson pci_nic_init_nofail(&nd_table[i], phb->bus, nd->model, NULL); 224653018216SPaolo Bonzini } 224753018216SPaolo Bonzini } 224853018216SPaolo Bonzini 224953018216SPaolo Bonzini for (i = 0; i <= drive_get_max_bus(IF_SCSI); i++) { 225053018216SPaolo Bonzini spapr_vscsi_create(spapr->vio_bus); 225153018216SPaolo Bonzini } 225253018216SPaolo Bonzini 225353018216SPaolo Bonzini /* Graphics */ 225414c6a894SDavid Gibson if (spapr_vga_init(phb->bus, &error_fatal)) { 225553018216SPaolo Bonzini spapr->has_graphics = true; 2256c6e76503SPaolo Bonzini machine->usb |= defaults_enabled() && !machine->usb_disabled; 225753018216SPaolo Bonzini } 225853018216SPaolo Bonzini 22594ee9ced9SMarcel Apfelbaum if (machine->usb) { 226057040d45SThomas Huth if (smc->use_ohci_by_default) { 226153018216SPaolo Bonzini pci_create_simple(phb->bus, -1, "pci-ohci"); 226257040d45SThomas Huth } else { 226357040d45SThomas Huth pci_create_simple(phb->bus, -1, "nec-usb-xhci"); 226457040d45SThomas Huth } 2265c86580b8SMarkus Armbruster 226653018216SPaolo Bonzini if (spapr->has_graphics) { 2267c86580b8SMarkus Armbruster USBBus *usb_bus = usb_bus_find(-1); 2268c86580b8SMarkus Armbruster 2269c86580b8SMarkus Armbruster usb_create_simple(usb_bus, "usb-kbd"); 2270c86580b8SMarkus Armbruster usb_create_simple(usb_bus, "usb-mouse"); 227153018216SPaolo Bonzini } 227253018216SPaolo Bonzini } 227353018216SPaolo Bonzini 227453018216SPaolo Bonzini if (spapr->rma_size < (MIN_RMA_SLOF << 20)) { 2275d54e4d76SDavid Gibson error_report( 2276d54e4d76SDavid Gibson "pSeries SLOF firmware requires >= %ldM guest RMA (Real Mode Area memory)", 2277d54e4d76SDavid Gibson MIN_RMA_SLOF); 227853018216SPaolo Bonzini exit(1); 227953018216SPaolo Bonzini } 228053018216SPaolo Bonzini 228153018216SPaolo Bonzini if (kernel_filename) { 228253018216SPaolo Bonzini uint64_t lowaddr = 0; 228353018216SPaolo Bonzini 2284a19f7fb0SDavid Gibson spapr->kernel_size = load_elf(kernel_filename, translate_kernel_address, 2285a19f7fb0SDavid Gibson NULL, NULL, &lowaddr, NULL, 1, 2286a19f7fb0SDavid Gibson PPC_ELF_MACHINE, 0, 0); 2287a19f7fb0SDavid Gibson if (spapr->kernel_size == ELF_LOAD_WRONG_ENDIAN) { 2288a19f7fb0SDavid Gibson spapr->kernel_size = load_elf(kernel_filename, 2289a19f7fb0SDavid Gibson translate_kernel_address, NULL, NULL, 2290a19f7fb0SDavid Gibson &lowaddr, NULL, 0, PPC_ELF_MACHINE, 22917ef295eaSPeter Crosthwaite 0, 0); 2292a19f7fb0SDavid Gibson spapr->kernel_le = spapr->kernel_size > 0; 229316457e7fSBenjamin Herrenschmidt } 2294a19f7fb0SDavid Gibson if (spapr->kernel_size < 0) { 2295a19f7fb0SDavid Gibson error_report("error loading %s: %s", kernel_filename, 2296a19f7fb0SDavid Gibson load_elf_strerror(spapr->kernel_size)); 229753018216SPaolo Bonzini exit(1); 229853018216SPaolo Bonzini } 229953018216SPaolo Bonzini 230053018216SPaolo Bonzini /* load initrd */ 230153018216SPaolo Bonzini if (initrd_filename) { 230253018216SPaolo Bonzini /* Try to locate the initrd in the gap between the kernel 230353018216SPaolo Bonzini * and the firmware. Add a bit of space just in case 230453018216SPaolo Bonzini */ 2305a19f7fb0SDavid Gibson spapr->initrd_base = (KERNEL_LOAD_ADDR + spapr->kernel_size 2306a19f7fb0SDavid Gibson + 0x1ffff) & ~0xffff; 2307a19f7fb0SDavid Gibson spapr->initrd_size = load_image_targphys(initrd_filename, 2308a19f7fb0SDavid Gibson spapr->initrd_base, 2309a19f7fb0SDavid Gibson load_limit 2310a19f7fb0SDavid Gibson - spapr->initrd_base); 2311a19f7fb0SDavid Gibson if (spapr->initrd_size < 0) { 2312d54e4d76SDavid Gibson error_report("could not load initial ram disk '%s'", 231353018216SPaolo Bonzini initrd_filename); 231453018216SPaolo Bonzini exit(1); 231553018216SPaolo Bonzini } 231653018216SPaolo Bonzini } 231753018216SPaolo Bonzini } 231853018216SPaolo Bonzini 23198e7ea787SAndreas Färber if (bios_name == NULL) { 23208e7ea787SAndreas Färber bios_name = FW_FILE_NAME; 23218e7ea787SAndreas Färber } 23228e7ea787SAndreas Färber filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name); 23234c56440dSStefan Weil if (!filename) { 232468fea5a0SThomas Huth error_report("Could not find LPAR firmware '%s'", bios_name); 23254c56440dSStefan Weil exit(1); 23264c56440dSStefan Weil } 232753018216SPaolo Bonzini fw_size = load_image_targphys(filename, 0, FW_MAX_SIZE); 232868fea5a0SThomas Huth if (fw_size <= 0) { 232968fea5a0SThomas Huth error_report("Could not load LPAR firmware '%s'", filename); 233053018216SPaolo Bonzini exit(1); 233153018216SPaolo Bonzini } 233253018216SPaolo Bonzini g_free(filename); 233353018216SPaolo Bonzini 233428e02042SDavid Gibson /* FIXME: Should register things through the MachineState's qdev 233528e02042SDavid Gibson * interface, this is a legacy from the sPAPREnvironment structure 233628e02042SDavid Gibson * which predated MachineState but had a similar function */ 23374be21d56SDavid Gibson vmstate_register(NULL, 0, &vmstate_spapr, spapr); 23384be21d56SDavid Gibson register_savevm_live(NULL, "spapr/htab", -1, 1, 23394be21d56SDavid Gibson &savevm_htab_handlers, spapr); 23404be21d56SDavid Gibson 23415b2128d2SAlexander Graf qemu_register_boot_set(spapr_boot_set, spapr); 234242043e4fSLaurent Vivier 234342043e4fSLaurent Vivier if (kvm_enabled()) { 23443dc410aeSAlexey Kardashevskiy /* to stop and start vmclock */ 234542043e4fSLaurent Vivier qemu_add_vm_change_state_handler(cpu_ppc_clock_vm_state_change, 234642043e4fSLaurent Vivier &spapr->tb); 23473dc410aeSAlexey Kardashevskiy 23483dc410aeSAlexey Kardashevskiy kvmppc_spapr_enable_inkernel_multitce(); 234942043e4fSLaurent Vivier } 235053018216SPaolo Bonzini } 235153018216SPaolo Bonzini 2352135a129aSAneesh Kumar K.V static int spapr_kvm_type(const char *vm_type) 2353135a129aSAneesh Kumar K.V { 2354135a129aSAneesh Kumar K.V if (!vm_type) { 2355135a129aSAneesh Kumar K.V return 0; 2356135a129aSAneesh Kumar K.V } 2357135a129aSAneesh Kumar K.V 2358135a129aSAneesh Kumar K.V if (!strcmp(vm_type, "HV")) { 2359135a129aSAneesh Kumar K.V return 1; 2360135a129aSAneesh Kumar K.V } 2361135a129aSAneesh Kumar K.V 2362135a129aSAneesh Kumar K.V if (!strcmp(vm_type, "PR")) { 2363135a129aSAneesh Kumar K.V return 2; 2364135a129aSAneesh Kumar K.V } 2365135a129aSAneesh Kumar K.V 2366135a129aSAneesh Kumar K.V error_report("Unknown kvm-type specified '%s'", vm_type); 2367135a129aSAneesh Kumar K.V exit(1); 2368135a129aSAneesh Kumar K.V } 2369135a129aSAneesh Kumar K.V 237071461b0fSAlexey Kardashevskiy /* 2371627b84f4SGonglei * Implementation of an interface to adjust firmware path 237271461b0fSAlexey Kardashevskiy * for the bootindex property handling. 237371461b0fSAlexey Kardashevskiy */ 237471461b0fSAlexey Kardashevskiy static char *spapr_get_fw_dev_path(FWPathProvider *p, BusState *bus, 237571461b0fSAlexey Kardashevskiy DeviceState *dev) 237671461b0fSAlexey Kardashevskiy { 237771461b0fSAlexey Kardashevskiy #define CAST(type, obj, name) \ 237871461b0fSAlexey Kardashevskiy ((type *)object_dynamic_cast(OBJECT(obj), (name))) 237971461b0fSAlexey Kardashevskiy SCSIDevice *d = CAST(SCSIDevice, dev, TYPE_SCSI_DEVICE); 238071461b0fSAlexey Kardashevskiy sPAPRPHBState *phb = CAST(sPAPRPHBState, dev, TYPE_SPAPR_PCI_HOST_BRIDGE); 2381c4e13492SFelipe Franciosi VHostSCSICommon *vsc = CAST(VHostSCSICommon, dev, TYPE_VHOST_SCSI_COMMON); 238271461b0fSAlexey Kardashevskiy 238371461b0fSAlexey Kardashevskiy if (d) { 238471461b0fSAlexey Kardashevskiy void *spapr = CAST(void, bus->parent, "spapr-vscsi"); 238571461b0fSAlexey Kardashevskiy VirtIOSCSI *virtio = CAST(VirtIOSCSI, bus->parent, TYPE_VIRTIO_SCSI); 238671461b0fSAlexey Kardashevskiy USBDevice *usb = CAST(USBDevice, bus->parent, TYPE_USB_DEVICE); 238771461b0fSAlexey Kardashevskiy 238871461b0fSAlexey Kardashevskiy if (spapr) { 238971461b0fSAlexey Kardashevskiy /* 239071461b0fSAlexey Kardashevskiy * Replace "channel@0/disk@0,0" with "disk@8000000000000000": 239171461b0fSAlexey Kardashevskiy * We use SRP luns of the form 8000 | (bus << 8) | (id << 5) | lun 239271461b0fSAlexey Kardashevskiy * in the top 16 bits of the 64-bit LUN 239371461b0fSAlexey Kardashevskiy */ 239471461b0fSAlexey Kardashevskiy unsigned id = 0x8000 | (d->id << 8) | d->lun; 239571461b0fSAlexey Kardashevskiy return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev), 239671461b0fSAlexey Kardashevskiy (uint64_t)id << 48); 239771461b0fSAlexey Kardashevskiy } else if (virtio) { 239871461b0fSAlexey Kardashevskiy /* 239971461b0fSAlexey Kardashevskiy * We use SRP luns of the form 01000000 | (target << 8) | lun 240071461b0fSAlexey Kardashevskiy * in the top 32 bits of the 64-bit LUN 240171461b0fSAlexey Kardashevskiy * Note: the quote above is from SLOF and it is wrong, 240271461b0fSAlexey Kardashevskiy * the actual binding is: 240371461b0fSAlexey Kardashevskiy * swap 0100 or 10 << or 20 << ( target lun-id -- srplun ) 240471461b0fSAlexey Kardashevskiy */ 240571461b0fSAlexey Kardashevskiy unsigned id = 0x1000000 | (d->id << 16) | d->lun; 240671461b0fSAlexey Kardashevskiy return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev), 240771461b0fSAlexey Kardashevskiy (uint64_t)id << 32); 240871461b0fSAlexey Kardashevskiy } else if (usb) { 240971461b0fSAlexey Kardashevskiy /* 241071461b0fSAlexey Kardashevskiy * We use SRP luns of the form 01000000 | (usb-port << 16) | lun 241171461b0fSAlexey Kardashevskiy * in the top 32 bits of the 64-bit LUN 241271461b0fSAlexey Kardashevskiy */ 241371461b0fSAlexey Kardashevskiy unsigned usb_port = atoi(usb->port->path); 241471461b0fSAlexey Kardashevskiy unsigned id = 0x1000000 | (usb_port << 16) | d->lun; 241571461b0fSAlexey Kardashevskiy return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev), 241671461b0fSAlexey Kardashevskiy (uint64_t)id << 32); 241771461b0fSAlexey Kardashevskiy } 241871461b0fSAlexey Kardashevskiy } 241971461b0fSAlexey Kardashevskiy 2420b99260ebSThomas Huth /* 2421b99260ebSThomas Huth * SLOF probes the USB devices, and if it recognizes that the device is a 2422b99260ebSThomas Huth * storage device, it changes its name to "storage" instead of "usb-host", 2423b99260ebSThomas Huth * and additionally adds a child node for the SCSI LUN, so the correct 2424b99260ebSThomas Huth * boot path in SLOF is something like .../storage@1/disk@xxx" instead. 2425b99260ebSThomas Huth */ 2426b99260ebSThomas Huth if (strcmp("usb-host", qdev_fw_name(dev)) == 0) { 2427b99260ebSThomas Huth USBDevice *usbdev = CAST(USBDevice, dev, TYPE_USB_DEVICE); 2428b99260ebSThomas Huth if (usb_host_dev_is_scsi_storage(usbdev)) { 2429b99260ebSThomas Huth return g_strdup_printf("storage@%s/disk", usbdev->port->path); 2430b99260ebSThomas Huth } 2431b99260ebSThomas Huth } 2432b99260ebSThomas Huth 243371461b0fSAlexey Kardashevskiy if (phb) { 243471461b0fSAlexey Kardashevskiy /* Replace "pci" with "pci@800000020000000" */ 243571461b0fSAlexey Kardashevskiy return g_strdup_printf("pci@%"PRIX64, phb->buid); 243671461b0fSAlexey Kardashevskiy } 243771461b0fSAlexey Kardashevskiy 2438c4e13492SFelipe Franciosi if (vsc) { 2439c4e13492SFelipe Franciosi /* Same logic as virtio above */ 2440c4e13492SFelipe Franciosi unsigned id = 0x1000000 | (vsc->target << 16) | vsc->lun; 2441c4e13492SFelipe Franciosi return g_strdup_printf("disk@%"PRIX64, (uint64_t)id << 32); 2442c4e13492SFelipe Franciosi } 2443c4e13492SFelipe Franciosi 244471461b0fSAlexey Kardashevskiy return NULL; 244571461b0fSAlexey Kardashevskiy } 244671461b0fSAlexey Kardashevskiy 244723825581SEduardo Habkost static char *spapr_get_kvm_type(Object *obj, Error **errp) 244823825581SEduardo Habkost { 244928e02042SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 245023825581SEduardo Habkost 245128e02042SDavid Gibson return g_strdup(spapr->kvm_type); 245223825581SEduardo Habkost } 245323825581SEduardo Habkost 245423825581SEduardo Habkost static void spapr_set_kvm_type(Object *obj, const char *value, Error **errp) 245523825581SEduardo Habkost { 245628e02042SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 245723825581SEduardo Habkost 245828e02042SDavid Gibson g_free(spapr->kvm_type); 245928e02042SDavid Gibson spapr->kvm_type = g_strdup(value); 246023825581SEduardo Habkost } 246123825581SEduardo Habkost 2462f6229214SMichael Roth static bool spapr_get_modern_hotplug_events(Object *obj, Error **errp) 2463f6229214SMichael Roth { 2464f6229214SMichael Roth sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 2465f6229214SMichael Roth 2466f6229214SMichael Roth return spapr->use_hotplug_event_source; 2467f6229214SMichael Roth } 2468f6229214SMichael Roth 2469f6229214SMichael Roth static void spapr_set_modern_hotplug_events(Object *obj, bool value, 2470f6229214SMichael Roth Error **errp) 2471f6229214SMichael Roth { 2472f6229214SMichael Roth sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 2473f6229214SMichael Roth 2474f6229214SMichael Roth spapr->use_hotplug_event_source = value; 2475f6229214SMichael Roth } 2476f6229214SMichael Roth 247723825581SEduardo Habkost static void spapr_machine_initfn(Object *obj) 247823825581SEduardo Habkost { 2479715c5407SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 2480715c5407SDavid Gibson 2481715c5407SDavid Gibson spapr->htab_fd = -1; 2482f6229214SMichael Roth spapr->use_hotplug_event_source = true; 248323825581SEduardo Habkost object_property_add_str(obj, "kvm-type", 248423825581SEduardo Habkost spapr_get_kvm_type, spapr_set_kvm_type, NULL); 248549d2e648SMarcel Apfelbaum object_property_set_description(obj, "kvm-type", 248649d2e648SMarcel Apfelbaum "Specifies the KVM virtualization mode (HV, PR)", 248749d2e648SMarcel Apfelbaum NULL); 2488f6229214SMichael Roth object_property_add_bool(obj, "modern-hotplug-events", 2489f6229214SMichael Roth spapr_get_modern_hotplug_events, 2490f6229214SMichael Roth spapr_set_modern_hotplug_events, 2491f6229214SMichael Roth NULL); 2492f6229214SMichael Roth object_property_set_description(obj, "modern-hotplug-events", 2493f6229214SMichael Roth "Use dedicated hotplug event mechanism in" 2494f6229214SMichael Roth " place of standard EPOW events when possible" 2495f6229214SMichael Roth " (required for memory hot-unplug support)", 2496f6229214SMichael Roth NULL); 249723825581SEduardo Habkost } 249823825581SEduardo Habkost 249987bbdd9cSDavid Gibson static void spapr_machine_finalizefn(Object *obj) 250087bbdd9cSDavid Gibson { 250187bbdd9cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 250287bbdd9cSDavid Gibson 250387bbdd9cSDavid Gibson g_free(spapr->kvm_type); 250487bbdd9cSDavid Gibson } 250587bbdd9cSDavid Gibson 25061c7ad77eSNicholas Piggin void spapr_do_system_reset_on_cpu(CPUState *cs, run_on_cpu_data arg) 250734316482SAlexey Kardashevskiy { 250834316482SAlexey Kardashevskiy cpu_synchronize_state(cs); 250934316482SAlexey Kardashevskiy ppc_cpu_do_system_reset(cs); 251034316482SAlexey Kardashevskiy } 251134316482SAlexey Kardashevskiy 251234316482SAlexey Kardashevskiy static void spapr_nmi(NMIState *n, int cpu_index, Error **errp) 251334316482SAlexey Kardashevskiy { 251434316482SAlexey Kardashevskiy CPUState *cs; 251534316482SAlexey Kardashevskiy 251634316482SAlexey Kardashevskiy CPU_FOREACH(cs) { 25171c7ad77eSNicholas Piggin async_run_on_cpu(cs, spapr_do_system_reset_on_cpu, RUN_ON_CPU_NULL); 251834316482SAlexey Kardashevskiy } 251934316482SAlexey Kardashevskiy } 252034316482SAlexey Kardashevskiy 252179b78a6bSMichael Roth static void spapr_add_lmbs(DeviceState *dev, uint64_t addr_start, uint64_t size, 252279b78a6bSMichael Roth uint32_t node, bool dedicated_hp_event_source, 252379b78a6bSMichael Roth Error **errp) 2524c20d332aSBharata B Rao { 2525c20d332aSBharata B Rao sPAPRDRConnector *drc; 2526c20d332aSBharata B Rao sPAPRDRConnectorClass *drck; 2527c20d332aSBharata B Rao uint32_t nr_lmbs = size/SPAPR_MEMORY_BLOCK_SIZE; 2528c20d332aSBharata B Rao int i, fdt_offset, fdt_size; 2529c20d332aSBharata B Rao void *fdt; 253079b78a6bSMichael Roth uint64_t addr = addr_start; 2531c20d332aSBharata B Rao 2532c20d332aSBharata B Rao for (i = 0; i < nr_lmbs; i++) { 2533fbf55397SDavid Gibson drc = spapr_drc_by_id(TYPE_SPAPR_DRC_LMB, 2534c20d332aSBharata B Rao addr / SPAPR_MEMORY_BLOCK_SIZE); 2535c20d332aSBharata B Rao g_assert(drc); 2536c20d332aSBharata B Rao 2537c20d332aSBharata B Rao fdt = create_device_tree(&fdt_size); 2538c20d332aSBharata B Rao fdt_offset = spapr_populate_memory_node(fdt, node, addr, 2539c20d332aSBharata B Rao SPAPR_MEMORY_BLOCK_SIZE); 2540c20d332aSBharata B Rao 2541c20d332aSBharata B Rao drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 2542c20d332aSBharata B Rao drck->attach(drc, dev, fdt, fdt_offset, !dev->hotplugged, errp); 2543c20d332aSBharata B Rao addr += SPAPR_MEMORY_BLOCK_SIZE; 25445c0139a8SMichael Roth if (!dev->hotplugged) { 25455c0139a8SMichael Roth /* guests expect coldplugged LMBs to be pre-allocated */ 25465c0139a8SMichael Roth drck->set_allocation_state(drc, SPAPR_DR_ALLOCATION_STATE_USABLE); 25475c0139a8SMichael Roth drck->set_isolation_state(drc, SPAPR_DR_ISOLATION_STATE_UNISOLATED); 25485c0139a8SMichael Roth } 2549c20d332aSBharata B Rao } 25505dd5238cSJianjun Duan /* send hotplug notification to the 25515dd5238cSJianjun Duan * guest only in case of hotplugged memory 25525dd5238cSJianjun Duan */ 25535dd5238cSJianjun Duan if (dev->hotplugged) { 255479b78a6bSMichael Roth if (dedicated_hp_event_source) { 2555fbf55397SDavid Gibson drc = spapr_drc_by_id(TYPE_SPAPR_DRC_LMB, 255679b78a6bSMichael Roth addr_start / SPAPR_MEMORY_BLOCK_SIZE); 255779b78a6bSMichael Roth drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 255879b78a6bSMichael Roth spapr_hotplug_req_add_by_count_indexed(SPAPR_DR_CONNECTOR_TYPE_LMB, 255979b78a6bSMichael Roth nr_lmbs, 25600b55aa91SDavid Gibson spapr_drc_index(drc)); 256179b78a6bSMichael Roth } else { 256279b78a6bSMichael Roth spapr_hotplug_req_add_by_count(SPAPR_DR_CONNECTOR_TYPE_LMB, 256379b78a6bSMichael Roth nr_lmbs); 256479b78a6bSMichael Roth } 2565c20d332aSBharata B Rao } 25665dd5238cSJianjun Duan } 2567c20d332aSBharata B Rao 2568c20d332aSBharata B Rao static void spapr_memory_plug(HotplugHandler *hotplug_dev, DeviceState *dev, 2569c20d332aSBharata B Rao uint32_t node, Error **errp) 2570c20d332aSBharata B Rao { 2571c20d332aSBharata B Rao Error *local_err = NULL; 2572c20d332aSBharata B Rao sPAPRMachineState *ms = SPAPR_MACHINE(hotplug_dev); 2573c20d332aSBharata B Rao PCDIMMDevice *dimm = PC_DIMM(dev); 2574c20d332aSBharata B Rao PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); 2575c20d332aSBharata B Rao MemoryRegion *mr = ddc->get_memory_region(dimm); 2576c20d332aSBharata B Rao uint64_t align = memory_region_get_alignment(mr); 2577c20d332aSBharata B Rao uint64_t size = memory_region_size(mr); 2578c20d332aSBharata B Rao uint64_t addr; 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 2599c871bc70SLaurent Vivier static void spapr_memory_pre_plug(HotplugHandler *hotplug_dev, DeviceState *dev, 2600c871bc70SLaurent Vivier Error **errp) 2601c871bc70SLaurent Vivier { 2602c871bc70SLaurent Vivier PCDIMMDevice *dimm = PC_DIMM(dev); 2603c871bc70SLaurent Vivier PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); 2604c871bc70SLaurent Vivier MemoryRegion *mr = ddc->get_memory_region(dimm); 2605c871bc70SLaurent Vivier uint64_t size = memory_region_size(mr); 2606c871bc70SLaurent Vivier char *mem_dev; 2607c871bc70SLaurent Vivier 2608c871bc70SLaurent Vivier if (size % SPAPR_MEMORY_BLOCK_SIZE) { 2609c871bc70SLaurent Vivier error_setg(errp, "Hotplugged memory size must be a multiple of " 2610c871bc70SLaurent Vivier "%lld MB", SPAPR_MEMORY_BLOCK_SIZE / M_BYTE); 2611c871bc70SLaurent Vivier return; 2612c871bc70SLaurent Vivier } 2613c871bc70SLaurent Vivier 2614c871bc70SLaurent Vivier mem_dev = object_property_get_str(OBJECT(dimm), PC_DIMM_MEMDEV_PROP, NULL); 2615c871bc70SLaurent Vivier if (mem_dev && !kvmppc_is_mem_backend_page_size_ok(mem_dev)) { 2616c871bc70SLaurent Vivier error_setg(errp, "Memory backend has bad page size. " 2617c871bc70SLaurent Vivier "Use 'memory-backend-file' with correct mem-path."); 2618*8a9e0e7bSGreg Kurz goto out; 2619c871bc70SLaurent Vivier } 2620*8a9e0e7bSGreg Kurz 2621*8a9e0e7bSGreg Kurz out: 2622*8a9e0e7bSGreg Kurz g_free(mem_dev); 2623c871bc70SLaurent Vivier } 2624c871bc70SLaurent Vivier 26250cffce56SDavid Gibson struct sPAPRDIMMState { 26260cffce56SDavid Gibson PCDIMMDevice *dimm; 2627cf632463SBharata B Rao uint32_t nr_lmbs; 26280cffce56SDavid Gibson QTAILQ_ENTRY(sPAPRDIMMState) next; 26290cffce56SDavid Gibson }; 26300cffce56SDavid Gibson 26310cffce56SDavid Gibson static sPAPRDIMMState *spapr_pending_dimm_unplugs_find(sPAPRMachineState *s, 26320cffce56SDavid Gibson PCDIMMDevice *dimm) 26330cffce56SDavid Gibson { 26340cffce56SDavid Gibson sPAPRDIMMState *dimm_state = NULL; 26350cffce56SDavid Gibson 26360cffce56SDavid Gibson QTAILQ_FOREACH(dimm_state, &s->pending_dimm_unplugs, next) { 26370cffce56SDavid Gibson if (dimm_state->dimm == dimm) { 26380cffce56SDavid Gibson break; 26390cffce56SDavid Gibson } 26400cffce56SDavid Gibson } 26410cffce56SDavid Gibson return dimm_state; 26420cffce56SDavid Gibson } 26430cffce56SDavid Gibson 26440cffce56SDavid Gibson static void spapr_pending_dimm_unplugs_add(sPAPRMachineState *spapr, 26450cffce56SDavid Gibson sPAPRDIMMState *dimm_state) 26460cffce56SDavid Gibson { 26470cffce56SDavid Gibson g_assert(!spapr_pending_dimm_unplugs_find(spapr, dimm_state->dimm)); 26480cffce56SDavid Gibson QTAILQ_INSERT_HEAD(&spapr->pending_dimm_unplugs, dimm_state, next); 26490cffce56SDavid Gibson } 26500cffce56SDavid Gibson 26510cffce56SDavid Gibson static void spapr_pending_dimm_unplugs_remove(sPAPRMachineState *spapr, 26520cffce56SDavid Gibson sPAPRDIMMState *dimm_state) 26530cffce56SDavid Gibson { 26540cffce56SDavid Gibson QTAILQ_REMOVE(&spapr->pending_dimm_unplugs, dimm_state, next); 26550cffce56SDavid Gibson g_free(dimm_state); 26560cffce56SDavid Gibson } 2657cf632463SBharata B Rao 265816ee9980SDaniel Henrique Barboza static sPAPRDIMMState *spapr_recover_pending_dimm_state(sPAPRMachineState *ms, 265916ee9980SDaniel Henrique Barboza PCDIMMDevice *dimm) 266016ee9980SDaniel Henrique Barboza { 266116ee9980SDaniel Henrique Barboza sPAPRDRConnector *drc; 266216ee9980SDaniel Henrique Barboza PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); 266316ee9980SDaniel Henrique Barboza MemoryRegion *mr = ddc->get_memory_region(dimm); 266416ee9980SDaniel Henrique Barboza uint64_t size = memory_region_size(mr); 266516ee9980SDaniel Henrique Barboza uint32_t nr_lmbs = size / SPAPR_MEMORY_BLOCK_SIZE; 266616ee9980SDaniel Henrique Barboza uint32_t avail_lmbs = 0; 266716ee9980SDaniel Henrique Barboza uint64_t addr_start, addr; 266816ee9980SDaniel Henrique Barboza int i; 266916ee9980SDaniel Henrique Barboza sPAPRDIMMState *ds; 267016ee9980SDaniel Henrique Barboza 267116ee9980SDaniel Henrique Barboza addr_start = object_property_get_int(OBJECT(dimm), PC_DIMM_ADDR_PROP, 267216ee9980SDaniel Henrique Barboza &error_abort); 267316ee9980SDaniel Henrique Barboza 267416ee9980SDaniel Henrique Barboza addr = addr_start; 267516ee9980SDaniel Henrique Barboza for (i = 0; i < nr_lmbs; i++) { 2676fbf55397SDavid Gibson drc = spapr_drc_by_id(TYPE_SPAPR_DRC_LMB, 267716ee9980SDaniel Henrique Barboza addr / SPAPR_MEMORY_BLOCK_SIZE); 267816ee9980SDaniel Henrique Barboza g_assert(drc); 267916ee9980SDaniel Henrique Barboza if (drc->indicator_state != SPAPR_DR_INDICATOR_STATE_INACTIVE) { 268016ee9980SDaniel Henrique Barboza avail_lmbs++; 268116ee9980SDaniel Henrique Barboza } 268216ee9980SDaniel Henrique Barboza addr += SPAPR_MEMORY_BLOCK_SIZE; 268316ee9980SDaniel Henrique Barboza } 268416ee9980SDaniel Henrique Barboza 268516ee9980SDaniel Henrique Barboza ds = g_malloc0(sizeof(sPAPRDIMMState)); 268616ee9980SDaniel Henrique Barboza ds->nr_lmbs = avail_lmbs; 268716ee9980SDaniel Henrique Barboza ds->dimm = dimm; 268816ee9980SDaniel Henrique Barboza spapr_pending_dimm_unplugs_add(ms, ds); 268916ee9980SDaniel Henrique Barboza return ds; 269016ee9980SDaniel Henrique Barboza } 269116ee9980SDaniel Henrique Barboza 269231834723SDaniel Henrique Barboza /* Callback to be called during DRC release. */ 269331834723SDaniel Henrique Barboza void spapr_lmb_release(DeviceState *dev) 2694cf632463SBharata B Rao { 26950cffce56SDavid Gibson HotplugHandler *hotplug_ctrl = qdev_get_hotplug_handler(dev); 26960cffce56SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(hotplug_ctrl); 26970cffce56SDavid Gibson sPAPRDIMMState *ds = spapr_pending_dimm_unplugs_find(spapr, PC_DIMM(dev)); 2698cf632463SBharata B Rao 269916ee9980SDaniel Henrique Barboza /* This information will get lost if a migration occurs 270016ee9980SDaniel Henrique Barboza * during the unplug process. In this case recover it. */ 270116ee9980SDaniel Henrique Barboza if (ds == NULL) { 270216ee9980SDaniel Henrique Barboza ds = spapr_recover_pending_dimm_state(spapr, PC_DIMM(dev)); 270316ee9980SDaniel Henrique Barboza if (ds->nr_lmbs) { 270416ee9980SDaniel Henrique Barboza return; 270516ee9980SDaniel Henrique Barboza } 270616ee9980SDaniel Henrique Barboza } else if (--ds->nr_lmbs) { 2707cf632463SBharata B Rao return; 2708cf632463SBharata B Rao } 2709cf632463SBharata B Rao 27100cffce56SDavid Gibson spapr_pending_dimm_unplugs_remove(spapr, ds); 2711cf632463SBharata B Rao 2712cf632463SBharata B Rao /* 2713cf632463SBharata B Rao * Now that all the LMBs have been removed by the guest, call the 2714cf632463SBharata B Rao * pc-dimm unplug handler to cleanup up the pc-dimm device. 2715cf632463SBharata B Rao */ 2716cf632463SBharata B Rao hotplug_handler_unplug(hotplug_ctrl, dev, &error_abort); 2717cf632463SBharata B Rao } 2718cf632463SBharata B Rao 2719cf632463SBharata B Rao static void spapr_memory_unplug(HotplugHandler *hotplug_dev, DeviceState *dev, 2720cf632463SBharata B Rao Error **errp) 2721cf632463SBharata B Rao { 2722cf632463SBharata B Rao sPAPRMachineState *ms = SPAPR_MACHINE(hotplug_dev); 2723cf632463SBharata B Rao PCDIMMDevice *dimm = PC_DIMM(dev); 2724cf632463SBharata B Rao PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); 2725cf632463SBharata B Rao MemoryRegion *mr = ddc->get_memory_region(dimm); 2726cf632463SBharata B Rao 2727cf632463SBharata B Rao pc_dimm_memory_unplug(dev, &ms->hotplug_memory, mr); 2728cf632463SBharata B Rao object_unparent(OBJECT(dev)); 2729cf632463SBharata B Rao } 2730cf632463SBharata B Rao 2731cf632463SBharata B Rao static void spapr_memory_unplug_request(HotplugHandler *hotplug_dev, 2732cf632463SBharata B Rao DeviceState *dev, Error **errp) 2733cf632463SBharata B Rao { 27340cffce56SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(hotplug_dev); 2735cf632463SBharata B Rao Error *local_err = NULL; 2736cf632463SBharata B Rao PCDIMMDevice *dimm = PC_DIMM(dev); 2737cf632463SBharata B Rao PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); 2738cf632463SBharata B Rao MemoryRegion *mr = ddc->get_memory_region(dimm); 2739cf632463SBharata B Rao uint64_t size = memory_region_size(mr); 27400cffce56SDavid Gibson uint32_t nr_lmbs = size / SPAPR_MEMORY_BLOCK_SIZE; 27410cffce56SDavid Gibson uint64_t addr_start, addr; 27420cffce56SDavid Gibson int i; 27430cffce56SDavid Gibson sPAPRDRConnector *drc; 27440cffce56SDavid Gibson sPAPRDRConnectorClass *drck; 27450cffce56SDavid Gibson sPAPRDIMMState *ds; 2746cf632463SBharata B Rao 27470cffce56SDavid Gibson addr_start = object_property_get_int(OBJECT(dimm), PC_DIMM_ADDR_PROP, 27480cffce56SDavid Gibson &local_err); 2749cf632463SBharata B Rao if (local_err) { 2750cf632463SBharata B Rao goto out; 2751cf632463SBharata B Rao } 2752cf632463SBharata B Rao 27530cffce56SDavid Gibson ds = g_malloc0(sizeof(sPAPRDIMMState)); 27540cffce56SDavid Gibson ds->nr_lmbs = nr_lmbs; 27550cffce56SDavid Gibson ds->dimm = dimm; 27560cffce56SDavid Gibson spapr_pending_dimm_unplugs_add(spapr, ds); 27570cffce56SDavid Gibson 27580cffce56SDavid Gibson addr = addr_start; 27590cffce56SDavid Gibson for (i = 0; i < nr_lmbs; i++) { 2760fbf55397SDavid Gibson drc = spapr_drc_by_id(TYPE_SPAPR_DRC_LMB, 27610cffce56SDavid Gibson addr / SPAPR_MEMORY_BLOCK_SIZE); 27620cffce56SDavid Gibson g_assert(drc); 27630cffce56SDavid Gibson 27640cffce56SDavid Gibson drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 276531834723SDaniel Henrique Barboza drck->detach(drc, dev, errp); 27660cffce56SDavid Gibson addr += SPAPR_MEMORY_BLOCK_SIZE; 27670cffce56SDavid Gibson } 27680cffce56SDavid Gibson 2769fbf55397SDavid Gibson drc = spapr_drc_by_id(TYPE_SPAPR_DRC_LMB, 27700cffce56SDavid Gibson addr_start / SPAPR_MEMORY_BLOCK_SIZE); 27710cffce56SDavid Gibson drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 27720cffce56SDavid Gibson spapr_hotplug_req_remove_by_count_indexed(SPAPR_DR_CONNECTOR_TYPE_LMB, 27730b55aa91SDavid Gibson nr_lmbs, spapr_drc_index(drc)); 2774cf632463SBharata B Rao out: 2775cf632463SBharata B Rao error_propagate(errp, local_err); 2776cf632463SBharata B Rao } 2777cf632463SBharata B Rao 2778af81cf32SBharata B Rao void *spapr_populate_hotplug_cpu_dt(CPUState *cs, int *fdt_offset, 2779af81cf32SBharata B Rao sPAPRMachineState *spapr) 2780af81cf32SBharata B Rao { 2781af81cf32SBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(cs); 2782af81cf32SBharata B Rao DeviceClass *dc = DEVICE_GET_CLASS(cs); 2783af81cf32SBharata B Rao int id = ppc_get_vcpu_dt_id(cpu); 2784af81cf32SBharata B Rao void *fdt; 2785af81cf32SBharata B Rao int offset, fdt_size; 2786af81cf32SBharata B Rao char *nodename; 2787af81cf32SBharata B Rao 2788af81cf32SBharata B Rao fdt = create_device_tree(&fdt_size); 2789af81cf32SBharata B Rao nodename = g_strdup_printf("%s@%x", dc->fw_name, id); 2790af81cf32SBharata B Rao offset = fdt_add_subnode(fdt, 0, nodename); 2791af81cf32SBharata B Rao 2792af81cf32SBharata B Rao spapr_populate_cpu_dt(cs, fdt, offset, spapr); 2793af81cf32SBharata B Rao g_free(nodename); 2794af81cf32SBharata B Rao 2795af81cf32SBharata B Rao *fdt_offset = offset; 2796af81cf32SBharata B Rao return fdt; 2797af81cf32SBharata B Rao } 2798af81cf32SBharata B Rao 2799115debf2SIgor Mammedov static void spapr_core_unplug(HotplugHandler *hotplug_dev, DeviceState *dev, 2800115debf2SIgor Mammedov Error **errp) 2801ff9006ddSIgor Mammedov { 2802535455fdSIgor Mammedov MachineState *ms = MACHINE(qdev_get_machine()); 2803ff9006ddSIgor Mammedov CPUCore *cc = CPU_CORE(dev); 2804535455fdSIgor Mammedov CPUArchId *core_slot = spapr_find_cpu_slot(ms, cc->core_id, NULL); 2805ff9006ddSIgor Mammedov 280607572c06SGreg Kurz assert(core_slot); 2807535455fdSIgor Mammedov core_slot->cpu = NULL; 2808ff9006ddSIgor Mammedov object_unparent(OBJECT(dev)); 2809ff9006ddSIgor Mammedov } 2810ff9006ddSIgor Mammedov 281131834723SDaniel Henrique Barboza /* Callback to be called during DRC release. */ 281231834723SDaniel Henrique Barboza void spapr_core_release(DeviceState *dev) 2813115debf2SIgor Mammedov { 2814115debf2SIgor Mammedov HotplugHandler *hotplug_ctrl; 2815115debf2SIgor Mammedov 2816115debf2SIgor Mammedov hotplug_ctrl = qdev_get_hotplug_handler(dev); 2817115debf2SIgor Mammedov hotplug_handler_unplug(hotplug_ctrl, dev, &error_abort); 2818115debf2SIgor Mammedov } 2819115debf2SIgor Mammedov 2820115debf2SIgor Mammedov static 2821115debf2SIgor Mammedov void spapr_core_unplug_request(HotplugHandler *hotplug_dev, DeviceState *dev, 2822ff9006ddSIgor Mammedov Error **errp) 2823ff9006ddSIgor Mammedov { 2824535455fdSIgor Mammedov int index; 2825535455fdSIgor Mammedov sPAPRDRConnector *drc; 2826ff9006ddSIgor Mammedov sPAPRDRConnectorClass *drck; 2827ff9006ddSIgor Mammedov Error *local_err = NULL; 2828535455fdSIgor Mammedov CPUCore *cc = CPU_CORE(dev); 2829535455fdSIgor Mammedov int smt = kvmppc_smt_threads(); 2830ff9006ddSIgor Mammedov 2831535455fdSIgor Mammedov if (!spapr_find_cpu_slot(MACHINE(hotplug_dev), cc->core_id, &index)) { 2832535455fdSIgor Mammedov error_setg(errp, "Unable to find CPU core with core-id: %d", 2833535455fdSIgor Mammedov cc->core_id); 2834535455fdSIgor Mammedov return; 2835535455fdSIgor Mammedov } 2836ff9006ddSIgor Mammedov if (index == 0) { 2837ff9006ddSIgor Mammedov error_setg(errp, "Boot CPU core may not be unplugged"); 2838ff9006ddSIgor Mammedov return; 2839ff9006ddSIgor Mammedov } 2840ff9006ddSIgor Mammedov 2841fbf55397SDavid Gibson drc = spapr_drc_by_id(TYPE_SPAPR_DRC_CPU, index * smt); 2842ff9006ddSIgor Mammedov g_assert(drc); 2843ff9006ddSIgor Mammedov 2844ff9006ddSIgor Mammedov drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 284531834723SDaniel Henrique Barboza drck->detach(drc, dev, &local_err); 2846ff9006ddSIgor Mammedov if (local_err) { 2847ff9006ddSIgor Mammedov error_propagate(errp, local_err); 2848ff9006ddSIgor Mammedov return; 2849ff9006ddSIgor Mammedov } 2850ff9006ddSIgor Mammedov 2851ff9006ddSIgor Mammedov spapr_hotplug_req_remove_by_index(drc); 2852ff9006ddSIgor Mammedov } 2853ff9006ddSIgor Mammedov 2854ff9006ddSIgor Mammedov static void spapr_core_plug(HotplugHandler *hotplug_dev, DeviceState *dev, 2855ff9006ddSIgor Mammedov Error **errp) 2856ff9006ddSIgor Mammedov { 2857ff9006ddSIgor Mammedov sPAPRMachineState *spapr = SPAPR_MACHINE(OBJECT(hotplug_dev)); 2858ff9006ddSIgor Mammedov MachineClass *mc = MACHINE_GET_CLASS(spapr); 2859ff9006ddSIgor Mammedov sPAPRCPUCore *core = SPAPR_CPU_CORE(OBJECT(dev)); 2860ff9006ddSIgor Mammedov CPUCore *cc = CPU_CORE(dev); 2861ff9006ddSIgor Mammedov CPUState *cs = CPU(core->threads); 2862ff9006ddSIgor Mammedov sPAPRDRConnector *drc; 2863ff9006ddSIgor Mammedov Error *local_err = NULL; 2864ff9006ddSIgor Mammedov void *fdt = NULL; 2865ff9006ddSIgor Mammedov int fdt_offset = 0; 2866ff9006ddSIgor Mammedov int smt = kvmppc_smt_threads(); 2867535455fdSIgor Mammedov CPUArchId *core_slot; 2868535455fdSIgor Mammedov int index; 2869ff9006ddSIgor Mammedov 2870535455fdSIgor Mammedov core_slot = spapr_find_cpu_slot(MACHINE(hotplug_dev), cc->core_id, &index); 2871535455fdSIgor Mammedov if (!core_slot) { 2872535455fdSIgor Mammedov error_setg(errp, "Unable to find CPU core with core-id: %d", 2873535455fdSIgor Mammedov cc->core_id); 2874535455fdSIgor Mammedov return; 2875535455fdSIgor Mammedov } 2876fbf55397SDavid Gibson drc = spapr_drc_by_id(TYPE_SPAPR_DRC_CPU, index * smt); 2877ff9006ddSIgor Mammedov 2878c5514d0eSIgor Mammedov g_assert(drc || !mc->has_hotpluggable_cpus); 2879ff9006ddSIgor Mammedov 2880ff9006ddSIgor Mammedov /* 2881ff9006ddSIgor Mammedov * Setup CPU DT entries only for hotplugged CPUs. For boot time or 2882ff9006ddSIgor Mammedov * coldplugged CPUs DT entries are setup in spapr_build_fdt(). 2883ff9006ddSIgor Mammedov */ 2884ff9006ddSIgor Mammedov if (dev->hotplugged) { 2885ff9006ddSIgor Mammedov fdt = spapr_populate_hotplug_cpu_dt(cs, &fdt_offset, spapr); 2886ff9006ddSIgor Mammedov } 2887ff9006ddSIgor Mammedov 2888ff9006ddSIgor Mammedov if (drc) { 2889ff9006ddSIgor Mammedov sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 2890ff9006ddSIgor Mammedov drck->attach(drc, dev, fdt, fdt_offset, !dev->hotplugged, &local_err); 2891ff9006ddSIgor Mammedov if (local_err) { 2892ff9006ddSIgor Mammedov g_free(fdt); 2893ff9006ddSIgor Mammedov error_propagate(errp, local_err); 2894ff9006ddSIgor Mammedov return; 2895ff9006ddSIgor Mammedov } 2896ff9006ddSIgor Mammedov } 2897ff9006ddSIgor Mammedov 2898ff9006ddSIgor Mammedov if (dev->hotplugged) { 2899ff9006ddSIgor Mammedov /* 2900ff9006ddSIgor Mammedov * Send hotplug notification interrupt to the guest only in case 2901ff9006ddSIgor Mammedov * of hotplugged CPUs. 2902ff9006ddSIgor Mammedov */ 2903ff9006ddSIgor Mammedov spapr_hotplug_req_add_by_index(drc); 2904ff9006ddSIgor Mammedov } else { 2905ff9006ddSIgor Mammedov /* 2906ff9006ddSIgor Mammedov * Set the right DRC states for cold plugged CPU. 2907ff9006ddSIgor Mammedov */ 2908ff9006ddSIgor Mammedov if (drc) { 2909ff9006ddSIgor Mammedov sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 2910ff9006ddSIgor Mammedov drck->set_allocation_state(drc, SPAPR_DR_ALLOCATION_STATE_USABLE); 2911ff9006ddSIgor Mammedov drck->set_isolation_state(drc, SPAPR_DR_ISOLATION_STATE_UNISOLATED); 2912ff9006ddSIgor Mammedov } 2913ff9006ddSIgor Mammedov } 2914535455fdSIgor Mammedov core_slot->cpu = OBJECT(dev); 2915ff9006ddSIgor Mammedov } 2916ff9006ddSIgor Mammedov 2917ff9006ddSIgor Mammedov static void spapr_core_pre_plug(HotplugHandler *hotplug_dev, DeviceState *dev, 2918ff9006ddSIgor Mammedov Error **errp) 2919ff9006ddSIgor Mammedov { 2920ff9006ddSIgor Mammedov MachineState *machine = MACHINE(OBJECT(hotplug_dev)); 2921ff9006ddSIgor Mammedov MachineClass *mc = MACHINE_GET_CLASS(hotplug_dev); 2922ff9006ddSIgor Mammedov Error *local_err = NULL; 2923ff9006ddSIgor Mammedov CPUCore *cc = CPU_CORE(dev); 2924ff9006ddSIgor Mammedov char *base_core_type = spapr_get_cpu_core_type(machine->cpu_model); 2925ff9006ddSIgor Mammedov const char *type = object_get_typename(OBJECT(dev)); 2926535455fdSIgor Mammedov CPUArchId *core_slot; 2927535455fdSIgor Mammedov int index; 2928ff9006ddSIgor Mammedov 2929c5514d0eSIgor Mammedov if (dev->hotplugged && !mc->has_hotpluggable_cpus) { 2930ff9006ddSIgor Mammedov error_setg(&local_err, "CPU hotplug not supported for this machine"); 2931ff9006ddSIgor Mammedov goto out; 2932ff9006ddSIgor Mammedov } 2933ff9006ddSIgor Mammedov 2934ff9006ddSIgor Mammedov if (strcmp(base_core_type, type)) { 2935ff9006ddSIgor Mammedov error_setg(&local_err, "CPU core type should be %s", base_core_type); 2936ff9006ddSIgor Mammedov goto out; 2937ff9006ddSIgor Mammedov } 2938ff9006ddSIgor Mammedov 2939ff9006ddSIgor Mammedov if (cc->core_id % smp_threads) { 2940ff9006ddSIgor Mammedov error_setg(&local_err, "invalid core id %d", cc->core_id); 2941ff9006ddSIgor Mammedov goto out; 2942ff9006ddSIgor Mammedov } 2943ff9006ddSIgor Mammedov 2944459264efSDavid Gibson /* 2945459264efSDavid Gibson * In general we should have homogeneous threads-per-core, but old 2946459264efSDavid Gibson * (pre hotplug support) machine types allow the last core to have 2947459264efSDavid Gibson * reduced threads as a compatibility hack for when we allowed 2948459264efSDavid Gibson * total vcpus not a multiple of threads-per-core. 2949459264efSDavid Gibson */ 2950459264efSDavid Gibson if (mc->has_hotpluggable_cpus && (cc->nr_threads != smp_threads)) { 29518149e299SDavid Gibson error_setg(errp, "invalid nr-threads %d, must be %d", 29528149e299SDavid Gibson cc->nr_threads, smp_threads); 29538149e299SDavid Gibson return; 29548149e299SDavid Gibson } 29558149e299SDavid Gibson 2956535455fdSIgor Mammedov core_slot = spapr_find_cpu_slot(MACHINE(hotplug_dev), cc->core_id, &index); 2957535455fdSIgor Mammedov if (!core_slot) { 2958ff9006ddSIgor Mammedov error_setg(&local_err, "core id %d out of range", cc->core_id); 2959ff9006ddSIgor Mammedov goto out; 2960ff9006ddSIgor Mammedov } 2961ff9006ddSIgor Mammedov 2962535455fdSIgor Mammedov if (core_slot->cpu) { 2963ff9006ddSIgor Mammedov error_setg(&local_err, "core %d already populated", cc->core_id); 2964ff9006ddSIgor Mammedov goto out; 2965ff9006ddSIgor Mammedov } 2966ff9006ddSIgor Mammedov 2967a0ceb640SIgor Mammedov numa_cpu_pre_plug(core_slot, dev, &local_err); 29680b8497f0SIgor Mammedov 2969ff9006ddSIgor Mammedov out: 2970ff9006ddSIgor Mammedov g_free(base_core_type); 2971ff9006ddSIgor Mammedov error_propagate(errp, local_err); 2972ff9006ddSIgor Mammedov } 2973ff9006ddSIgor Mammedov 2974c20d332aSBharata B Rao static void spapr_machine_device_plug(HotplugHandler *hotplug_dev, 2975c20d332aSBharata B Rao DeviceState *dev, Error **errp) 2976c20d332aSBharata B Rao { 2977c20d332aSBharata B Rao sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(qdev_get_machine()); 2978c20d332aSBharata B Rao 2979c20d332aSBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { 2980b556854bSBharata B Rao int node; 2981c20d332aSBharata B Rao 2982c20d332aSBharata B Rao if (!smc->dr_lmb_enabled) { 2983c20d332aSBharata B Rao error_setg(errp, "Memory hotplug not supported for this machine"); 2984c20d332aSBharata B Rao return; 2985c20d332aSBharata B Rao } 2986c20d332aSBharata B Rao node = object_property_get_int(OBJECT(dev), PC_DIMM_NODE_PROP, errp); 2987c20d332aSBharata B Rao if (*errp) { 2988c20d332aSBharata B Rao return; 2989c20d332aSBharata B Rao } 29901a5512bbSGonglei if (node < 0 || node >= MAX_NODES) { 29911a5512bbSGonglei error_setg(errp, "Invaild node %d", node); 29921a5512bbSGonglei return; 29931a5512bbSGonglei } 2994c20d332aSBharata B Rao 2995b556854bSBharata B Rao /* 2996b556854bSBharata B Rao * Currently PowerPC kernel doesn't allow hot-adding memory to 2997b556854bSBharata B Rao * memory-less node, but instead will silently add the memory 2998b556854bSBharata B Rao * to the first node that has some memory. This causes two 2999b556854bSBharata B Rao * unexpected behaviours for the user. 3000b556854bSBharata B Rao * 3001b556854bSBharata B Rao * - Memory gets hotplugged to a different node than what the user 3002b556854bSBharata B Rao * specified. 3003b556854bSBharata B Rao * - Since pc-dimm subsystem in QEMU still thinks that memory belongs 3004b556854bSBharata B Rao * to memory-less node, a reboot will set things accordingly 3005b556854bSBharata B Rao * and the previously hotplugged memory now ends in the right node. 3006b556854bSBharata B Rao * This appears as if some memory moved from one node to another. 3007b556854bSBharata B Rao * 3008b556854bSBharata B Rao * So until kernel starts supporting memory hotplug to memory-less 3009b556854bSBharata B Rao * nodes, just prevent such attempts upfront in QEMU. 3010b556854bSBharata B Rao */ 3011b556854bSBharata B Rao if (nb_numa_nodes && !numa_info[node].node_mem) { 3012b556854bSBharata B Rao error_setg(errp, "Can't hotplug memory to memory-less node %d", 3013b556854bSBharata B Rao node); 3014b556854bSBharata B Rao return; 3015b556854bSBharata B Rao } 3016b556854bSBharata B Rao 3017c20d332aSBharata B Rao spapr_memory_plug(hotplug_dev, dev, node, errp); 3018af81cf32SBharata B Rao } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 3019af81cf32SBharata B Rao spapr_core_plug(hotplug_dev, dev, errp); 3020c20d332aSBharata B Rao } 3021c20d332aSBharata B Rao } 3022c20d332aSBharata B Rao 3023c20d332aSBharata B Rao static void spapr_machine_device_unplug(HotplugHandler *hotplug_dev, 3024c20d332aSBharata B Rao DeviceState *dev, Error **errp) 3025c20d332aSBharata B Rao { 3026cf632463SBharata B Rao sPAPRMachineState *sms = SPAPR_MACHINE(qdev_get_machine()); 30273c0c47e3SDavid Gibson MachineClass *mc = MACHINE_GET_CLASS(qdev_get_machine()); 30286f4b5c3eSBharata B Rao 3029c20d332aSBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { 3030cf632463SBharata B Rao if (spapr_ovec_test(sms->ov5_cas, OV5_HP_EVT)) { 3031cf632463SBharata B Rao spapr_memory_unplug(hotplug_dev, dev, errp); 3032cf632463SBharata B Rao } else { 3033cf632463SBharata B Rao error_setg(errp, "Memory hot unplug not supported for this guest"); 3034cf632463SBharata B Rao } 3035cf632463SBharata B Rao } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 3036c5514d0eSIgor Mammedov if (!mc->has_hotpluggable_cpus) { 3037cf632463SBharata B Rao error_setg(errp, "CPU hot unplug not supported on this machine"); 3038cf632463SBharata B Rao return; 3039cf632463SBharata B Rao } 3040cf632463SBharata B Rao spapr_core_unplug(hotplug_dev, dev, errp); 3041cf632463SBharata B Rao } 3042cf632463SBharata B Rao } 3043cf632463SBharata B Rao 3044cf632463SBharata B Rao static void spapr_machine_device_unplug_request(HotplugHandler *hotplug_dev, 3045cf632463SBharata B Rao DeviceState *dev, Error **errp) 3046cf632463SBharata B Rao { 3047cf632463SBharata B Rao sPAPRMachineState *sms = SPAPR_MACHINE(qdev_get_machine()); 3048cf632463SBharata B Rao MachineClass *mc = MACHINE_GET_CLASS(qdev_get_machine()); 3049cf632463SBharata B Rao 3050cf632463SBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { 3051cf632463SBharata B Rao if (spapr_ovec_test(sms->ov5_cas, OV5_HP_EVT)) { 3052cf632463SBharata B Rao spapr_memory_unplug_request(hotplug_dev, dev, errp); 3053cf632463SBharata B Rao } else { 3054cf632463SBharata B Rao /* NOTE: this means there is a window after guest reset, prior to 3055cf632463SBharata B Rao * CAS negotiation, where unplug requests will fail due to the 3056cf632463SBharata B Rao * capability not being detected yet. This is a bit different than 3057cf632463SBharata B Rao * the case with PCI unplug, where the events will be queued and 3058cf632463SBharata B Rao * eventually handled by the guest after boot 3059cf632463SBharata B Rao */ 3060cf632463SBharata B Rao error_setg(errp, "Memory hot unplug not supported for this guest"); 3061cf632463SBharata B Rao } 30626f4b5c3eSBharata B Rao } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 3063c5514d0eSIgor Mammedov if (!mc->has_hotpluggable_cpus) { 30646f4b5c3eSBharata B Rao error_setg(errp, "CPU hot unplug not supported on this machine"); 30656f4b5c3eSBharata B Rao return; 30666f4b5c3eSBharata B Rao } 3067115debf2SIgor Mammedov spapr_core_unplug_request(hotplug_dev, dev, errp); 3068c20d332aSBharata B Rao } 3069c20d332aSBharata B Rao } 3070c20d332aSBharata B Rao 307194a94e4cSBharata B Rao static void spapr_machine_device_pre_plug(HotplugHandler *hotplug_dev, 307294a94e4cSBharata B Rao DeviceState *dev, Error **errp) 307394a94e4cSBharata B Rao { 3074c871bc70SLaurent Vivier if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { 3075c871bc70SLaurent Vivier spapr_memory_pre_plug(hotplug_dev, dev, errp); 3076c871bc70SLaurent Vivier } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 307794a94e4cSBharata B Rao spapr_core_pre_plug(hotplug_dev, dev, errp); 307894a94e4cSBharata B Rao } 307994a94e4cSBharata B Rao } 308094a94e4cSBharata B Rao 30817ebaf795SBharata B Rao static HotplugHandler *spapr_get_hotplug_handler(MachineState *machine, 3082c20d332aSBharata B Rao DeviceState *dev) 3083c20d332aSBharata B Rao { 308494a94e4cSBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM) || 308594a94e4cSBharata B Rao object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 3086c20d332aSBharata B Rao return HOTPLUG_HANDLER(machine); 3087c20d332aSBharata B Rao } 3088c20d332aSBharata B Rao return NULL; 3089c20d332aSBharata B Rao } 3090c20d332aSBharata B Rao 3091ea089eebSIgor Mammedov static CpuInstanceProperties 3092ea089eebSIgor Mammedov spapr_cpu_index_to_props(MachineState *machine, unsigned cpu_index) 309320bb648dSDavid Gibson { 3094ea089eebSIgor Mammedov CPUArchId *core_slot; 3095ea089eebSIgor Mammedov MachineClass *mc = MACHINE_GET_CLASS(machine); 3096ea089eebSIgor Mammedov 3097ea089eebSIgor Mammedov /* make sure possible_cpu are intialized */ 3098ea089eebSIgor Mammedov mc->possible_cpu_arch_ids(machine); 3099ea089eebSIgor Mammedov /* get CPU core slot containing thread that matches cpu_index */ 3100ea089eebSIgor Mammedov core_slot = spapr_find_cpu_slot(machine, cpu_index, NULL); 3101ea089eebSIgor Mammedov assert(core_slot); 3102ea089eebSIgor Mammedov return core_slot->props; 310320bb648dSDavid Gibson } 310420bb648dSDavid Gibson 3105535455fdSIgor Mammedov static const CPUArchIdList *spapr_possible_cpu_arch_ids(MachineState *machine) 3106535455fdSIgor Mammedov { 3107535455fdSIgor Mammedov int i; 3108535455fdSIgor Mammedov int spapr_max_cores = max_cpus / smp_threads; 3109535455fdSIgor Mammedov MachineClass *mc = MACHINE_GET_CLASS(machine); 3110535455fdSIgor Mammedov 3111c5514d0eSIgor Mammedov if (!mc->has_hotpluggable_cpus) { 3112535455fdSIgor Mammedov spapr_max_cores = QEMU_ALIGN_UP(smp_cpus, smp_threads) / smp_threads; 3113535455fdSIgor Mammedov } 3114535455fdSIgor Mammedov if (machine->possible_cpus) { 3115535455fdSIgor Mammedov assert(machine->possible_cpus->len == spapr_max_cores); 3116535455fdSIgor Mammedov return machine->possible_cpus; 3117535455fdSIgor Mammedov } 3118535455fdSIgor Mammedov 3119535455fdSIgor Mammedov machine->possible_cpus = g_malloc0(sizeof(CPUArchIdList) + 3120535455fdSIgor Mammedov sizeof(CPUArchId) * spapr_max_cores); 3121535455fdSIgor Mammedov machine->possible_cpus->len = spapr_max_cores; 3122535455fdSIgor Mammedov for (i = 0; i < machine->possible_cpus->len; i++) { 3123535455fdSIgor Mammedov int core_id = i * smp_threads; 3124535455fdSIgor Mammedov 3125f2d672c2SIgor Mammedov machine->possible_cpus->cpus[i].vcpus_count = smp_threads; 3126535455fdSIgor Mammedov machine->possible_cpus->cpus[i].arch_id = core_id; 3127535455fdSIgor Mammedov machine->possible_cpus->cpus[i].props.has_core_id = true; 3128535455fdSIgor Mammedov machine->possible_cpus->cpus[i].props.core_id = core_id; 3129ea089eebSIgor Mammedov 3130ea089eebSIgor Mammedov /* default distribution of CPUs over NUMA nodes */ 3131ea089eebSIgor Mammedov if (nb_numa_nodes) { 3132ea089eebSIgor Mammedov /* preset values but do not enable them i.e. 'has_node_id = false', 3133ea089eebSIgor Mammedov * numa init code will enable them later if manual mapping wasn't 3134ea089eebSIgor Mammedov * present on CLI */ 3135ea089eebSIgor Mammedov machine->possible_cpus->cpus[i].props.node_id = 3136ea089eebSIgor Mammedov core_id / smp_threads / smp_cores % nb_numa_nodes; 3137ea089eebSIgor Mammedov } 3138535455fdSIgor Mammedov } 3139535455fdSIgor Mammedov return machine->possible_cpus; 3140535455fdSIgor Mammedov } 3141535455fdSIgor Mammedov 31426737d9adSDavid Gibson static void spapr_phb_placement(sPAPRMachineState *spapr, uint32_t index, 3143daa23699SDavid Gibson uint64_t *buid, hwaddr *pio, 3144daa23699SDavid Gibson hwaddr *mmio32, hwaddr *mmio64, 31456737d9adSDavid Gibson unsigned n_dma, uint32_t *liobns, Error **errp) 31466737d9adSDavid Gibson { 3147357d1e3bSDavid Gibson /* 3148357d1e3bSDavid Gibson * New-style PHB window placement. 3149357d1e3bSDavid Gibson * 3150357d1e3bSDavid Gibson * Goals: Gives large (1TiB), naturally aligned 64-bit MMIO window 3151357d1e3bSDavid Gibson * for each PHB, in addition to 2GiB 32-bit MMIO and 64kiB PIO 3152357d1e3bSDavid Gibson * windows. 3153357d1e3bSDavid Gibson * 3154357d1e3bSDavid Gibson * Some guest kernels can't work with MMIO windows above 1<<46 3155357d1e3bSDavid Gibson * (64TiB), so we place up to 31 PHBs in the area 32TiB..64TiB 3156357d1e3bSDavid Gibson * 3157357d1e3bSDavid Gibson * 32TiB..(33TiB+1984kiB) contains the 64kiB PIO windows for each 3158357d1e3bSDavid Gibson * PHB stacked together. (32TiB+2GiB)..(32TiB+64GiB) contains the 3159357d1e3bSDavid Gibson * 2GiB 32-bit MMIO windows for each PHB. Then 33..64TiB has the 3160357d1e3bSDavid Gibson * 1TiB 64-bit MMIO windows for each PHB. 3161357d1e3bSDavid Gibson */ 31626737d9adSDavid Gibson const uint64_t base_buid = 0x800000020000000ULL; 316325e6a118SMichael S. Tsirkin #define SPAPR_MAX_PHBS ((SPAPR_PCI_LIMIT - SPAPR_PCI_BASE) / \ 316425e6a118SMichael S. Tsirkin SPAPR_PCI_MEM64_WIN_SIZE - 1) 31656737d9adSDavid Gibson int i; 31666737d9adSDavid Gibson 3167357d1e3bSDavid Gibson /* Sanity check natural alignments */ 3168357d1e3bSDavid Gibson QEMU_BUILD_BUG_ON((SPAPR_PCI_BASE % SPAPR_PCI_MEM64_WIN_SIZE) != 0); 3169357d1e3bSDavid Gibson QEMU_BUILD_BUG_ON((SPAPR_PCI_LIMIT % SPAPR_PCI_MEM64_WIN_SIZE) != 0); 3170357d1e3bSDavid Gibson QEMU_BUILD_BUG_ON((SPAPR_PCI_MEM64_WIN_SIZE % SPAPR_PCI_MEM32_WIN_SIZE) != 0); 3171357d1e3bSDavid Gibson QEMU_BUILD_BUG_ON((SPAPR_PCI_MEM32_WIN_SIZE % SPAPR_PCI_IO_WIN_SIZE) != 0); 3172357d1e3bSDavid Gibson /* Sanity check bounds */ 317325e6a118SMichael S. Tsirkin QEMU_BUILD_BUG_ON((SPAPR_MAX_PHBS * SPAPR_PCI_IO_WIN_SIZE) > 317425e6a118SMichael S. Tsirkin SPAPR_PCI_MEM32_WIN_SIZE); 317525e6a118SMichael S. Tsirkin QEMU_BUILD_BUG_ON((SPAPR_MAX_PHBS * SPAPR_PCI_MEM32_WIN_SIZE) > 317625e6a118SMichael S. Tsirkin SPAPR_PCI_MEM64_WIN_SIZE); 31772efff1c0SDavid Gibson 317825e6a118SMichael S. Tsirkin if (index >= SPAPR_MAX_PHBS) { 317925e6a118SMichael S. Tsirkin error_setg(errp, "\"index\" for PAPR PHB is too large (max %llu)", 318025e6a118SMichael S. Tsirkin SPAPR_MAX_PHBS - 1); 31816737d9adSDavid Gibson return; 31826737d9adSDavid Gibson } 31836737d9adSDavid Gibson 31846737d9adSDavid Gibson *buid = base_buid + index; 31856737d9adSDavid Gibson for (i = 0; i < n_dma; ++i) { 31866737d9adSDavid Gibson liobns[i] = SPAPR_PCI_LIOBN(index, i); 31876737d9adSDavid Gibson } 31886737d9adSDavid Gibson 3189357d1e3bSDavid Gibson *pio = SPAPR_PCI_BASE + index * SPAPR_PCI_IO_WIN_SIZE; 3190357d1e3bSDavid Gibson *mmio32 = SPAPR_PCI_BASE + (index + 1) * SPAPR_PCI_MEM32_WIN_SIZE; 3191357d1e3bSDavid Gibson *mmio64 = SPAPR_PCI_BASE + (index + 1) * SPAPR_PCI_MEM64_WIN_SIZE; 31926737d9adSDavid Gibson } 31936737d9adSDavid Gibson 31947844e12bSCédric Le Goater static ICSState *spapr_ics_get(XICSFabric *dev, int irq) 31957844e12bSCédric Le Goater { 31967844e12bSCédric Le Goater sPAPRMachineState *spapr = SPAPR_MACHINE(dev); 31977844e12bSCédric Le Goater 31987844e12bSCédric Le Goater return ics_valid_irq(spapr->ics, irq) ? spapr->ics : NULL; 31997844e12bSCédric Le Goater } 32007844e12bSCédric Le Goater 32017844e12bSCédric Le Goater static void spapr_ics_resend(XICSFabric *dev) 32027844e12bSCédric Le Goater { 32037844e12bSCédric Le Goater sPAPRMachineState *spapr = SPAPR_MACHINE(dev); 32047844e12bSCédric Le Goater 32057844e12bSCédric Le Goater ics_resend(spapr->ics); 32067844e12bSCédric Le Goater } 32077844e12bSCédric Le Goater 320806747ba6SCédric Le Goater static ICPState *spapr_icp_get(XICSFabric *xi, int cpu_dt_id) 3209b2fc59aaSCédric Le Goater { 32105bc8d26dSCédric Le Goater PowerPCCPU *cpu = ppc_get_vcpu_by_dt_id(cpu_dt_id); 3211b2fc59aaSCédric Le Goater 32125bc8d26dSCédric Le Goater return cpu ? ICP(cpu->intc) : NULL; 3213b2fc59aaSCédric Le Goater } 3214b2fc59aaSCédric Le Goater 32156449da45SCédric Le Goater static void spapr_pic_print_info(InterruptStatsProvider *obj, 32166449da45SCédric Le Goater Monitor *mon) 32176449da45SCédric Le Goater { 32186449da45SCédric Le Goater sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 32195bc8d26dSCédric Le Goater CPUState *cs; 32206449da45SCédric Le Goater 32215bc8d26dSCédric Le Goater CPU_FOREACH(cs) { 32225bc8d26dSCédric Le Goater PowerPCCPU *cpu = POWERPC_CPU(cs); 32235bc8d26dSCédric Le Goater 32245bc8d26dSCédric Le Goater icp_pic_print_info(ICP(cpu->intc), mon); 32256449da45SCédric Le Goater } 32266449da45SCédric Le Goater 32276449da45SCédric Le Goater ics_pic_print_info(spapr->ics, mon); 32286449da45SCédric Le Goater } 32296449da45SCédric Le Goater 323029ee3247SAlexey Kardashevskiy static void spapr_machine_class_init(ObjectClass *oc, void *data) 323153018216SPaolo Bonzini { 323229ee3247SAlexey Kardashevskiy MachineClass *mc = MACHINE_CLASS(oc); 3233224245bfSDavid Gibson sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(oc); 323471461b0fSAlexey Kardashevskiy FWPathProviderClass *fwc = FW_PATH_PROVIDER_CLASS(oc); 323534316482SAlexey Kardashevskiy NMIClass *nc = NMI_CLASS(oc); 3236c20d332aSBharata B Rao HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(oc); 32371d1be34dSDavid Gibson PPCVirtualHypervisorClass *vhc = PPC_VIRTUAL_HYPERVISOR_CLASS(oc); 32387844e12bSCédric Le Goater XICSFabricClass *xic = XICS_FABRIC_CLASS(oc); 32396449da45SCédric Le Goater InterruptStatsProviderClass *ispc = INTERRUPT_STATS_PROVIDER_CLASS(oc); 324029ee3247SAlexey Kardashevskiy 32410eb9054cSDavid Gibson mc->desc = "pSeries Logical Partition (PAPR compliant)"; 3242fc9f38c3SDavid Gibson 3243fc9f38c3SDavid Gibson /* 3244fc9f38c3SDavid Gibson * We set up the default / latest behaviour here. The class_init 3245fc9f38c3SDavid Gibson * functions for the specific versioned machine types can override 3246fc9f38c3SDavid Gibson * these details for backwards compatibility 3247fc9f38c3SDavid Gibson */ 3248958db90cSMarcel Apfelbaum mc->init = ppc_spapr_init; 3249958db90cSMarcel Apfelbaum mc->reset = ppc_spapr_reset; 3250958db90cSMarcel Apfelbaum mc->block_default_type = IF_SCSI; 32516244bb7eSGreg Kurz mc->max_cpus = 1024; 3252958db90cSMarcel Apfelbaum mc->no_parallel = 1; 32535b2128d2SAlexander Graf mc->default_boot_order = ""; 3254a34944feSNikunj A Dadhania mc->default_ram_size = 512 * M_BYTE; 3255958db90cSMarcel Apfelbaum mc->kvm_type = spapr_kvm_type; 32569e3f9733SAlexander Graf mc->has_dynamic_sysbus = true; 3257e4024630SLaurent Vivier mc->pci_allow_0_address = true; 32587ebaf795SBharata B Rao mc->get_hotplug_handler = spapr_get_hotplug_handler; 325994a94e4cSBharata B Rao hc->pre_plug = spapr_machine_device_pre_plug; 3260c20d332aSBharata B Rao hc->plug = spapr_machine_device_plug; 3261c20d332aSBharata B Rao hc->unplug = spapr_machine_device_unplug; 3262ea089eebSIgor Mammedov mc->cpu_index_to_instance_props = spapr_cpu_index_to_props; 3263535455fdSIgor Mammedov mc->possible_cpu_arch_ids = spapr_possible_cpu_arch_ids; 3264cf632463SBharata B Rao hc->unplug_request = spapr_machine_device_unplug_request; 326500b4fbe2SMarcel Apfelbaum 3266fc9f38c3SDavid Gibson smc->dr_lmb_enabled = true; 32673daa4a9fSThomas Huth smc->tcg_default_cpu = "POWER8"; 3268c5514d0eSIgor Mammedov mc->has_hotpluggable_cpus = true; 326971461b0fSAlexey Kardashevskiy fwc->get_dev_path = spapr_get_fw_dev_path; 327034316482SAlexey Kardashevskiy nc->nmi_monitor_handler = spapr_nmi; 32716737d9adSDavid Gibson smc->phb_placement = spapr_phb_placement; 32721d1be34dSDavid Gibson vhc->hypercall = emulate_spapr_hypercall; 3273e57ca75cSDavid Gibson vhc->hpt_mask = spapr_hpt_mask; 3274e57ca75cSDavid Gibson vhc->map_hptes = spapr_map_hptes; 3275e57ca75cSDavid Gibson vhc->unmap_hptes = spapr_unmap_hptes; 3276e57ca75cSDavid Gibson vhc->store_hpte = spapr_store_hpte; 32779861bb3eSSuraj Jitindar Singh vhc->get_patbe = spapr_get_patbe; 32787844e12bSCédric Le Goater xic->ics_get = spapr_ics_get; 32797844e12bSCédric Le Goater xic->ics_resend = spapr_ics_resend; 3280b2fc59aaSCédric Le Goater xic->icp_get = spapr_icp_get; 32816449da45SCédric Le Goater ispc->print_info = spapr_pic_print_info; 328255641213SLaurent Vivier /* Force NUMA node memory size to be a multiple of 328355641213SLaurent Vivier * SPAPR_MEMORY_BLOCK_SIZE (256M) since that's the granularity 328455641213SLaurent Vivier * in which LMBs are represented and hot-added 328555641213SLaurent Vivier */ 328655641213SLaurent Vivier mc->numa_mem_align_shift = 28; 328753018216SPaolo Bonzini } 328853018216SPaolo Bonzini 328929ee3247SAlexey Kardashevskiy static const TypeInfo spapr_machine_info = { 329029ee3247SAlexey Kardashevskiy .name = TYPE_SPAPR_MACHINE, 329129ee3247SAlexey Kardashevskiy .parent = TYPE_MACHINE, 32924aee7362SDavid Gibson .abstract = true, 32936ca1502eSAlexey Kardashevskiy .instance_size = sizeof(sPAPRMachineState), 329423825581SEduardo Habkost .instance_init = spapr_machine_initfn, 329587bbdd9cSDavid Gibson .instance_finalize = spapr_machine_finalizefn, 3296183930c0SDavid Gibson .class_size = sizeof(sPAPRMachineClass), 329729ee3247SAlexey Kardashevskiy .class_init = spapr_machine_class_init, 329871461b0fSAlexey Kardashevskiy .interfaces = (InterfaceInfo[]) { 329971461b0fSAlexey Kardashevskiy { TYPE_FW_PATH_PROVIDER }, 330034316482SAlexey Kardashevskiy { TYPE_NMI }, 3301c20d332aSBharata B Rao { TYPE_HOTPLUG_HANDLER }, 33021d1be34dSDavid Gibson { TYPE_PPC_VIRTUAL_HYPERVISOR }, 33037844e12bSCédric Le Goater { TYPE_XICS_FABRIC }, 33046449da45SCédric Le Goater { TYPE_INTERRUPT_STATS_PROVIDER }, 330571461b0fSAlexey Kardashevskiy { } 330671461b0fSAlexey Kardashevskiy }, 330729ee3247SAlexey Kardashevskiy }; 330829ee3247SAlexey Kardashevskiy 3309fccbc785SDavid Gibson #define DEFINE_SPAPR_MACHINE(suffix, verstr, latest) \ 33105013c547SDavid Gibson static void spapr_machine_##suffix##_class_init(ObjectClass *oc, \ 33115013c547SDavid Gibson void *data) \ 33125013c547SDavid Gibson { \ 33135013c547SDavid Gibson MachineClass *mc = MACHINE_CLASS(oc); \ 33145013c547SDavid Gibson spapr_machine_##suffix##_class_options(mc); \ 3315fccbc785SDavid Gibson if (latest) { \ 3316fccbc785SDavid Gibson mc->alias = "pseries"; \ 3317fccbc785SDavid Gibson mc->is_default = 1; \ 3318fccbc785SDavid Gibson } \ 33195013c547SDavid Gibson } \ 33205013c547SDavid Gibson static void spapr_machine_##suffix##_instance_init(Object *obj) \ 33215013c547SDavid Gibson { \ 33225013c547SDavid Gibson MachineState *machine = MACHINE(obj); \ 33235013c547SDavid Gibson spapr_machine_##suffix##_instance_options(machine); \ 33245013c547SDavid Gibson } \ 33255013c547SDavid Gibson static const TypeInfo spapr_machine_##suffix##_info = { \ 33265013c547SDavid Gibson .name = MACHINE_TYPE_NAME("pseries-" verstr), \ 33275013c547SDavid Gibson .parent = TYPE_SPAPR_MACHINE, \ 33285013c547SDavid Gibson .class_init = spapr_machine_##suffix##_class_init, \ 33295013c547SDavid Gibson .instance_init = spapr_machine_##suffix##_instance_init, \ 33305013c547SDavid Gibson }; \ 33315013c547SDavid Gibson static void spapr_machine_register_##suffix(void) \ 33325013c547SDavid Gibson { \ 33335013c547SDavid Gibson type_register(&spapr_machine_##suffix##_info); \ 33345013c547SDavid Gibson } \ 33350e6aac87SEduardo Habkost type_init(spapr_machine_register_##suffix) 33365013c547SDavid Gibson 33371c5f29bbSDavid Gibson /* 33383fa14fbeSDavid Gibson * pseries-2.10 3339db800b21SDavid Gibson */ 33403fa14fbeSDavid Gibson static void spapr_machine_2_10_instance_options(MachineState *machine) 3341db800b21SDavid Gibson { 3342db800b21SDavid Gibson } 3343db800b21SDavid Gibson 33443fa14fbeSDavid Gibson static void spapr_machine_2_10_class_options(MachineClass *mc) 3345db800b21SDavid Gibson { 3346db800b21SDavid Gibson /* Defaults for the latest behaviour inherited from the base class */ 3347db800b21SDavid Gibson } 3348db800b21SDavid Gibson 33493fa14fbeSDavid Gibson DEFINE_SPAPR_MACHINE(2_10, "2.10", true); 33503fa14fbeSDavid Gibson 33513fa14fbeSDavid Gibson /* 33523fa14fbeSDavid Gibson * pseries-2.9 33533fa14fbeSDavid Gibson */ 33543fa14fbeSDavid Gibson #define SPAPR_COMPAT_2_9 \ 33553fa14fbeSDavid Gibson HW_COMPAT_2_9 33563fa14fbeSDavid Gibson 33573fa14fbeSDavid Gibson static void spapr_machine_2_9_instance_options(MachineState *machine) 33583fa14fbeSDavid Gibson { 33593fa14fbeSDavid Gibson spapr_machine_2_10_instance_options(machine); 33603fa14fbeSDavid Gibson } 33613fa14fbeSDavid Gibson 33623fa14fbeSDavid Gibson static void spapr_machine_2_9_class_options(MachineClass *mc) 33633fa14fbeSDavid Gibson { 33643fa14fbeSDavid Gibson spapr_machine_2_10_class_options(mc); 33653fa14fbeSDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_9); 33663bfe5716SLaurent Vivier mc->numa_auto_assign_ram = numa_legacy_auto_assign_ram; 33673fa14fbeSDavid Gibson } 33683fa14fbeSDavid Gibson 33693fa14fbeSDavid Gibson DEFINE_SPAPR_MACHINE(2_9, "2.9", false); 3370fa325e6cSDavid Gibson 3371fa325e6cSDavid Gibson /* 3372fa325e6cSDavid Gibson * pseries-2.8 3373fa325e6cSDavid Gibson */ 3374fa325e6cSDavid Gibson #define SPAPR_COMPAT_2_8 \ 337582516263SDavid Gibson HW_COMPAT_2_8 \ 337682516263SDavid Gibson { \ 337782516263SDavid Gibson .driver = TYPE_SPAPR_PCI_HOST_BRIDGE, \ 337882516263SDavid Gibson .property = "pcie-extended-configuration-space", \ 337982516263SDavid Gibson .value = "off", \ 338082516263SDavid Gibson }, 3381fa325e6cSDavid Gibson 3382fa325e6cSDavid Gibson static void spapr_machine_2_8_instance_options(MachineState *machine) 3383fa325e6cSDavid Gibson { 3384fa325e6cSDavid Gibson spapr_machine_2_9_instance_options(machine); 3385fa325e6cSDavid Gibson } 3386fa325e6cSDavid Gibson 3387fa325e6cSDavid Gibson static void spapr_machine_2_8_class_options(MachineClass *mc) 3388fa325e6cSDavid Gibson { 3389fa325e6cSDavid Gibson spapr_machine_2_9_class_options(mc); 3390fa325e6cSDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_8); 339155641213SLaurent Vivier mc->numa_mem_align_shift = 23; 3392fa325e6cSDavid Gibson } 3393fa325e6cSDavid Gibson 3394fa325e6cSDavid Gibson DEFINE_SPAPR_MACHINE(2_8, "2.8", false); 3395db800b21SDavid Gibson 3396db800b21SDavid Gibson /* 33971ea1eefcSBharata B Rao * pseries-2.7 33981ea1eefcSBharata B Rao */ 3399db800b21SDavid Gibson #define SPAPR_COMPAT_2_7 \ 3400db800b21SDavid Gibson HW_COMPAT_2_7 \ 3401357d1e3bSDavid Gibson { \ 3402357d1e3bSDavid Gibson .driver = TYPE_SPAPR_PCI_HOST_BRIDGE, \ 3403357d1e3bSDavid Gibson .property = "mem_win_size", \ 3404357d1e3bSDavid Gibson .value = stringify(SPAPR_PCI_2_7_MMIO_WIN_SIZE),\ 3405357d1e3bSDavid Gibson }, \ 3406357d1e3bSDavid Gibson { \ 3407357d1e3bSDavid Gibson .driver = TYPE_SPAPR_PCI_HOST_BRIDGE, \ 3408357d1e3bSDavid Gibson .property = "mem64_win_size", \ 3409357d1e3bSDavid Gibson .value = "0", \ 3410146c11f1SDavid Gibson }, \ 3411146c11f1SDavid Gibson { \ 3412146c11f1SDavid Gibson .driver = TYPE_POWERPC_CPU, \ 3413146c11f1SDavid Gibson .property = "pre-2.8-migration", \ 3414146c11f1SDavid Gibson .value = "on", \ 34155c4537bdSDavid Gibson }, \ 34165c4537bdSDavid Gibson { \ 34175c4537bdSDavid Gibson .driver = TYPE_SPAPR_PCI_HOST_BRIDGE, \ 34185c4537bdSDavid Gibson .property = "pre-2.8-migration", \ 34195c4537bdSDavid Gibson .value = "on", \ 3420357d1e3bSDavid Gibson }, 3421357d1e3bSDavid Gibson 3422357d1e3bSDavid Gibson static void phb_placement_2_7(sPAPRMachineState *spapr, uint32_t index, 3423357d1e3bSDavid Gibson uint64_t *buid, hwaddr *pio, 3424357d1e3bSDavid Gibson hwaddr *mmio32, hwaddr *mmio64, 3425357d1e3bSDavid Gibson unsigned n_dma, uint32_t *liobns, Error **errp) 3426357d1e3bSDavid Gibson { 3427357d1e3bSDavid Gibson /* Legacy PHB placement for pseries-2.7 and earlier machine types */ 3428357d1e3bSDavid Gibson const uint64_t base_buid = 0x800000020000000ULL; 3429357d1e3bSDavid Gibson const hwaddr phb_spacing = 0x1000000000ULL; /* 64 GiB */ 3430357d1e3bSDavid Gibson const hwaddr mmio_offset = 0xa0000000; /* 2 GiB + 512 MiB */ 3431357d1e3bSDavid Gibson const hwaddr pio_offset = 0x80000000; /* 2 GiB */ 3432357d1e3bSDavid Gibson const uint32_t max_index = 255; 3433357d1e3bSDavid Gibson const hwaddr phb0_alignment = 0x10000000000ULL; /* 1 TiB */ 3434357d1e3bSDavid Gibson 3435357d1e3bSDavid Gibson uint64_t ram_top = MACHINE(spapr)->ram_size; 3436357d1e3bSDavid Gibson hwaddr phb0_base, phb_base; 3437357d1e3bSDavid Gibson int i; 3438357d1e3bSDavid Gibson 3439357d1e3bSDavid Gibson /* Do we have hotpluggable memory? */ 3440357d1e3bSDavid Gibson if (MACHINE(spapr)->maxram_size > ram_top) { 3441357d1e3bSDavid Gibson /* Can't just use maxram_size, because there may be an 3442357d1e3bSDavid Gibson * alignment gap between normal and hotpluggable memory 3443357d1e3bSDavid Gibson * regions */ 3444357d1e3bSDavid Gibson ram_top = spapr->hotplug_memory.base + 3445357d1e3bSDavid Gibson memory_region_size(&spapr->hotplug_memory.mr); 3446357d1e3bSDavid Gibson } 3447357d1e3bSDavid Gibson 3448357d1e3bSDavid Gibson phb0_base = QEMU_ALIGN_UP(ram_top, phb0_alignment); 3449357d1e3bSDavid Gibson 3450357d1e3bSDavid Gibson if (index > max_index) { 3451357d1e3bSDavid Gibson error_setg(errp, "\"index\" for PAPR PHB is too large (max %u)", 3452357d1e3bSDavid Gibson max_index); 3453357d1e3bSDavid Gibson return; 3454357d1e3bSDavid Gibson } 3455357d1e3bSDavid Gibson 3456357d1e3bSDavid Gibson *buid = base_buid + index; 3457357d1e3bSDavid Gibson for (i = 0; i < n_dma; ++i) { 3458357d1e3bSDavid Gibson liobns[i] = SPAPR_PCI_LIOBN(index, i); 3459357d1e3bSDavid Gibson } 3460357d1e3bSDavid Gibson 3461357d1e3bSDavid Gibson phb_base = phb0_base + index * phb_spacing; 3462357d1e3bSDavid Gibson *pio = phb_base + pio_offset; 3463357d1e3bSDavid Gibson *mmio32 = phb_base + mmio_offset; 3464357d1e3bSDavid Gibson /* 3465357d1e3bSDavid Gibson * We don't set the 64-bit MMIO window, relying on the PHB's 3466357d1e3bSDavid Gibson * fallback behaviour of automatically splitting a large "32-bit" 3467357d1e3bSDavid Gibson * window into contiguous 32-bit and 64-bit windows 3468357d1e3bSDavid Gibson */ 3469357d1e3bSDavid Gibson } 3470db800b21SDavid Gibson 34711ea1eefcSBharata B Rao static void spapr_machine_2_7_instance_options(MachineState *machine) 34721ea1eefcSBharata B Rao { 3473f6229214SMichael Roth sPAPRMachineState *spapr = SPAPR_MACHINE(machine); 3474f6229214SMichael Roth 3475672de881SMichael Roth spapr_machine_2_8_instance_options(machine); 3476f6229214SMichael Roth spapr->use_hotplug_event_source = false; 34771ea1eefcSBharata B Rao } 34781ea1eefcSBharata B Rao 34791ea1eefcSBharata B Rao static void spapr_machine_2_7_class_options(MachineClass *mc) 34801ea1eefcSBharata B Rao { 34813daa4a9fSThomas Huth sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); 34823daa4a9fSThomas Huth 3483db800b21SDavid Gibson spapr_machine_2_8_class_options(mc); 34843daa4a9fSThomas Huth smc->tcg_default_cpu = "POWER7"; 3485db800b21SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_7); 3486357d1e3bSDavid Gibson smc->phb_placement = phb_placement_2_7; 34871ea1eefcSBharata B Rao } 34881ea1eefcSBharata B Rao 3489db800b21SDavid Gibson DEFINE_SPAPR_MACHINE(2_7, "2.7", false); 34901ea1eefcSBharata B Rao 34911ea1eefcSBharata B Rao /* 34924b23699cSDavid Gibson * pseries-2.6 34934b23699cSDavid Gibson */ 34941ea1eefcSBharata B Rao #define SPAPR_COMPAT_2_6 \ 3495ae4de14cSAlexey Kardashevskiy HW_COMPAT_2_6 \ 3496ae4de14cSAlexey Kardashevskiy { \ 3497ae4de14cSAlexey Kardashevskiy .driver = TYPE_SPAPR_PCI_HOST_BRIDGE,\ 3498ae4de14cSAlexey Kardashevskiy .property = "ddw",\ 3499ae4de14cSAlexey Kardashevskiy .value = stringify(off),\ 3500ae4de14cSAlexey Kardashevskiy }, 35011ea1eefcSBharata B Rao 35024b23699cSDavid Gibson static void spapr_machine_2_6_instance_options(MachineState *machine) 35034b23699cSDavid Gibson { 3504672de881SMichael Roth spapr_machine_2_7_instance_options(machine); 35054b23699cSDavid Gibson } 35064b23699cSDavid Gibson 35074b23699cSDavid Gibson static void spapr_machine_2_6_class_options(MachineClass *mc) 35084b23699cSDavid Gibson { 35091ea1eefcSBharata B Rao spapr_machine_2_7_class_options(mc); 3510c5514d0eSIgor Mammedov mc->has_hotpluggable_cpus = false; 35111ea1eefcSBharata B Rao SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_6); 35124b23699cSDavid Gibson } 35134b23699cSDavid Gibson 35141ea1eefcSBharata B Rao DEFINE_SPAPR_MACHINE(2_6, "2.6", false); 35154b23699cSDavid Gibson 35164b23699cSDavid Gibson /* 35171c5f29bbSDavid Gibson * pseries-2.5 35181c5f29bbSDavid Gibson */ 35194b23699cSDavid Gibson #define SPAPR_COMPAT_2_5 \ 352057c522f4SThomas Huth HW_COMPAT_2_5 \ 352157c522f4SThomas Huth { \ 352257c522f4SThomas Huth .driver = "spapr-vlan", \ 352357c522f4SThomas Huth .property = "use-rx-buffer-pools", \ 352457c522f4SThomas Huth .value = "off", \ 352557c522f4SThomas Huth }, 35264b23699cSDavid Gibson 35275013c547SDavid Gibson static void spapr_machine_2_5_instance_options(MachineState *machine) 35281c5f29bbSDavid Gibson { 3529672de881SMichael Roth spapr_machine_2_6_instance_options(machine); 35305013c547SDavid Gibson } 35315013c547SDavid Gibson 35325013c547SDavid Gibson static void spapr_machine_2_5_class_options(MachineClass *mc) 35335013c547SDavid Gibson { 353457040d45SThomas Huth sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); 353557040d45SThomas Huth 35364b23699cSDavid Gibson spapr_machine_2_6_class_options(mc); 353757040d45SThomas Huth smc->use_ohci_by_default = true; 35384b23699cSDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_5); 35391c5f29bbSDavid Gibson } 35401c5f29bbSDavid Gibson 35414b23699cSDavid Gibson DEFINE_SPAPR_MACHINE(2_5, "2.5", false); 35421c5f29bbSDavid Gibson 35431c5f29bbSDavid Gibson /* 35441c5f29bbSDavid Gibson * pseries-2.4 35451c5f29bbSDavid Gibson */ 354680fd50f9SCornelia Huck #define SPAPR_COMPAT_2_4 \ 354780fd50f9SCornelia Huck HW_COMPAT_2_4 354880fd50f9SCornelia Huck 35495013c547SDavid Gibson static void spapr_machine_2_4_instance_options(MachineState *machine) 35501c5f29bbSDavid Gibson { 35515013c547SDavid Gibson spapr_machine_2_5_instance_options(machine); 35525013c547SDavid Gibson } 35531c5f29bbSDavid Gibson 35545013c547SDavid Gibson static void spapr_machine_2_4_class_options(MachineClass *mc) 35555013c547SDavid Gibson { 3556fc9f38c3SDavid Gibson sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); 3557fc9f38c3SDavid Gibson 3558fc9f38c3SDavid Gibson spapr_machine_2_5_class_options(mc); 3559fc9f38c3SDavid Gibson smc->dr_lmb_enabled = false; 3560f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_4); 35611c5f29bbSDavid Gibson } 35621c5f29bbSDavid Gibson 3563fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_4, "2.4", false); 35641c5f29bbSDavid Gibson 35651c5f29bbSDavid Gibson /* 35661c5f29bbSDavid Gibson * pseries-2.3 35671c5f29bbSDavid Gibson */ 356838ff32c6SEduardo Habkost #define SPAPR_COMPAT_2_3 \ 35697619c7b0SMichael Roth HW_COMPAT_2_3 \ 35707619c7b0SMichael Roth {\ 35717619c7b0SMichael Roth .driver = "spapr-pci-host-bridge",\ 35727619c7b0SMichael Roth .property = "dynamic-reconfiguration",\ 35737619c7b0SMichael Roth .value = "off",\ 35747619c7b0SMichael Roth }, 357538ff32c6SEduardo Habkost 35765013c547SDavid Gibson static void spapr_machine_2_3_instance_options(MachineState *machine) 35771c5f29bbSDavid Gibson { 35785013c547SDavid Gibson spapr_machine_2_4_instance_options(machine); 35791c5f29bbSDavid Gibson savevm_skip_section_footers(); 35801c5f29bbSDavid Gibson global_state_set_optional(); 358109b5e30dSGreg Kurz savevm_skip_configuration(); 35821c5f29bbSDavid Gibson } 35831c5f29bbSDavid Gibson 35845013c547SDavid Gibson static void spapr_machine_2_3_class_options(MachineClass *mc) 35851c5f29bbSDavid Gibson { 3586fc9f38c3SDavid Gibson spapr_machine_2_4_class_options(mc); 3587f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_3); 35881c5f29bbSDavid Gibson } 3589fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_3, "2.3", false); 35901c5f29bbSDavid Gibson 35911c5f29bbSDavid Gibson /* 35921c5f29bbSDavid Gibson * pseries-2.2 35931c5f29bbSDavid Gibson */ 35941c5f29bbSDavid Gibson 3595b194df47SAlexey Kardashevskiy #define SPAPR_COMPAT_2_2 \ 35964dfd8eaaSEduardo Habkost HW_COMPAT_2_2 \ 3597b194df47SAlexey Kardashevskiy {\ 3598b194df47SAlexey Kardashevskiy .driver = TYPE_SPAPR_PCI_HOST_BRIDGE,\ 3599b194df47SAlexey Kardashevskiy .property = "mem_win_size",\ 3600b194df47SAlexey Kardashevskiy .value = "0x20000000",\ 3601dd754bafSEduardo Habkost }, 3602b194df47SAlexey Kardashevskiy 36035013c547SDavid Gibson static void spapr_machine_2_2_instance_options(MachineState *machine) 3604b0e966d0SJason Wang { 36055013c547SDavid Gibson spapr_machine_2_3_instance_options(machine); 3606cba0e779SGreg Kurz machine->suppress_vmdesc = true; 3607b0e966d0SJason Wang } 3608b0e966d0SJason Wang 36095013c547SDavid Gibson static void spapr_machine_2_2_class_options(MachineClass *mc) 3610b0e966d0SJason Wang { 3611fc9f38c3SDavid Gibson spapr_machine_2_3_class_options(mc); 3612f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_2); 36131c5f29bbSDavid Gibson } 3614fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_2, "2.2", false); 36151c5f29bbSDavid Gibson 36161c5f29bbSDavid Gibson /* 36171c5f29bbSDavid Gibson * pseries-2.1 36181c5f29bbSDavid Gibson */ 36191c5f29bbSDavid Gibson #define SPAPR_COMPAT_2_1 \ 36201c5f29bbSDavid Gibson HW_COMPAT_2_1 36211c5f29bbSDavid Gibson 36225013c547SDavid Gibson static void spapr_machine_2_1_instance_options(MachineState *machine) 36231c5f29bbSDavid Gibson { 36245013c547SDavid Gibson spapr_machine_2_2_instance_options(machine); 36251c5f29bbSDavid Gibson } 36261c5f29bbSDavid Gibson 36275013c547SDavid Gibson static void spapr_machine_2_1_class_options(MachineClass *mc) 3628b0e966d0SJason Wang { 3629fc9f38c3SDavid Gibson spapr_machine_2_2_class_options(mc); 3630f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_1); 36316026db45SAlexey Kardashevskiy } 3632fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_1, "2.1", false); 36336026db45SAlexey Kardashevskiy 363429ee3247SAlexey Kardashevskiy static void spapr_machine_register_types(void) 363529ee3247SAlexey Kardashevskiy { 363629ee3247SAlexey Kardashevskiy type_register_static(&spapr_machine_info); 363729ee3247SAlexey Kardashevskiy } 363829ee3247SAlexey Kardashevskiy 363929ee3247SAlexey Kardashevskiy type_init(spapr_machine_register_types) 3640