153018216SPaolo Bonzini /* 253018216SPaolo Bonzini * QEMU PowerPC pSeries Logical Partition (aka sPAPR) hardware System Emulator 353018216SPaolo Bonzini * 453018216SPaolo Bonzini * Copyright (c) 2004-2007 Fabrice Bellard 553018216SPaolo Bonzini * Copyright (c) 2007 Jocelyn Mayer 653018216SPaolo Bonzini * Copyright (c) 2010 David Gibson, IBM Corporation. 753018216SPaolo Bonzini * 853018216SPaolo Bonzini * Permission is hereby granted, free of charge, to any person obtaining a copy 953018216SPaolo Bonzini * of this software and associated documentation files (the "Software"), to deal 1053018216SPaolo Bonzini * in the Software without restriction, including without limitation the rights 1153018216SPaolo Bonzini * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 1253018216SPaolo Bonzini * copies of the Software, and to permit persons to whom the Software is 1353018216SPaolo Bonzini * furnished to do so, subject to the following conditions: 1453018216SPaolo Bonzini * 1553018216SPaolo Bonzini * The above copyright notice and this permission notice shall be included in 1653018216SPaolo Bonzini * all copies or substantial portions of the Software. 1753018216SPaolo Bonzini * 1853018216SPaolo Bonzini * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 1953018216SPaolo Bonzini * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 2053018216SPaolo Bonzini * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 2153018216SPaolo Bonzini * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 2253018216SPaolo Bonzini * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 2353018216SPaolo Bonzini * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 2453018216SPaolo Bonzini * THE SOFTWARE. 2553018216SPaolo Bonzini * 2653018216SPaolo Bonzini */ 270d75590dSPeter Maydell #include "qemu/osdep.h" 28da34e65cSMarkus Armbruster #include "qapi/error.h" 2953018216SPaolo Bonzini #include "sysemu/sysemu.h" 30e35704baSEduardo Habkost #include "sysemu/numa.h" 3153018216SPaolo Bonzini #include "hw/hw.h" 3203dd024fSPaolo Bonzini #include "qemu/log.h" 3371461b0fSAlexey Kardashevskiy #include "hw/fw-path-provider.h" 3453018216SPaolo Bonzini #include "elf.h" 3553018216SPaolo Bonzini #include "net/net.h" 36ad440b4aSAndrew Jones #include "sysemu/device_tree.h" 37fa1d36dfSMarkus Armbruster #include "sysemu/block-backend.h" 3853018216SPaolo Bonzini #include "sysemu/cpus.h" 39b3946626SVincent Palatin #include "sysemu/hw_accel.h" 4053018216SPaolo Bonzini #include "kvm_ppc.h" 41ff14e817SDr. David Alan Gilbert #include "migration/migration.h" 424be21d56SDavid Gibson #include "mmu-hash64.h" 43b4db5413SSuraj Jitindar Singh #include "mmu-book3s-v3.h" 443794d548SAlexey Kardashevskiy #include "qom/cpu.h" 4553018216SPaolo Bonzini 4653018216SPaolo Bonzini #include "hw/boards.h" 470d09e41aSPaolo Bonzini #include "hw/ppc/ppc.h" 4853018216SPaolo Bonzini #include "hw/loader.h" 4953018216SPaolo Bonzini 507804c353SCédric Le Goater #include "hw/ppc/fdt.h" 510d09e41aSPaolo Bonzini #include "hw/ppc/spapr.h" 520d09e41aSPaolo Bonzini #include "hw/ppc/spapr_vio.h" 530d09e41aSPaolo Bonzini #include "hw/pci-host/spapr.h" 540d09e41aSPaolo Bonzini #include "hw/ppc/xics.h" 5553018216SPaolo Bonzini #include "hw/pci/msi.h" 5653018216SPaolo Bonzini 5753018216SPaolo Bonzini #include "hw/pci/pci.h" 5871461b0fSAlexey Kardashevskiy #include "hw/scsi/scsi.h" 5971461b0fSAlexey Kardashevskiy #include "hw/virtio/virtio-scsi.h" 6053018216SPaolo Bonzini 6153018216SPaolo Bonzini #include "exec/address-spaces.h" 6253018216SPaolo Bonzini #include "hw/usb.h" 6353018216SPaolo Bonzini #include "qemu/config-file.h" 64135a129aSAneesh Kumar K.V #include "qemu/error-report.h" 652a6593cbSAlexey Kardashevskiy #include "trace.h" 6634316482SAlexey Kardashevskiy #include "hw/nmi.h" 676449da45SCédric Le Goater #include "hw/intc/intc.h" 6853018216SPaolo Bonzini 6968a27b20SMichael S. Tsirkin #include "hw/compat.h" 70f348b6d1SVeronia Bahaa #include "qemu/cutils.h" 7194a94e4cSBharata B Rao #include "hw/ppc/spapr_cpu_core.h" 722474bfd4SIgor Mammedov #include "qmp-commands.h" 7368a27b20SMichael S. Tsirkin 7453018216SPaolo Bonzini #include <libfdt.h> 7553018216SPaolo Bonzini 7653018216SPaolo Bonzini /* SLOF memory layout: 7753018216SPaolo Bonzini * 7853018216SPaolo Bonzini * SLOF raw image loaded at 0, copies its romfs right below the flat 7953018216SPaolo Bonzini * device-tree, then position SLOF itself 31M below that 8053018216SPaolo Bonzini * 8153018216SPaolo Bonzini * So we set FW_OVERHEAD to 40MB which should account for all of that 8253018216SPaolo Bonzini * and more 8353018216SPaolo Bonzini * 8453018216SPaolo Bonzini * We load our kernel at 4M, leaving space for SLOF initial image 8553018216SPaolo Bonzini */ 8638b02bd8SAlexey Kardashevskiy #define FDT_MAX_SIZE 0x100000 8753018216SPaolo Bonzini #define RTAS_MAX_SIZE 0x10000 88b7d1f77aSBenjamin Herrenschmidt #define RTAS_MAX_ADDR 0x80000000 /* RTAS must stay below that */ 8953018216SPaolo Bonzini #define FW_MAX_SIZE 0x400000 9053018216SPaolo Bonzini #define FW_FILE_NAME "slof.bin" 9153018216SPaolo Bonzini #define FW_OVERHEAD 0x2800000 9253018216SPaolo Bonzini #define KERNEL_LOAD_ADDR FW_MAX_SIZE 9353018216SPaolo Bonzini 9453018216SPaolo Bonzini #define MIN_RMA_SLOF 128UL 9553018216SPaolo Bonzini 9653018216SPaolo Bonzini #define PHANDLE_XICP 0x00001111 9753018216SPaolo Bonzini 9853018216SPaolo Bonzini #define HTAB_SIZE(spapr) (1ULL << ((spapr)->htab_shift)) 9953018216SPaolo Bonzini 10071cd4dacSCédric Le Goater static ICSState *spapr_ics_create(sPAPRMachineState *spapr, 10171cd4dacSCédric Le Goater const char *type_ics, 102817bb6a4SCédric Le Goater int nr_irqs, Error **errp) 103c04d6cfaSAnthony Liguori { 104*175d2aa0SGreg Kurz Error *local_err = NULL; 10571cd4dacSCédric Le Goater Object *obj; 106c04d6cfaSAnthony Liguori 10771cd4dacSCédric Le Goater obj = object_new(type_ics); 108*175d2aa0SGreg Kurz object_property_add_child(OBJECT(spapr), "ics", obj, &error_abort); 10971cd4dacSCédric Le Goater object_property_add_const_link(obj, "xics", OBJECT(spapr), &error_abort); 110*175d2aa0SGreg Kurz object_property_set_int(obj, nr_irqs, "nr-irqs", &local_err); 111*175d2aa0SGreg Kurz if (local_err) { 112*175d2aa0SGreg Kurz goto error; 113*175d2aa0SGreg Kurz } 11471cd4dacSCédric Le Goater object_property_set_bool(obj, true, "realized", &local_err); 115*175d2aa0SGreg Kurz if (local_err) { 116*175d2aa0SGreg Kurz goto error; 117c04d6cfaSAnthony Liguori } 118c04d6cfaSAnthony Liguori 11971cd4dacSCédric Le Goater return ICS_SIMPLE(obj); 120*175d2aa0SGreg Kurz 121*175d2aa0SGreg Kurz error: 122*175d2aa0SGreg Kurz error_propagate(errp, local_err); 123*175d2aa0SGreg Kurz return NULL; 1245bc8d26dSCédric Le Goater } 1255bc8d26dSCédric Le Goater 12671cd4dacSCédric Le Goater static void xics_system_init(MachineState *machine, int nr_irqs, Error **errp) 127c04d6cfaSAnthony Liguori { 12871cd4dacSCédric Le Goater sPAPRMachineState *spapr = SPAPR_MACHINE(machine); 129c04d6cfaSAnthony Liguori 13011ad93f6SDavid Gibson if (kvm_enabled()) { 13134f2af3dSMarkus Armbruster Error *err = NULL; 13234f2af3dSMarkus Armbruster 1332192a930SCédric Le Goater if (machine_kernel_irqchip_allowed(machine) && 13471cd4dacSCédric Le Goater !xics_kvm_init(spapr, errp)) { 13571cd4dacSCédric Le Goater spapr->icp_type = TYPE_KVM_ICP; 13671cd4dacSCédric Le Goater spapr->ics = spapr_ics_create(spapr, TYPE_ICS_KVM, nr_irqs, &err); 13711ad93f6SDavid Gibson } 13871cd4dacSCédric Le Goater if (machine_kernel_irqchip_required(machine) && !spapr->ics) { 139b83baa60SMarkus Armbruster error_reportf_err(err, 140b83baa60SMarkus Armbruster "kernel_irqchip requested but unavailable: "); 141b83baa60SMarkus Armbruster } else { 142903a41d3SStefano Dong (董兴水) error_free(err); 14311ad93f6SDavid Gibson } 144b83baa60SMarkus Armbruster } 14511ad93f6SDavid Gibson 14671cd4dacSCédric Le Goater if (!spapr->ics) { 147f63ebfe0SGreg Kurz xics_spapr_init(spapr); 14871cd4dacSCédric Le Goater spapr->icp_type = TYPE_ICP; 14971cd4dacSCédric Le Goater spapr->ics = spapr_ics_create(spapr, TYPE_ICS_SIMPLE, nr_irqs, errp); 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 1860da6f3feSBharata B Rao static int spapr_fixup_cpu_numa_dt(void *fdt, int offset, CPUState *cs) 1870da6f3feSBharata B Rao { 1880da6f3feSBharata B Rao int ret = 0; 1890da6f3feSBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(cs); 1900da6f3feSBharata B Rao int index = ppc_get_vcpu_dt_id(cpu); 1910da6f3feSBharata B Rao uint32_t associativity[] = {cpu_to_be32(0x5), 1920da6f3feSBharata B Rao cpu_to_be32(0x0), 1930da6f3feSBharata B Rao cpu_to_be32(0x0), 1940da6f3feSBharata B Rao cpu_to_be32(0x0), 1950da6f3feSBharata B Rao cpu_to_be32(cs->numa_node), 1960da6f3feSBharata B Rao cpu_to_be32(index)}; 1970da6f3feSBharata B Rao 1980da6f3feSBharata B Rao /* Advertise NUMA via ibm,associativity */ 1990da6f3feSBharata B Rao if (nb_numa_nodes > 1) { 2000da6f3feSBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,associativity", associativity, 2010da6f3feSBharata B Rao sizeof(associativity)); 2020da6f3feSBharata B Rao } 2030da6f3feSBharata B Rao 2040da6f3feSBharata B Rao return ret; 2050da6f3feSBharata B Rao } 2060da6f3feSBharata B Rao 20786d5771aSSam Bobroff /* Populate the "ibm,pa-features" property */ 208e957f6a9SSam Bobroff static void spapr_populate_pa_features(CPUPPCState *env, void *fdt, int offset, 209e957f6a9SSam Bobroff bool legacy_guest) 21086d5771aSSam Bobroff { 21186d5771aSSam Bobroff uint8_t pa_features_206[] = { 6, 0, 21286d5771aSSam Bobroff 0xf6, 0x1f, 0xc7, 0x00, 0x80, 0xc0 }; 21386d5771aSSam Bobroff uint8_t pa_features_207[] = { 24, 0, 21486d5771aSSam Bobroff 0xf6, 0x1f, 0xc7, 0xc0, 0x80, 0xf0, 21586d5771aSSam Bobroff 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 21686d5771aSSam Bobroff 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 21786d5771aSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x00, 0x00 }; 2189fb4541fSSam Bobroff uint8_t pa_features_300[] = { 66, 0, 2199fb4541fSSam Bobroff /* 0: MMU|FPU|SLB|RUN|DABR|NX, 1: fri[nzpm]|DABRX|SPRG3|SLB0|PP110 */ 2209fb4541fSSam Bobroff /* 2: VPM|DS205|PPR|DS202|DS206, 3: LSD|URG, SSO, 5: LE|CFAR|EB|LSQ */ 22186d5771aSSam Bobroff 0xf6, 0x1f, 0xc7, 0xc0, 0x80, 0xf0, /* 0 - 5 */ 2229fb4541fSSam Bobroff /* 6: DS207 */ 22386d5771aSSam Bobroff 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, /* 6 - 11 */ 2249fb4541fSSam Bobroff /* 16: Vector */ 22586d5771aSSam Bobroff 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, /* 12 - 17 */ 2269fb4541fSSam Bobroff /* 18: Vec. Scalar, 20: Vec. XOR, 22: HTM */ 2279bf502feSDavid Gibson 0x80, 0x00, 0x80, 0x00, 0x00, 0x00, /* 18 - 23 */ 2289fb4541fSSam Bobroff /* 24: Ext. Dec, 26: 64 bit ftrs, 28: PM ftrs */ 2299fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, /* 24 - 29 */ 2309fb4541fSSam Bobroff /* 30: MMR, 32: LE atomic, 34: EBB + ext EBB */ 2319fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0xC0, 0x00, /* 30 - 35 */ 2329fb4541fSSam Bobroff /* 36: SPR SO, 38: Copy/Paste, 40: Radix MMU */ 2339fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, /* 36 - 41 */ 2349fb4541fSSam Bobroff /* 42: PM, 44: PC RA, 46: SC vec'd */ 2359fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, /* 42 - 47 */ 2369fb4541fSSam Bobroff /* 48: SIMD, 50: QP BFP, 52: String */ 2379fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, /* 48 - 53 */ 2389fb4541fSSam Bobroff /* 54: DecFP, 56: DecI, 58: SHA */ 2399fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, /* 54 - 59 */ 2409fb4541fSSam Bobroff /* 60: NM atomic, 62: RNG */ 2419fb4541fSSam Bobroff 0x80, 0x00, 0x80, 0x00, 0x00, 0x00, /* 60 - 65 */ 2429fb4541fSSam Bobroff }; 24386d5771aSSam Bobroff uint8_t *pa_features; 24486d5771aSSam Bobroff size_t pa_size; 24586d5771aSSam Bobroff 24686d5771aSSam Bobroff switch (POWERPC_MMU_VER(env->mmu_model)) { 24786d5771aSSam Bobroff case POWERPC_MMU_VER_2_06: 24886d5771aSSam Bobroff pa_features = pa_features_206; 24986d5771aSSam Bobroff pa_size = sizeof(pa_features_206); 25086d5771aSSam Bobroff break; 25186d5771aSSam Bobroff case POWERPC_MMU_VER_2_07: 25286d5771aSSam Bobroff pa_features = pa_features_207; 25386d5771aSSam Bobroff pa_size = sizeof(pa_features_207); 25486d5771aSSam Bobroff break; 25586d5771aSSam Bobroff case POWERPC_MMU_VER_3_00: 25686d5771aSSam Bobroff pa_features = pa_features_300; 25786d5771aSSam Bobroff pa_size = sizeof(pa_features_300); 25886d5771aSSam Bobroff break; 25986d5771aSSam Bobroff default: 26086d5771aSSam Bobroff return; 26186d5771aSSam Bobroff } 26286d5771aSSam Bobroff 26386d5771aSSam Bobroff if (env->ci_large_pages) { 26486d5771aSSam Bobroff /* 26586d5771aSSam Bobroff * Note: we keep CI large pages off by default because a 64K capable 26686d5771aSSam Bobroff * guest provisioned with large pages might otherwise try to map a qemu 26786d5771aSSam Bobroff * framebuffer (or other kind of memory mapped PCI BAR) using 64K pages 26886d5771aSSam Bobroff * even if that qemu runs on a 4k host. 26986d5771aSSam Bobroff * We dd this bit back here if we are confident this is not an issue 27086d5771aSSam Bobroff */ 27186d5771aSSam Bobroff pa_features[3] |= 0x20; 27286d5771aSSam Bobroff } 27386d5771aSSam Bobroff if (kvmppc_has_cap_htm() && pa_size > 24) { 27486d5771aSSam Bobroff pa_features[24] |= 0x80; /* Transactional memory support */ 27586d5771aSSam Bobroff } 276e957f6a9SSam Bobroff if (legacy_guest && pa_size > 40) { 277e957f6a9SSam Bobroff /* Workaround for broken kernels that attempt (guest) radix 278e957f6a9SSam Bobroff * mode when they can't handle it, if they see the radix bit set 279e957f6a9SSam Bobroff * in pa-features. So hide it from them. */ 280e957f6a9SSam Bobroff pa_features[40 + 2] &= ~0x80; /* Radix MMU */ 281e957f6a9SSam Bobroff } 28286d5771aSSam Bobroff 28386d5771aSSam Bobroff _FDT((fdt_setprop(fdt, offset, "ibm,pa-features", pa_features, pa_size))); 28486d5771aSSam Bobroff } 28586d5771aSSam Bobroff 28628e02042SDavid Gibson static int spapr_fixup_cpu_dt(void *fdt, sPAPRMachineState *spapr) 28753018216SPaolo Bonzini { 28882677ed2SAlexey Kardashevskiy int ret = 0, offset, cpus_offset; 28982677ed2SAlexey Kardashevskiy CPUState *cs; 29053018216SPaolo Bonzini char cpu_model[32]; 29153018216SPaolo Bonzini int smt = kvmppc_smt_threads(); 29253018216SPaolo Bonzini uint32_t pft_size_prop[] = {0, cpu_to_be32(spapr->htab_shift)}; 29353018216SPaolo Bonzini 29482677ed2SAlexey Kardashevskiy CPU_FOREACH(cs) { 29582677ed2SAlexey Kardashevskiy PowerPCCPU *cpu = POWERPC_CPU(cs); 296e957f6a9SSam Bobroff CPUPPCState *env = &cpu->env; 29782677ed2SAlexey Kardashevskiy DeviceClass *dc = DEVICE_GET_CLASS(cs); 29882677ed2SAlexey Kardashevskiy int index = ppc_get_vcpu_dt_id(cpu); 29912dbeb16SDavid Gibson int compat_smt = MIN(smp_threads, ppc_compat_max_threads(cpu)); 30053018216SPaolo Bonzini 3010f20ba62SAlexey Kardashevskiy if ((index % smt) != 0) { 30253018216SPaolo Bonzini continue; 30353018216SPaolo Bonzini } 30453018216SPaolo Bonzini 30582677ed2SAlexey Kardashevskiy snprintf(cpu_model, 32, "%s@%x", dc->fw_name, index); 30653018216SPaolo Bonzini 30782677ed2SAlexey Kardashevskiy cpus_offset = fdt_path_offset(fdt, "/cpus"); 30882677ed2SAlexey Kardashevskiy if (cpus_offset < 0) { 30982677ed2SAlexey Kardashevskiy cpus_offset = fdt_add_subnode(fdt, fdt_path_offset(fdt, "/"), 31082677ed2SAlexey Kardashevskiy "cpus"); 31182677ed2SAlexey Kardashevskiy if (cpus_offset < 0) { 31282677ed2SAlexey Kardashevskiy return cpus_offset; 31382677ed2SAlexey Kardashevskiy } 31482677ed2SAlexey Kardashevskiy } 31582677ed2SAlexey Kardashevskiy offset = fdt_subnode_offset(fdt, cpus_offset, cpu_model); 31682677ed2SAlexey Kardashevskiy if (offset < 0) { 31782677ed2SAlexey Kardashevskiy offset = fdt_add_subnode(fdt, cpus_offset, cpu_model); 31853018216SPaolo Bonzini if (offset < 0) { 31953018216SPaolo Bonzini return offset; 32053018216SPaolo Bonzini } 32182677ed2SAlexey Kardashevskiy } 32253018216SPaolo Bonzini 3230da6f3feSBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,pft-size", 3240da6f3feSBharata B Rao pft_size_prop, sizeof(pft_size_prop)); 32553018216SPaolo Bonzini if (ret < 0) { 32653018216SPaolo Bonzini return ret; 32753018216SPaolo Bonzini } 32853018216SPaolo Bonzini 3290da6f3feSBharata B Rao ret = spapr_fixup_cpu_numa_dt(fdt, offset, cs); 33053018216SPaolo Bonzini if (ret < 0) { 33153018216SPaolo Bonzini return ret; 33253018216SPaolo Bonzini } 333833d4668SAlexey Kardashevskiy 33412dbeb16SDavid Gibson ret = spapr_fixup_cpu_smt_dt(fdt, offset, cpu, compat_smt); 335833d4668SAlexey Kardashevskiy if (ret < 0) { 336833d4668SAlexey Kardashevskiy return ret; 337833d4668SAlexey Kardashevskiy } 338e957f6a9SSam Bobroff 339e957f6a9SSam Bobroff spapr_populate_pa_features(env, fdt, offset, 340e957f6a9SSam Bobroff spapr->cas_legacy_guest_workaround); 34153018216SPaolo Bonzini } 34253018216SPaolo Bonzini return ret; 34353018216SPaolo Bonzini } 34453018216SPaolo Bonzini 345b082d65aSAlexey Kardashevskiy static hwaddr spapr_node0_size(void) 346b082d65aSAlexey Kardashevskiy { 347fb164994SDavid Gibson MachineState *machine = MACHINE(qdev_get_machine()); 348fb164994SDavid Gibson 349b082d65aSAlexey Kardashevskiy if (nb_numa_nodes) { 350b082d65aSAlexey Kardashevskiy int i; 351b082d65aSAlexey Kardashevskiy for (i = 0; i < nb_numa_nodes; ++i) { 352b082d65aSAlexey Kardashevskiy if (numa_info[i].node_mem) { 353fb164994SDavid Gibson return MIN(pow2floor(numa_info[i].node_mem), 354fb164994SDavid Gibson machine->ram_size); 355b082d65aSAlexey Kardashevskiy } 356b082d65aSAlexey Kardashevskiy } 357b082d65aSAlexey Kardashevskiy } 358fb164994SDavid Gibson return machine->ram_size; 359b082d65aSAlexey Kardashevskiy } 360b082d65aSAlexey Kardashevskiy 361a1d59c0fSAlexey Kardashevskiy static void add_str(GString *s, const gchar *s1) 362a1d59c0fSAlexey Kardashevskiy { 363a1d59c0fSAlexey Kardashevskiy g_string_append_len(s, s1, strlen(s1) + 1); 364a1d59c0fSAlexey Kardashevskiy } 36553018216SPaolo Bonzini 36603d196b7SBharata B Rao static int spapr_populate_memory_node(void *fdt, int nodeid, hwaddr start, 36726a8c353SAlexey Kardashevskiy hwaddr size) 36826a8c353SAlexey Kardashevskiy { 36926a8c353SAlexey Kardashevskiy uint32_t associativity[] = { 37026a8c353SAlexey Kardashevskiy cpu_to_be32(0x4), /* length */ 37126a8c353SAlexey Kardashevskiy cpu_to_be32(0x0), cpu_to_be32(0x0), 372c3b4f589SAlexey Kardashevskiy cpu_to_be32(0x0), cpu_to_be32(nodeid) 37326a8c353SAlexey Kardashevskiy }; 37426a8c353SAlexey Kardashevskiy char mem_name[32]; 37526a8c353SAlexey Kardashevskiy uint64_t mem_reg_property[2]; 37626a8c353SAlexey Kardashevskiy int off; 37726a8c353SAlexey Kardashevskiy 37826a8c353SAlexey Kardashevskiy mem_reg_property[0] = cpu_to_be64(start); 37926a8c353SAlexey Kardashevskiy mem_reg_property[1] = cpu_to_be64(size); 38026a8c353SAlexey Kardashevskiy 38126a8c353SAlexey Kardashevskiy sprintf(mem_name, "memory@" TARGET_FMT_lx, start); 38226a8c353SAlexey Kardashevskiy off = fdt_add_subnode(fdt, 0, mem_name); 38326a8c353SAlexey Kardashevskiy _FDT(off); 38426a8c353SAlexey Kardashevskiy _FDT((fdt_setprop_string(fdt, off, "device_type", "memory"))); 38526a8c353SAlexey Kardashevskiy _FDT((fdt_setprop(fdt, off, "reg", mem_reg_property, 38626a8c353SAlexey Kardashevskiy sizeof(mem_reg_property)))); 38726a8c353SAlexey Kardashevskiy _FDT((fdt_setprop(fdt, off, "ibm,associativity", associativity, 38826a8c353SAlexey Kardashevskiy sizeof(associativity)))); 38903d196b7SBharata B Rao return off; 39026a8c353SAlexey Kardashevskiy } 39126a8c353SAlexey Kardashevskiy 39228e02042SDavid Gibson static int spapr_populate_memory(sPAPRMachineState *spapr, void *fdt) 39353018216SPaolo Bonzini { 394fb164994SDavid Gibson MachineState *machine = MACHINE(spapr); 3957db8a127SAlexey Kardashevskiy hwaddr mem_start, node_size; 3967db8a127SAlexey Kardashevskiy int i, nb_nodes = nb_numa_nodes; 3977db8a127SAlexey Kardashevskiy NodeInfo *nodes = numa_info; 3987db8a127SAlexey Kardashevskiy NodeInfo ramnode; 39953018216SPaolo Bonzini 4007db8a127SAlexey Kardashevskiy /* No NUMA nodes, assume there is just one node with whole RAM */ 4017db8a127SAlexey Kardashevskiy if (!nb_numa_nodes) { 4027db8a127SAlexey Kardashevskiy nb_nodes = 1; 403fb164994SDavid Gibson ramnode.node_mem = machine->ram_size; 4047db8a127SAlexey Kardashevskiy nodes = &ramnode; 4055fe269b1SPaul Mackerras } 40653018216SPaolo Bonzini 4077db8a127SAlexey Kardashevskiy for (i = 0, mem_start = 0; i < nb_nodes; ++i) { 4087db8a127SAlexey Kardashevskiy if (!nodes[i].node_mem) { 4097db8a127SAlexey Kardashevskiy continue; 41053018216SPaolo Bonzini } 411fb164994SDavid Gibson if (mem_start >= machine->ram_size) { 4125fe269b1SPaul Mackerras node_size = 0; 4135fe269b1SPaul Mackerras } else { 4147db8a127SAlexey Kardashevskiy node_size = nodes[i].node_mem; 415fb164994SDavid Gibson if (node_size > machine->ram_size - mem_start) { 416fb164994SDavid Gibson node_size = machine->ram_size - mem_start; 4175fe269b1SPaul Mackerras } 4185fe269b1SPaul Mackerras } 4197db8a127SAlexey Kardashevskiy if (!mem_start) { 4207db8a127SAlexey Kardashevskiy /* ppc_spapr_init() checks for rma_size <= node0_size already */ 421e8f986fcSBharata B Rao spapr_populate_memory_node(fdt, i, 0, spapr->rma_size); 4227db8a127SAlexey Kardashevskiy mem_start += spapr->rma_size; 4237db8a127SAlexey Kardashevskiy node_size -= spapr->rma_size; 4247db8a127SAlexey Kardashevskiy } 4256010818cSAlexey Kardashevskiy for ( ; node_size; ) { 4266010818cSAlexey Kardashevskiy hwaddr sizetmp = pow2floor(node_size); 4276010818cSAlexey Kardashevskiy 4286010818cSAlexey Kardashevskiy /* mem_start != 0 here */ 4296010818cSAlexey Kardashevskiy if (ctzl(mem_start) < ctzl(sizetmp)) { 4306010818cSAlexey Kardashevskiy sizetmp = 1ULL << ctzl(mem_start); 4316010818cSAlexey Kardashevskiy } 4326010818cSAlexey Kardashevskiy 4336010818cSAlexey Kardashevskiy spapr_populate_memory_node(fdt, i, mem_start, sizetmp); 4346010818cSAlexey Kardashevskiy node_size -= sizetmp; 4356010818cSAlexey Kardashevskiy mem_start += sizetmp; 4366010818cSAlexey Kardashevskiy } 43753018216SPaolo Bonzini } 43853018216SPaolo Bonzini 43953018216SPaolo Bonzini return 0; 44053018216SPaolo Bonzini } 44153018216SPaolo Bonzini 4420da6f3feSBharata B Rao static void spapr_populate_cpu_dt(CPUState *cs, void *fdt, int offset, 4430da6f3feSBharata B Rao sPAPRMachineState *spapr) 4440da6f3feSBharata B Rao { 4450da6f3feSBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(cs); 4460da6f3feSBharata B Rao CPUPPCState *env = &cpu->env; 4470da6f3feSBharata B Rao PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(cs); 4480da6f3feSBharata B Rao int index = ppc_get_vcpu_dt_id(cpu); 4490da6f3feSBharata B Rao uint32_t segs[] = {cpu_to_be32(28), cpu_to_be32(40), 4500da6f3feSBharata B Rao 0xffffffff, 0xffffffff}; 451afd10a0fSBharata B Rao uint32_t tbfreq = kvm_enabled() ? kvmppc_get_tbfreq() 452afd10a0fSBharata B Rao : SPAPR_TIMEBASE_FREQ; 4530da6f3feSBharata B Rao uint32_t cpufreq = kvm_enabled() ? kvmppc_get_clockfreq() : 1000000000; 4540da6f3feSBharata B Rao uint32_t page_sizes_prop[64]; 4550da6f3feSBharata B Rao size_t page_sizes_prop_size; 45622419c2aSDavid Gibson uint32_t vcpus_per_socket = smp_threads * smp_cores; 4570da6f3feSBharata B Rao uint32_t pft_size_prop[] = {0, cpu_to_be32(spapr->htab_shift)}; 45812dbeb16SDavid Gibson int compat_smt = MIN(smp_threads, ppc_compat_max_threads(cpu)); 459af81cf32SBharata B Rao sPAPRDRConnector *drc; 460af81cf32SBharata B Rao sPAPRDRConnectorClass *drck; 461af81cf32SBharata B Rao int drc_index; 462c64abd1fSSam Bobroff uint32_t radix_AP_encodings[PPC_PAGE_SIZES_MAX_SZ]; 463c64abd1fSSam Bobroff int i; 464af81cf32SBharata B Rao 465af81cf32SBharata B Rao drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_CPU, index); 466af81cf32SBharata B Rao if (drc) { 467af81cf32SBharata B Rao drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 468af81cf32SBharata B Rao drc_index = drck->get_index(drc); 469af81cf32SBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,my-drc-index", drc_index))); 470af81cf32SBharata B Rao } 4710da6f3feSBharata B Rao 4720da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "reg", index))); 4730da6f3feSBharata B Rao _FDT((fdt_setprop_string(fdt, offset, "device_type", "cpu"))); 4740da6f3feSBharata B Rao 4750da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "cpu-version", env->spr[SPR_PVR]))); 4760da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "d-cache-block-size", 4770da6f3feSBharata B Rao env->dcache_line_size))); 4780da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "d-cache-line-size", 4790da6f3feSBharata B Rao env->dcache_line_size))); 4800da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "i-cache-block-size", 4810da6f3feSBharata B Rao env->icache_line_size))); 4820da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "i-cache-line-size", 4830da6f3feSBharata B Rao env->icache_line_size))); 4840da6f3feSBharata B Rao 4850da6f3feSBharata B Rao if (pcc->l1_dcache_size) { 4860da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "d-cache-size", 4870da6f3feSBharata B Rao pcc->l1_dcache_size))); 4880da6f3feSBharata B Rao } else { 489ce9863b7SCédric Le Goater error_report("Warning: Unknown L1 dcache size for cpu"); 4900da6f3feSBharata B Rao } 4910da6f3feSBharata B Rao if (pcc->l1_icache_size) { 4920da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "i-cache-size", 4930da6f3feSBharata B Rao pcc->l1_icache_size))); 4940da6f3feSBharata B Rao } else { 495ce9863b7SCédric Le Goater error_report("Warning: Unknown L1 icache size for cpu"); 4960da6f3feSBharata B Rao } 4970da6f3feSBharata B Rao 4980da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "timebase-frequency", tbfreq))); 4990da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "clock-frequency", cpufreq))); 500fd5da5c4SThomas Huth _FDT((fdt_setprop_cell(fdt, offset, "slb-size", env->slb_nr))); 5010da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,slb-size", env->slb_nr))); 5020da6f3feSBharata B Rao _FDT((fdt_setprop_string(fdt, offset, "status", "okay"))); 5030da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "64-bit", NULL, 0))); 5040da6f3feSBharata B Rao 5050da6f3feSBharata B Rao if (env->spr_cb[SPR_PURR].oea_read) { 5060da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,purr", NULL, 0))); 5070da6f3feSBharata B Rao } 5080da6f3feSBharata B Rao 5090da6f3feSBharata B Rao if (env->mmu_model & POWERPC_MMU_1TSEG) { 5100da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,processor-segment-sizes", 5110da6f3feSBharata B Rao segs, sizeof(segs)))); 5120da6f3feSBharata B Rao } 5130da6f3feSBharata B Rao 5140da6f3feSBharata B Rao /* Advertise VMX/VSX (vector extensions) if available 5150da6f3feSBharata B Rao * 0 / no property == no vector extensions 5160da6f3feSBharata B Rao * 1 == VMX / Altivec available 5170da6f3feSBharata B Rao * 2 == VSX available */ 5180da6f3feSBharata B Rao if (env->insns_flags & PPC_ALTIVEC) { 5190da6f3feSBharata B Rao uint32_t vmx = (env->insns_flags2 & PPC2_VSX) ? 2 : 1; 5200da6f3feSBharata B Rao 5210da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,vmx", vmx))); 5220da6f3feSBharata B Rao } 5230da6f3feSBharata B Rao 5240da6f3feSBharata B Rao /* Advertise DFP (Decimal Floating Point) if available 5250da6f3feSBharata B Rao * 0 / no property == no DFP 5260da6f3feSBharata B Rao * 1 == DFP available */ 5270da6f3feSBharata B Rao if (env->insns_flags2 & PPC2_DFP) { 5280da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,dfp", 1))); 5290da6f3feSBharata B Rao } 5300da6f3feSBharata B Rao 5313654fa95SCédric Le Goater page_sizes_prop_size = ppc_create_page_sizes_prop(env, page_sizes_prop, 5320da6f3feSBharata B Rao sizeof(page_sizes_prop)); 5330da6f3feSBharata B Rao if (page_sizes_prop_size) { 5340da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,segment-page-sizes", 5350da6f3feSBharata B Rao page_sizes_prop, page_sizes_prop_size))); 5360da6f3feSBharata B Rao } 5370da6f3feSBharata B Rao 538e957f6a9SSam Bobroff spapr_populate_pa_features(env, fdt, offset, false); 53990da0d5aSBenjamin Herrenschmidt 5400da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,chip-id", 54122419c2aSDavid Gibson cs->cpu_index / vcpus_per_socket))); 5420da6f3feSBharata B Rao 5430da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,pft-size", 5440da6f3feSBharata B Rao pft_size_prop, sizeof(pft_size_prop)))); 5450da6f3feSBharata B Rao 5460da6f3feSBharata B Rao _FDT(spapr_fixup_cpu_numa_dt(fdt, offset, cs)); 5470da6f3feSBharata B Rao 54812dbeb16SDavid Gibson _FDT(spapr_fixup_cpu_smt_dt(fdt, offset, cpu, compat_smt)); 549c64abd1fSSam Bobroff 550c64abd1fSSam Bobroff if (pcc->radix_page_info) { 551c64abd1fSSam Bobroff for (i = 0; i < pcc->radix_page_info->count; i++) { 552c64abd1fSSam Bobroff radix_AP_encodings[i] = 553c64abd1fSSam Bobroff cpu_to_be32(pcc->radix_page_info->entries[i]); 554c64abd1fSSam Bobroff } 555c64abd1fSSam Bobroff _FDT((fdt_setprop(fdt, offset, "ibm,processor-radix-AP-encodings", 556c64abd1fSSam Bobroff radix_AP_encodings, 557c64abd1fSSam Bobroff pcc->radix_page_info->count * 558c64abd1fSSam Bobroff sizeof(radix_AP_encodings[0])))); 559c64abd1fSSam Bobroff } 5600da6f3feSBharata B Rao } 5610da6f3feSBharata B Rao 5620da6f3feSBharata B Rao static void spapr_populate_cpus_dt_node(void *fdt, sPAPRMachineState *spapr) 5630da6f3feSBharata B Rao { 5640da6f3feSBharata B Rao CPUState *cs; 5650da6f3feSBharata B Rao int cpus_offset; 5660da6f3feSBharata B Rao char *nodename; 5670da6f3feSBharata B Rao int smt = kvmppc_smt_threads(); 5680da6f3feSBharata B Rao 5690da6f3feSBharata B Rao cpus_offset = fdt_add_subnode(fdt, 0, "cpus"); 5700da6f3feSBharata B Rao _FDT(cpus_offset); 5710da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, cpus_offset, "#address-cells", 0x1))); 5720da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, cpus_offset, "#size-cells", 0x0))); 5730da6f3feSBharata B Rao 5740da6f3feSBharata B Rao /* 5750da6f3feSBharata B Rao * We walk the CPUs in reverse order to ensure that CPU DT nodes 5760da6f3feSBharata B Rao * created by fdt_add_subnode() end up in the right order in FDT 5770da6f3feSBharata B Rao * for the guest kernel the enumerate the CPUs correctly. 5780da6f3feSBharata B Rao */ 5790da6f3feSBharata B Rao CPU_FOREACH_REVERSE(cs) { 5800da6f3feSBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(cs); 5810da6f3feSBharata B Rao int index = ppc_get_vcpu_dt_id(cpu); 5820da6f3feSBharata B Rao DeviceClass *dc = DEVICE_GET_CLASS(cs); 5830da6f3feSBharata B Rao int offset; 5840da6f3feSBharata B Rao 5850da6f3feSBharata B Rao if ((index % smt) != 0) { 5860da6f3feSBharata B Rao continue; 5870da6f3feSBharata B Rao } 5880da6f3feSBharata B Rao 5890da6f3feSBharata B Rao nodename = g_strdup_printf("%s@%x", dc->fw_name, index); 5900da6f3feSBharata B Rao offset = fdt_add_subnode(fdt, cpus_offset, nodename); 5910da6f3feSBharata B Rao g_free(nodename); 5920da6f3feSBharata B Rao _FDT(offset); 5930da6f3feSBharata B Rao spapr_populate_cpu_dt(cs, fdt, offset, spapr); 5940da6f3feSBharata B Rao } 5950da6f3feSBharata B Rao 5960da6f3feSBharata B Rao } 5970da6f3feSBharata B Rao 59803d196b7SBharata B Rao /* 59903d196b7SBharata B Rao * Adds ibm,dynamic-reconfiguration-memory node. 60003d196b7SBharata B Rao * Refer to docs/specs/ppc-spapr-hotplug.txt for the documentation 60103d196b7SBharata B Rao * of this device tree node. 60203d196b7SBharata B Rao */ 60303d196b7SBharata B Rao static int spapr_populate_drconf_memory(sPAPRMachineState *spapr, void *fdt) 60403d196b7SBharata B Rao { 60503d196b7SBharata B Rao MachineState *machine = MACHINE(spapr); 60603d196b7SBharata B Rao int ret, i, offset; 60703d196b7SBharata B Rao uint64_t lmb_size = SPAPR_MEMORY_BLOCK_SIZE; 60803d196b7SBharata B Rao uint32_t prop_lmb_size[] = {0, cpu_to_be32(lmb_size)}; 609d0e5a8f2SBharata B Rao uint32_t hotplug_lmb_start = spapr->hotplug_memory.base / lmb_size; 610d0e5a8f2SBharata B Rao uint32_t nr_lmbs = (spapr->hotplug_memory.base + 611d0e5a8f2SBharata B Rao memory_region_size(&spapr->hotplug_memory.mr)) / 612d0e5a8f2SBharata B Rao lmb_size; 61303d196b7SBharata B Rao uint32_t *int_buf, *cur_index, buf_len; 6146663864eSBharata B Rao int nr_nodes = nb_numa_nodes ? nb_numa_nodes : 1; 61503d196b7SBharata B Rao 616ef001f06SThomas Huth /* 617d0e5a8f2SBharata B Rao * Don't create the node if there is no hotpluggable memory 61816c25aefSBharata B Rao */ 619d0e5a8f2SBharata B Rao if (machine->ram_size == machine->maxram_size) { 62016c25aefSBharata B Rao return 0; 62116c25aefSBharata B Rao } 62216c25aefSBharata B Rao 62316c25aefSBharata B Rao /* 624ef001f06SThomas Huth * Allocate enough buffer size to fit in ibm,dynamic-memory 625ef001f06SThomas Huth * or ibm,associativity-lookup-arrays 626ef001f06SThomas Huth */ 627ef001f06SThomas Huth buf_len = MAX(nr_lmbs * SPAPR_DR_LMB_LIST_ENTRY_SIZE + 1, nr_nodes * 4 + 2) 628ef001f06SThomas Huth * sizeof(uint32_t); 62903d196b7SBharata B Rao cur_index = int_buf = g_malloc0(buf_len); 63003d196b7SBharata B Rao 63103d196b7SBharata B Rao offset = fdt_add_subnode(fdt, 0, "ibm,dynamic-reconfiguration-memory"); 63203d196b7SBharata B Rao 63303d196b7SBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,lmb-size", prop_lmb_size, 63403d196b7SBharata B Rao sizeof(prop_lmb_size)); 63503d196b7SBharata B Rao if (ret < 0) { 63603d196b7SBharata B Rao goto out; 63703d196b7SBharata B Rao } 63803d196b7SBharata B Rao 63903d196b7SBharata B Rao ret = fdt_setprop_cell(fdt, offset, "ibm,memory-flags-mask", 0xff); 64003d196b7SBharata B Rao if (ret < 0) { 64103d196b7SBharata B Rao goto out; 64203d196b7SBharata B Rao } 64303d196b7SBharata B Rao 64403d196b7SBharata B Rao ret = fdt_setprop_cell(fdt, offset, "ibm,memory-preservation-time", 0x0); 64503d196b7SBharata B Rao if (ret < 0) { 64603d196b7SBharata B Rao goto out; 64703d196b7SBharata B Rao } 64803d196b7SBharata B Rao 64903d196b7SBharata B Rao /* ibm,dynamic-memory */ 65003d196b7SBharata B Rao int_buf[0] = cpu_to_be32(nr_lmbs); 65103d196b7SBharata B Rao cur_index++; 65203d196b7SBharata B Rao for (i = 0; i < nr_lmbs; i++) { 653d0e5a8f2SBharata B Rao uint64_t addr = i * lmb_size; 65403d196b7SBharata B Rao uint32_t *dynamic_memory = cur_index; 65503d196b7SBharata B Rao 656d0e5a8f2SBharata B Rao if (i >= hotplug_lmb_start) { 657d0e5a8f2SBharata B Rao sPAPRDRConnector *drc; 658d0e5a8f2SBharata B Rao sPAPRDRConnectorClass *drck; 659d0e5a8f2SBharata B Rao 660d0e5a8f2SBharata B Rao drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_LMB, i); 66103d196b7SBharata B Rao g_assert(drc); 66203d196b7SBharata B Rao drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 66303d196b7SBharata B Rao 66403d196b7SBharata B Rao dynamic_memory[0] = cpu_to_be32(addr >> 32); 66503d196b7SBharata B Rao dynamic_memory[1] = cpu_to_be32(addr & 0xffffffff); 66603d196b7SBharata B Rao dynamic_memory[2] = cpu_to_be32(drck->get_index(drc)); 66703d196b7SBharata B Rao dynamic_memory[3] = cpu_to_be32(0); /* reserved */ 66803d196b7SBharata B Rao dynamic_memory[4] = cpu_to_be32(numa_get_node(addr, NULL)); 669d0e5a8f2SBharata B Rao if (memory_region_present(get_system_memory(), addr)) { 67003d196b7SBharata B Rao dynamic_memory[5] = cpu_to_be32(SPAPR_LMB_FLAGS_ASSIGNED); 67103d196b7SBharata B Rao } else { 67203d196b7SBharata B Rao dynamic_memory[5] = cpu_to_be32(0); 67303d196b7SBharata B Rao } 674d0e5a8f2SBharata B Rao } else { 675d0e5a8f2SBharata B Rao /* 676d0e5a8f2SBharata B Rao * LMB information for RMA, boot time RAM and gap b/n RAM and 677d0e5a8f2SBharata B Rao * hotplug memory region -- all these are marked as reserved 678d0e5a8f2SBharata B Rao * and as having no valid DRC. 679d0e5a8f2SBharata B Rao */ 680d0e5a8f2SBharata B Rao dynamic_memory[0] = cpu_to_be32(addr >> 32); 681d0e5a8f2SBharata B Rao dynamic_memory[1] = cpu_to_be32(addr & 0xffffffff); 682d0e5a8f2SBharata B Rao dynamic_memory[2] = cpu_to_be32(0); 683d0e5a8f2SBharata B Rao dynamic_memory[3] = cpu_to_be32(0); /* reserved */ 684d0e5a8f2SBharata B Rao dynamic_memory[4] = cpu_to_be32(-1); 685d0e5a8f2SBharata B Rao dynamic_memory[5] = cpu_to_be32(SPAPR_LMB_FLAGS_RESERVED | 686d0e5a8f2SBharata B Rao SPAPR_LMB_FLAGS_DRC_INVALID); 687d0e5a8f2SBharata B Rao } 68803d196b7SBharata B Rao 68903d196b7SBharata B Rao cur_index += SPAPR_DR_LMB_LIST_ENTRY_SIZE; 69003d196b7SBharata B Rao } 69103d196b7SBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,dynamic-memory", int_buf, buf_len); 69203d196b7SBharata B Rao if (ret < 0) { 69303d196b7SBharata B Rao goto out; 69403d196b7SBharata B Rao } 69503d196b7SBharata B Rao 69603d196b7SBharata B Rao /* ibm,associativity-lookup-arrays */ 69703d196b7SBharata B Rao cur_index = int_buf; 6986663864eSBharata B Rao int_buf[0] = cpu_to_be32(nr_nodes); 69903d196b7SBharata B Rao int_buf[1] = cpu_to_be32(4); /* Number of entries per associativity list */ 70003d196b7SBharata B Rao cur_index += 2; 7016663864eSBharata B Rao for (i = 0; i < nr_nodes; i++) { 70203d196b7SBharata B Rao uint32_t associativity[] = { 70303d196b7SBharata B Rao cpu_to_be32(0x0), 70403d196b7SBharata B Rao cpu_to_be32(0x0), 70503d196b7SBharata B Rao cpu_to_be32(0x0), 70603d196b7SBharata B Rao cpu_to_be32(i) 70703d196b7SBharata B Rao }; 70803d196b7SBharata B Rao memcpy(cur_index, associativity, sizeof(associativity)); 70903d196b7SBharata B Rao cur_index += 4; 71003d196b7SBharata B Rao } 71103d196b7SBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,associativity-lookup-arrays", int_buf, 71203d196b7SBharata B Rao (cur_index - int_buf) * sizeof(uint32_t)); 71303d196b7SBharata B Rao out: 71403d196b7SBharata B Rao g_free(int_buf); 71503d196b7SBharata B Rao return ret; 71603d196b7SBharata B Rao } 71703d196b7SBharata B Rao 7186787d27bSMichael Roth static int spapr_dt_cas_updates(sPAPRMachineState *spapr, void *fdt, 7196787d27bSMichael Roth sPAPROptionVector *ov5_updates) 7206787d27bSMichael Roth { 7216787d27bSMichael Roth sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(spapr); 722417ece33SMichael Roth int ret = 0, offset; 7236787d27bSMichael Roth 7246787d27bSMichael Roth /* Generate ibm,dynamic-reconfiguration-memory node if required */ 7256787d27bSMichael Roth if (spapr_ovec_test(ov5_updates, OV5_DRCONF_MEMORY)) { 7266787d27bSMichael Roth g_assert(smc->dr_lmb_enabled); 7276787d27bSMichael Roth ret = spapr_populate_drconf_memory(spapr, fdt); 728417ece33SMichael Roth if (ret) { 729417ece33SMichael Roth goto out; 730417ece33SMichael Roth } 7316787d27bSMichael Roth } 7326787d27bSMichael Roth 733417ece33SMichael Roth offset = fdt_path_offset(fdt, "/chosen"); 734417ece33SMichael Roth if (offset < 0) { 735417ece33SMichael Roth offset = fdt_add_subnode(fdt, 0, "chosen"); 736417ece33SMichael Roth if (offset < 0) { 737417ece33SMichael Roth return offset; 738417ece33SMichael Roth } 739417ece33SMichael Roth } 740417ece33SMichael Roth ret = spapr_ovec_populate_dt(fdt, offset, spapr->ov5_cas, 741417ece33SMichael Roth "ibm,architecture-vec-5"); 742417ece33SMichael Roth 743417ece33SMichael Roth out: 7446787d27bSMichael Roth return ret; 7456787d27bSMichael Roth } 7466787d27bSMichael Roth 74703d196b7SBharata B Rao int spapr_h_cas_compose_response(sPAPRMachineState *spapr, 74803d196b7SBharata B Rao target_ulong addr, target_ulong size, 7496787d27bSMichael Roth sPAPROptionVector *ov5_updates) 75003d196b7SBharata B Rao { 75103d196b7SBharata B Rao void *fdt, *fdt_skel; 75203d196b7SBharata B Rao sPAPRDeviceTreeUpdateHeader hdr = { .version_id = 1 }; 75303d196b7SBharata B Rao 75403d196b7SBharata B Rao size -= sizeof(hdr); 75503d196b7SBharata B Rao 75603d196b7SBharata B Rao /* Create sceleton */ 75703d196b7SBharata B Rao fdt_skel = g_malloc0(size); 75803d196b7SBharata B Rao _FDT((fdt_create(fdt_skel, size))); 75903d196b7SBharata B Rao _FDT((fdt_begin_node(fdt_skel, ""))); 76003d196b7SBharata B Rao _FDT((fdt_end_node(fdt_skel))); 76103d196b7SBharata B Rao _FDT((fdt_finish(fdt_skel))); 76203d196b7SBharata B Rao fdt = g_malloc0(size); 76303d196b7SBharata B Rao _FDT((fdt_open_into(fdt_skel, fdt, size))); 76403d196b7SBharata B Rao g_free(fdt_skel); 76503d196b7SBharata B Rao 76603d196b7SBharata B Rao /* Fixup cpu nodes */ 76703d196b7SBharata B Rao _FDT((spapr_fixup_cpu_dt(fdt, spapr))); 76803d196b7SBharata B Rao 7696787d27bSMichael Roth if (spapr_dt_cas_updates(spapr, fdt, ov5_updates)) { 7706787d27bSMichael Roth return -1; 77103d196b7SBharata B Rao } 77203d196b7SBharata B Rao 77303d196b7SBharata B Rao /* Pack resulting tree */ 77403d196b7SBharata B Rao _FDT((fdt_pack(fdt))); 77503d196b7SBharata B Rao 77603d196b7SBharata B Rao if (fdt_totalsize(fdt) + sizeof(hdr) > size) { 77703d196b7SBharata B Rao trace_spapr_cas_failed(size); 77803d196b7SBharata B Rao return -1; 77903d196b7SBharata B Rao } 78003d196b7SBharata B Rao 78103d196b7SBharata B Rao cpu_physical_memory_write(addr, &hdr, sizeof(hdr)); 78203d196b7SBharata B Rao cpu_physical_memory_write(addr + sizeof(hdr), fdt, fdt_totalsize(fdt)); 78303d196b7SBharata B Rao trace_spapr_cas_continue(fdt_totalsize(fdt) + sizeof(hdr)); 78403d196b7SBharata B Rao g_free(fdt); 78503d196b7SBharata B Rao 78603d196b7SBharata B Rao return 0; 78703d196b7SBharata B Rao } 78803d196b7SBharata B Rao 7893f5dabceSDavid Gibson static void spapr_dt_rtas(sPAPRMachineState *spapr, void *fdt) 7903f5dabceSDavid Gibson { 7913f5dabceSDavid Gibson int rtas; 7923f5dabceSDavid Gibson GString *hypertas = g_string_sized_new(256); 7933f5dabceSDavid Gibson GString *qemu_hypertas = g_string_sized_new(256); 7943f5dabceSDavid Gibson uint32_t refpoints[] = { cpu_to_be32(0x4), cpu_to_be32(0x4) }; 7953f5dabceSDavid Gibson uint64_t max_hotplug_addr = spapr->hotplug_memory.base + 7963f5dabceSDavid Gibson memory_region_size(&spapr->hotplug_memory.mr); 7973f5dabceSDavid Gibson uint32_t lrdr_capacity[] = { 7983f5dabceSDavid Gibson cpu_to_be32(max_hotplug_addr >> 32), 7993f5dabceSDavid Gibson cpu_to_be32(max_hotplug_addr & 0xffffffff), 8003f5dabceSDavid Gibson 0, cpu_to_be32(SPAPR_MEMORY_BLOCK_SIZE), 8013f5dabceSDavid Gibson cpu_to_be32(max_cpus / smp_threads), 8023f5dabceSDavid Gibson }; 8033f5dabceSDavid Gibson 8043f5dabceSDavid Gibson _FDT(rtas = fdt_add_subnode(fdt, 0, "rtas")); 8053f5dabceSDavid Gibson 8063f5dabceSDavid Gibson /* hypertas */ 8073f5dabceSDavid Gibson add_str(hypertas, "hcall-pft"); 8083f5dabceSDavid Gibson add_str(hypertas, "hcall-term"); 8093f5dabceSDavid Gibson add_str(hypertas, "hcall-dabr"); 8103f5dabceSDavid Gibson add_str(hypertas, "hcall-interrupt"); 8113f5dabceSDavid Gibson add_str(hypertas, "hcall-tce"); 8123f5dabceSDavid Gibson add_str(hypertas, "hcall-vio"); 8133f5dabceSDavid Gibson add_str(hypertas, "hcall-splpar"); 8143f5dabceSDavid Gibson add_str(hypertas, "hcall-bulk"); 8153f5dabceSDavid Gibson add_str(hypertas, "hcall-set-mode"); 8163f5dabceSDavid Gibson add_str(hypertas, "hcall-sprg0"); 8173f5dabceSDavid Gibson add_str(hypertas, "hcall-copy"); 8183f5dabceSDavid Gibson add_str(hypertas, "hcall-debug"); 8193f5dabceSDavid Gibson add_str(qemu_hypertas, "hcall-memop1"); 8203f5dabceSDavid Gibson 8213f5dabceSDavid Gibson if (!kvm_enabled() || kvmppc_spapr_use_multitce()) { 8223f5dabceSDavid Gibson add_str(hypertas, "hcall-multi-tce"); 8233f5dabceSDavid Gibson } 8243f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,hypertas-functions", 8253f5dabceSDavid Gibson hypertas->str, hypertas->len)); 8263f5dabceSDavid Gibson g_string_free(hypertas, TRUE); 8273f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "qemu,hypertas-functions", 8283f5dabceSDavid Gibson qemu_hypertas->str, qemu_hypertas->len)); 8293f5dabceSDavid Gibson g_string_free(qemu_hypertas, TRUE); 8303f5dabceSDavid Gibson 8313f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,associativity-reference-points", 8323f5dabceSDavid Gibson refpoints, sizeof(refpoints))); 8333f5dabceSDavid Gibson 8343f5dabceSDavid Gibson _FDT(fdt_setprop_cell(fdt, rtas, "rtas-error-log-max", 8353f5dabceSDavid Gibson RTAS_ERROR_LOG_MAX)); 8363f5dabceSDavid Gibson _FDT(fdt_setprop_cell(fdt, rtas, "rtas-event-scan-rate", 8373f5dabceSDavid Gibson RTAS_EVENT_SCAN_RATE)); 8383f5dabceSDavid Gibson 8393f5dabceSDavid Gibson if (msi_nonbroken) { 8403f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,change-msix-capable", NULL, 0)); 8413f5dabceSDavid Gibson } 8423f5dabceSDavid Gibson 8433f5dabceSDavid Gibson /* 8443f5dabceSDavid Gibson * According to PAPR, rtas ibm,os-term does not guarantee a return 8453f5dabceSDavid Gibson * back to the guest cpu. 8463f5dabceSDavid Gibson * 8473f5dabceSDavid Gibson * While an additional ibm,extended-os-term property indicates 8483f5dabceSDavid Gibson * that rtas call return will always occur. Set this property. 8493f5dabceSDavid Gibson */ 8503f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,extended-os-term", NULL, 0)); 8513f5dabceSDavid Gibson 8523f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,lrdr-capacity", 8533f5dabceSDavid Gibson lrdr_capacity, sizeof(lrdr_capacity))); 8543f5dabceSDavid Gibson 8553f5dabceSDavid Gibson spapr_dt_rtas_tokens(fdt, rtas); 8563f5dabceSDavid Gibson } 8573f5dabceSDavid Gibson 8589fb4541fSSam Bobroff /* Prepare ibm,arch-vec-5-platform-support, which indicates the MMU features 8599fb4541fSSam Bobroff * that the guest may request and thus the valid values for bytes 24..26 of 8609fb4541fSSam Bobroff * option vector 5: */ 8619fb4541fSSam Bobroff static void spapr_dt_ov5_platform_support(void *fdt, int chosen) 8629fb4541fSSam Bobroff { 863545d6e2bSSuraj Jitindar Singh PowerPCCPU *first_ppc_cpu = POWERPC_CPU(first_cpu); 864545d6e2bSSuraj Jitindar Singh 8659fb4541fSSam Bobroff char val[2 * 3] = { 8669fb4541fSSam Bobroff 24, 0x00, /* Hash/Radix, filled in below. */ 8679fb4541fSSam Bobroff 25, 0x00, /* Hash options: Segment Tables == no, GTSE == no. */ 8689fb4541fSSam Bobroff 26, 0x40, /* Radix options: GTSE == yes. */ 8699fb4541fSSam Bobroff }; 8709fb4541fSSam Bobroff 8719fb4541fSSam Bobroff if (kvm_enabled()) { 8729fb4541fSSam Bobroff if (kvmppc_has_cap_mmu_radix() && kvmppc_has_cap_mmu_hash_v3()) { 8739fb4541fSSam Bobroff val[1] = 0x80; /* OV5_MMU_BOTH */ 8749fb4541fSSam Bobroff } else if (kvmppc_has_cap_mmu_radix()) { 8759fb4541fSSam Bobroff val[1] = 0x40; /* OV5_MMU_RADIX_300 */ 8769fb4541fSSam Bobroff } else { 8779fb4541fSSam Bobroff val[1] = 0x00; /* Hash */ 8789fb4541fSSam Bobroff } 8799fb4541fSSam Bobroff } else { 880545d6e2bSSuraj Jitindar Singh if (first_ppc_cpu->env.mmu_model & POWERPC_MMU_V3) { 881545d6e2bSSuraj Jitindar Singh /* V3 MMU supports both hash and radix (with dynamic switching) */ 882545d6e2bSSuraj Jitindar Singh val[1] = 0xC0; 883545d6e2bSSuraj Jitindar Singh } else { 884545d6e2bSSuraj Jitindar Singh /* Otherwise we can only do hash */ 8859fb4541fSSam Bobroff val[1] = 0x00; 8869fb4541fSSam Bobroff } 887545d6e2bSSuraj Jitindar Singh } 8889fb4541fSSam Bobroff _FDT(fdt_setprop(fdt, chosen, "ibm,arch-vec-5-platform-support", 8899fb4541fSSam Bobroff val, sizeof(val))); 8909fb4541fSSam Bobroff } 8919fb4541fSSam Bobroff 8927c866c6aSDavid Gibson static void spapr_dt_chosen(sPAPRMachineState *spapr, void *fdt) 8937c866c6aSDavid Gibson { 8947c866c6aSDavid Gibson MachineState *machine = MACHINE(spapr); 8957c866c6aSDavid Gibson int chosen; 8967c866c6aSDavid Gibson const char *boot_device = machine->boot_order; 8977c866c6aSDavid Gibson char *stdout_path = spapr_vio_stdout_path(spapr->vio_bus); 8987c866c6aSDavid Gibson size_t cb = 0; 8997c866c6aSDavid Gibson char *bootlist = get_boot_devices_list(&cb, true); 9007c866c6aSDavid Gibson 9017c866c6aSDavid Gibson _FDT(chosen = fdt_add_subnode(fdt, 0, "chosen")); 9027c866c6aSDavid Gibson 9037c866c6aSDavid Gibson _FDT(fdt_setprop_string(fdt, chosen, "bootargs", machine->kernel_cmdline)); 9047c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "linux,initrd-start", 9057c866c6aSDavid Gibson spapr->initrd_base)); 9067c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "linux,initrd-end", 9077c866c6aSDavid Gibson spapr->initrd_base + spapr->initrd_size)); 9087c866c6aSDavid Gibson 9097c866c6aSDavid Gibson if (spapr->kernel_size) { 9107c866c6aSDavid Gibson uint64_t kprop[2] = { cpu_to_be64(KERNEL_LOAD_ADDR), 9117c866c6aSDavid Gibson cpu_to_be64(spapr->kernel_size) }; 9127c866c6aSDavid Gibson 9137c866c6aSDavid Gibson _FDT(fdt_setprop(fdt, chosen, "qemu,boot-kernel", 9147c866c6aSDavid Gibson &kprop, sizeof(kprop))); 9157c866c6aSDavid Gibson if (spapr->kernel_le) { 9167c866c6aSDavid Gibson _FDT(fdt_setprop(fdt, chosen, "qemu,boot-kernel-le", NULL, 0)); 9177c866c6aSDavid Gibson } 9187c866c6aSDavid Gibson } 9197c866c6aSDavid Gibson if (boot_menu) { 9207c866c6aSDavid Gibson _FDT((fdt_setprop_cell(fdt, chosen, "qemu,boot-menu", boot_menu))); 9217c866c6aSDavid Gibson } 9227c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "qemu,graphic-width", graphic_width)); 9237c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "qemu,graphic-height", graphic_height)); 9247c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "qemu,graphic-depth", graphic_depth)); 9257c866c6aSDavid Gibson 9267c866c6aSDavid Gibson if (cb && bootlist) { 9277c866c6aSDavid Gibson int i; 9287c866c6aSDavid Gibson 9297c866c6aSDavid Gibson for (i = 0; i < cb; i++) { 9307c866c6aSDavid Gibson if (bootlist[i] == '\n') { 9317c866c6aSDavid Gibson bootlist[i] = ' '; 9327c866c6aSDavid Gibson } 9337c866c6aSDavid Gibson } 9347c866c6aSDavid Gibson _FDT(fdt_setprop_string(fdt, chosen, "qemu,boot-list", bootlist)); 9357c866c6aSDavid Gibson } 9367c866c6aSDavid Gibson 9377c866c6aSDavid Gibson if (boot_device && strlen(boot_device)) { 9387c866c6aSDavid Gibson _FDT(fdt_setprop_string(fdt, chosen, "qemu,boot-device", boot_device)); 9397c866c6aSDavid Gibson } 9407c866c6aSDavid Gibson 9417c866c6aSDavid Gibson if (!spapr->has_graphics && stdout_path) { 9427c866c6aSDavid Gibson _FDT(fdt_setprop_string(fdt, chosen, "linux,stdout-path", stdout_path)); 9437c866c6aSDavid Gibson } 9447c866c6aSDavid Gibson 9459fb4541fSSam Bobroff spapr_dt_ov5_platform_support(fdt, chosen); 9469fb4541fSSam Bobroff 9477c866c6aSDavid Gibson g_free(stdout_path); 9487c866c6aSDavid Gibson g_free(bootlist); 9497c866c6aSDavid Gibson } 9507c866c6aSDavid Gibson 951fca5f2dcSDavid Gibson static void spapr_dt_hypervisor(sPAPRMachineState *spapr, void *fdt) 952fca5f2dcSDavid Gibson { 953fca5f2dcSDavid Gibson /* The /hypervisor node isn't in PAPR - this is a hack to allow PR 954fca5f2dcSDavid Gibson * KVM to work under pHyp with some guest co-operation */ 955fca5f2dcSDavid Gibson int hypervisor; 956fca5f2dcSDavid Gibson uint8_t hypercall[16]; 957fca5f2dcSDavid Gibson 958fca5f2dcSDavid Gibson _FDT(hypervisor = fdt_add_subnode(fdt, 0, "hypervisor")); 959fca5f2dcSDavid Gibson /* indicate KVM hypercall interface */ 960fca5f2dcSDavid Gibson _FDT(fdt_setprop_string(fdt, hypervisor, "compatible", "linux,kvm")); 961fca5f2dcSDavid Gibson if (kvmppc_has_cap_fixup_hcalls()) { 962fca5f2dcSDavid Gibson /* 963fca5f2dcSDavid Gibson * Older KVM versions with older guest kernels were broken 964fca5f2dcSDavid Gibson * with the magic page, don't allow the guest to map it. 965fca5f2dcSDavid Gibson */ 966fca5f2dcSDavid Gibson if (!kvmppc_get_hypercall(first_cpu->env_ptr, hypercall, 967fca5f2dcSDavid Gibson sizeof(hypercall))) { 968fca5f2dcSDavid Gibson _FDT(fdt_setprop(fdt, hypervisor, "hcall-instructions", 969fca5f2dcSDavid Gibson hypercall, sizeof(hypercall))); 970fca5f2dcSDavid Gibson } 971fca5f2dcSDavid Gibson } 972fca5f2dcSDavid Gibson } 973fca5f2dcSDavid Gibson 974997b6cfcSDavid Gibson static void *spapr_build_fdt(sPAPRMachineState *spapr, 97553018216SPaolo Bonzini hwaddr rtas_addr, 97653018216SPaolo Bonzini hwaddr rtas_size) 97753018216SPaolo Bonzini { 9785b2128d2SAlexander Graf MachineState *machine = MACHINE(qdev_get_machine()); 9793c0c47e3SDavid Gibson MachineClass *mc = MACHINE_GET_CLASS(machine); 980c20d332aSBharata B Rao sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(machine); 9817c866c6aSDavid Gibson int ret; 98253018216SPaolo Bonzini void *fdt; 98353018216SPaolo Bonzini sPAPRPHBState *phb; 984398a0bd5SDavid Gibson char *buf; 98571cd4dacSCédric Le Goater int smt = kvmppc_smt_threads(); 98653018216SPaolo Bonzini 987398a0bd5SDavid Gibson fdt = g_malloc0(FDT_MAX_SIZE); 988398a0bd5SDavid Gibson _FDT((fdt_create_empty_tree(fdt, FDT_MAX_SIZE))); 98953018216SPaolo Bonzini 990398a0bd5SDavid Gibson /* Root node */ 991398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "device_type", "chrp")); 992398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "model", "IBM pSeries (emulated by qemu)")); 993398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "compatible", "qemu,pseries")); 994398a0bd5SDavid Gibson 995398a0bd5SDavid Gibson /* 996398a0bd5SDavid Gibson * Add info to guest to indentify which host is it being run on 997398a0bd5SDavid Gibson * and what is the uuid of the guest 998398a0bd5SDavid Gibson */ 999398a0bd5SDavid Gibson if (kvmppc_get_host_model(&buf)) { 1000398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "host-model", buf)); 1001398a0bd5SDavid Gibson g_free(buf); 1002398a0bd5SDavid Gibson } 1003398a0bd5SDavid Gibson if (kvmppc_get_host_serial(&buf)) { 1004398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "host-serial", buf)); 1005398a0bd5SDavid Gibson g_free(buf); 1006398a0bd5SDavid Gibson } 1007398a0bd5SDavid Gibson 1008398a0bd5SDavid Gibson buf = qemu_uuid_unparse_strdup(&qemu_uuid); 1009398a0bd5SDavid Gibson 1010398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "vm,uuid", buf)); 1011398a0bd5SDavid Gibson if (qemu_uuid_set) { 1012398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "system-id", buf)); 1013398a0bd5SDavid Gibson } 1014398a0bd5SDavid Gibson g_free(buf); 1015398a0bd5SDavid Gibson 1016398a0bd5SDavid Gibson if (qemu_get_vm_name()) { 1017398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "ibm,partition-name", 1018398a0bd5SDavid Gibson qemu_get_vm_name())); 1019398a0bd5SDavid Gibson } 1020398a0bd5SDavid Gibson 1021398a0bd5SDavid Gibson _FDT(fdt_setprop_cell(fdt, 0, "#address-cells", 2)); 1022398a0bd5SDavid Gibson _FDT(fdt_setprop_cell(fdt, 0, "#size-cells", 2)); 102353018216SPaolo Bonzini 10249b9a1908SDavid Gibson /* /interrupt controller */ 102571cd4dacSCédric Le Goater spapr_dt_xics(DIV_ROUND_UP(max_cpus * smt, smp_threads), fdt, PHANDLE_XICP); 10269b9a1908SDavid Gibson 1027e8f986fcSBharata B Rao ret = spapr_populate_memory(spapr, fdt); 1028e8f986fcSBharata B Rao if (ret < 0) { 1029ce9863b7SCédric Le Goater error_report("couldn't setup memory nodes in fdt"); 1030e8f986fcSBharata B Rao exit(1); 103153018216SPaolo Bonzini } 103253018216SPaolo Bonzini 1033bf5a6696SDavid Gibson /* /vdevice */ 1034bf5a6696SDavid Gibson spapr_dt_vdevice(spapr->vio_bus, fdt); 103553018216SPaolo Bonzini 10364d9392beSThomas Huth if (object_resolve_path_type("", TYPE_SPAPR_RNG, NULL)) { 10374d9392beSThomas Huth ret = spapr_rng_populate_dt(fdt); 10384d9392beSThomas Huth if (ret < 0) { 1039ce9863b7SCédric Le Goater error_report("could not set up rng device in the fdt"); 10404d9392beSThomas Huth exit(1); 10414d9392beSThomas Huth } 10424d9392beSThomas Huth } 10434d9392beSThomas Huth 104453018216SPaolo Bonzini QLIST_FOREACH(phb, &spapr->phbs, list) { 104553018216SPaolo Bonzini ret = spapr_populate_pci_dt(phb, PHANDLE_XICP, fdt); 104653018216SPaolo Bonzini if (ret < 0) { 1047da34fed7SThomas Huth error_report("couldn't setup PCI devices in fdt"); 104853018216SPaolo Bonzini exit(1); 104953018216SPaolo Bonzini } 1050da34fed7SThomas Huth } 105153018216SPaolo Bonzini 10520da6f3feSBharata B Rao /* cpus */ 10530da6f3feSBharata B Rao spapr_populate_cpus_dt_node(fdt, spapr); 105453018216SPaolo Bonzini 1055c20d332aSBharata B Rao if (smc->dr_lmb_enabled) { 1056c20d332aSBharata B Rao _FDT(spapr_drc_populate_dt(fdt, 0, NULL, SPAPR_DR_CONNECTOR_TYPE_LMB)); 1057c20d332aSBharata B Rao } 1058c20d332aSBharata B Rao 1059c5514d0eSIgor Mammedov if (mc->has_hotpluggable_cpus) { 1060af81cf32SBharata B Rao int offset = fdt_path_offset(fdt, "/cpus"); 1061af81cf32SBharata B Rao ret = spapr_drc_populate_dt(fdt, offset, NULL, 1062af81cf32SBharata B Rao SPAPR_DR_CONNECTOR_TYPE_CPU); 1063af81cf32SBharata B Rao if (ret < 0) { 1064af81cf32SBharata B Rao error_report("Couldn't set up CPU DR device tree properties"); 1065af81cf32SBharata B Rao exit(1); 1066af81cf32SBharata B Rao } 1067af81cf32SBharata B Rao } 1068af81cf32SBharata B Rao 1069ffb1e275SDavid Gibson /* /event-sources */ 1070ffbb1705SMichael Roth spapr_dt_events(spapr, fdt); 1071ffb1e275SDavid Gibson 10723f5dabceSDavid Gibson /* /rtas */ 10733f5dabceSDavid Gibson spapr_dt_rtas(spapr, fdt); 10743f5dabceSDavid Gibson 10757c866c6aSDavid Gibson /* /chosen */ 10767c866c6aSDavid Gibson spapr_dt_chosen(spapr, fdt); 1077cf6e5223SDavid Gibson 1078fca5f2dcSDavid Gibson /* /hypervisor */ 1079fca5f2dcSDavid Gibson if (kvm_enabled()) { 1080fca5f2dcSDavid Gibson spapr_dt_hypervisor(spapr, fdt); 1081fca5f2dcSDavid Gibson } 1082fca5f2dcSDavid Gibson 1083cf6e5223SDavid Gibson /* Build memory reserve map */ 1084cf6e5223SDavid Gibson if (spapr->kernel_size) { 1085cf6e5223SDavid Gibson _FDT((fdt_add_mem_rsv(fdt, KERNEL_LOAD_ADDR, spapr->kernel_size))); 1086cf6e5223SDavid Gibson } 1087cf6e5223SDavid Gibson if (spapr->initrd_size) { 1088cf6e5223SDavid Gibson _FDT((fdt_add_mem_rsv(fdt, spapr->initrd_base, spapr->initrd_size))); 1089cf6e5223SDavid Gibson } 1090cf6e5223SDavid Gibson 10916787d27bSMichael Roth /* ibm,client-architecture-support updates */ 10926787d27bSMichael Roth ret = spapr_dt_cas_updates(spapr, fdt, spapr->ov5_cas); 10936787d27bSMichael Roth if (ret < 0) { 10946787d27bSMichael Roth error_report("couldn't setup CAS properties fdt"); 10956787d27bSMichael Roth exit(1); 10966787d27bSMichael Roth } 10976787d27bSMichael Roth 1098997b6cfcSDavid Gibson return fdt; 109953018216SPaolo Bonzini } 110053018216SPaolo Bonzini 110153018216SPaolo Bonzini static uint64_t translate_kernel_address(void *opaque, uint64_t addr) 110253018216SPaolo Bonzini { 110353018216SPaolo Bonzini return (addr & 0x0fffffff) + KERNEL_LOAD_ADDR; 110453018216SPaolo Bonzini } 110553018216SPaolo Bonzini 11061d1be34dSDavid Gibson static void emulate_spapr_hypercall(PPCVirtualHypervisor *vhyp, 11071d1be34dSDavid Gibson PowerPCCPU *cpu) 110853018216SPaolo Bonzini { 110953018216SPaolo Bonzini CPUPPCState *env = &cpu->env; 111053018216SPaolo Bonzini 11118d04fb55SJan Kiszka /* The TCG path should also be holding the BQL at this point */ 11128d04fb55SJan Kiszka g_assert(qemu_mutex_iothread_locked()); 11138d04fb55SJan Kiszka 111453018216SPaolo Bonzini if (msr_pr) { 111553018216SPaolo Bonzini hcall_dprintf("Hypercall made with MSR[PR]=1\n"); 111653018216SPaolo Bonzini env->gpr[3] = H_PRIVILEGE; 111753018216SPaolo Bonzini } else { 111853018216SPaolo Bonzini env->gpr[3] = spapr_hypercall(cpu, env->gpr[3], &env->gpr[4]); 111953018216SPaolo Bonzini } 112053018216SPaolo Bonzini } 112153018216SPaolo Bonzini 11229861bb3eSSuraj Jitindar Singh static uint64_t spapr_get_patbe(PPCVirtualHypervisor *vhyp) 11239861bb3eSSuraj Jitindar Singh { 11249861bb3eSSuraj Jitindar Singh sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 11259861bb3eSSuraj Jitindar Singh 11269861bb3eSSuraj Jitindar Singh return spapr->patb_entry; 11279861bb3eSSuraj Jitindar Singh } 11289861bb3eSSuraj Jitindar Singh 1129e6b8fd24SSamuel Mendoza-Jonas #define HPTE(_table, _i) (void *)(((uint64_t *)(_table)) + ((_i) * 2)) 1130e6b8fd24SSamuel Mendoza-Jonas #define HPTE_VALID(_hpte) (tswap64(*((uint64_t *)(_hpte))) & HPTE64_V_VALID) 1131e6b8fd24SSamuel Mendoza-Jonas #define HPTE_DIRTY(_hpte) (tswap64(*((uint64_t *)(_hpte))) & HPTE64_V_HPTE_DIRTY) 1132e6b8fd24SSamuel Mendoza-Jonas #define CLEAN_HPTE(_hpte) ((*(uint64_t *)(_hpte)) &= tswap64(~HPTE64_V_HPTE_DIRTY)) 1133e6b8fd24SSamuel Mendoza-Jonas #define DIRTY_HPTE(_hpte) ((*(uint64_t *)(_hpte)) |= tswap64(HPTE64_V_HPTE_DIRTY)) 1134e6b8fd24SSamuel Mendoza-Jonas 1135715c5407SDavid Gibson /* 1136715c5407SDavid Gibson * Get the fd to access the kernel htab, re-opening it if necessary 1137715c5407SDavid Gibson */ 1138715c5407SDavid Gibson static int get_htab_fd(sPAPRMachineState *spapr) 1139715c5407SDavid Gibson { 1140715c5407SDavid Gibson if (spapr->htab_fd >= 0) { 1141715c5407SDavid Gibson return spapr->htab_fd; 1142715c5407SDavid Gibson } 1143715c5407SDavid Gibson 1144715c5407SDavid Gibson spapr->htab_fd = kvmppc_get_htab_fd(false); 1145715c5407SDavid Gibson if (spapr->htab_fd < 0) { 1146715c5407SDavid Gibson error_report("Unable to open fd for reading hash table from KVM: %s", 1147715c5407SDavid Gibson strerror(errno)); 1148715c5407SDavid Gibson } 1149715c5407SDavid Gibson 1150715c5407SDavid Gibson return spapr->htab_fd; 1151715c5407SDavid Gibson } 1152715c5407SDavid Gibson 1153b4db5413SSuraj Jitindar Singh void close_htab_fd(sPAPRMachineState *spapr) 1154715c5407SDavid Gibson { 1155715c5407SDavid Gibson if (spapr->htab_fd >= 0) { 1156715c5407SDavid Gibson close(spapr->htab_fd); 1157715c5407SDavid Gibson } 1158715c5407SDavid Gibson spapr->htab_fd = -1; 1159715c5407SDavid Gibson } 1160715c5407SDavid Gibson 1161e57ca75cSDavid Gibson static hwaddr spapr_hpt_mask(PPCVirtualHypervisor *vhyp) 1162e57ca75cSDavid Gibson { 1163e57ca75cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 1164e57ca75cSDavid Gibson 1165e57ca75cSDavid Gibson return HTAB_SIZE(spapr) / HASH_PTEG_SIZE_64 - 1; 1166e57ca75cSDavid Gibson } 1167e57ca75cSDavid Gibson 1168e57ca75cSDavid Gibson static const ppc_hash_pte64_t *spapr_map_hptes(PPCVirtualHypervisor *vhyp, 1169e57ca75cSDavid Gibson hwaddr ptex, int n) 1170e57ca75cSDavid Gibson { 1171e57ca75cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 1172e57ca75cSDavid Gibson hwaddr pte_offset = ptex * HASH_PTE_SIZE_64; 1173e57ca75cSDavid Gibson 1174e57ca75cSDavid Gibson if (!spapr->htab) { 1175e57ca75cSDavid Gibson /* 1176e57ca75cSDavid Gibson * HTAB is controlled by KVM. Fetch into temporary buffer 1177e57ca75cSDavid Gibson */ 1178e57ca75cSDavid Gibson ppc_hash_pte64_t *hptes = g_malloc(n * HASH_PTE_SIZE_64); 1179e57ca75cSDavid Gibson kvmppc_read_hptes(hptes, ptex, n); 1180e57ca75cSDavid Gibson return hptes; 1181e57ca75cSDavid Gibson } 1182e57ca75cSDavid Gibson 1183e57ca75cSDavid Gibson /* 1184e57ca75cSDavid Gibson * HTAB is controlled by QEMU. Just point to the internally 1185e57ca75cSDavid Gibson * accessible PTEG. 1186e57ca75cSDavid Gibson */ 1187e57ca75cSDavid Gibson return (const ppc_hash_pte64_t *)(spapr->htab + pte_offset); 1188e57ca75cSDavid Gibson } 1189e57ca75cSDavid Gibson 1190e57ca75cSDavid Gibson static void spapr_unmap_hptes(PPCVirtualHypervisor *vhyp, 1191e57ca75cSDavid Gibson const ppc_hash_pte64_t *hptes, 1192e57ca75cSDavid Gibson hwaddr ptex, int n) 1193e57ca75cSDavid Gibson { 1194e57ca75cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 1195e57ca75cSDavid Gibson 1196e57ca75cSDavid Gibson if (!spapr->htab) { 1197e57ca75cSDavid Gibson g_free((void *)hptes); 1198e57ca75cSDavid Gibson } 1199e57ca75cSDavid Gibson 1200e57ca75cSDavid Gibson /* Nothing to do for qemu managed HPT */ 1201e57ca75cSDavid Gibson } 1202e57ca75cSDavid Gibson 1203e57ca75cSDavid Gibson static void spapr_store_hpte(PPCVirtualHypervisor *vhyp, hwaddr ptex, 1204e57ca75cSDavid Gibson uint64_t pte0, uint64_t pte1) 1205e57ca75cSDavid Gibson { 1206e57ca75cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 1207e57ca75cSDavid Gibson hwaddr offset = ptex * HASH_PTE_SIZE_64; 1208e57ca75cSDavid Gibson 1209e57ca75cSDavid Gibson if (!spapr->htab) { 1210e57ca75cSDavid Gibson kvmppc_write_hpte(ptex, pte0, pte1); 1211e57ca75cSDavid Gibson } else { 1212e57ca75cSDavid Gibson stq_p(spapr->htab + offset, pte0); 1213e57ca75cSDavid Gibson stq_p(spapr->htab + offset + HASH_PTE_SIZE_64 / 2, pte1); 1214e57ca75cSDavid Gibson } 1215e57ca75cSDavid Gibson } 1216e57ca75cSDavid Gibson 12178dfe8e7fSDavid Gibson static int spapr_hpt_shift_for_ramsize(uint64_t ramsize) 12188dfe8e7fSDavid Gibson { 12198dfe8e7fSDavid Gibson int shift; 12208dfe8e7fSDavid Gibson 12218dfe8e7fSDavid Gibson /* We aim for a hash table of size 1/128 the size of RAM (rounded 12228dfe8e7fSDavid Gibson * up). The PAPR recommendation is actually 1/64 of RAM size, but 12238dfe8e7fSDavid Gibson * that's much more than is needed for Linux guests */ 12248dfe8e7fSDavid Gibson shift = ctz64(pow2ceil(ramsize)) - 7; 12258dfe8e7fSDavid Gibson shift = MAX(shift, 18); /* Minimum architected size */ 12268dfe8e7fSDavid Gibson shift = MIN(shift, 46); /* Maximum architected size */ 12278dfe8e7fSDavid Gibson return shift; 12288dfe8e7fSDavid Gibson } 12298dfe8e7fSDavid Gibson 1230c5f54f3eSDavid Gibson static void spapr_reallocate_hpt(sPAPRMachineState *spapr, int shift, 1231c5f54f3eSDavid Gibson Error **errp) 123253018216SPaolo Bonzini { 1233c5f54f3eSDavid Gibson long rc; 123453018216SPaolo Bonzini 1235c5f54f3eSDavid Gibson /* Clean up any HPT info from a previous boot */ 1236c5f54f3eSDavid Gibson g_free(spapr->htab); 1237c5f54f3eSDavid Gibson spapr->htab = NULL; 1238c5f54f3eSDavid Gibson spapr->htab_shift = 0; 1239c5f54f3eSDavid Gibson close_htab_fd(spapr); 124053018216SPaolo Bonzini 1241c5f54f3eSDavid Gibson rc = kvmppc_reset_htab(shift); 1242c5f54f3eSDavid Gibson if (rc < 0) { 1243c5f54f3eSDavid Gibson /* kernel-side HPT needed, but couldn't allocate one */ 1244c5f54f3eSDavid Gibson error_setg_errno(errp, errno, 1245c5f54f3eSDavid Gibson "Failed to allocate KVM HPT of order %d (try smaller maxmem?)", 1246c5f54f3eSDavid Gibson shift); 1247c5f54f3eSDavid Gibson /* This is almost certainly fatal, but if the caller really 1248c5f54f3eSDavid Gibson * wants to carry on with shift == 0, it's welcome to try */ 1249c5f54f3eSDavid Gibson } else if (rc > 0) { 1250c5f54f3eSDavid Gibson /* kernel-side HPT allocated */ 1251c5f54f3eSDavid Gibson if (rc != shift) { 1252c5f54f3eSDavid Gibson error_setg(errp, 1253c5f54f3eSDavid Gibson "Requested order %d HPT, but kernel allocated order %ld (try smaller maxmem?)", 1254c5f54f3eSDavid Gibson shift, rc); 12557735fedaSBharata B Rao } 12567735fedaSBharata B Rao 125753018216SPaolo Bonzini spapr->htab_shift = shift; 1258c18ad9a5SDavid Gibson spapr->htab = NULL; 1259b817772aSBharata B Rao } else { 1260c5f54f3eSDavid Gibson /* kernel-side HPT not needed, allocate in userspace instead */ 1261c5f54f3eSDavid Gibson size_t size = 1ULL << shift; 1262c5f54f3eSDavid Gibson int i; 126301a57972SSamuel Mendoza-Jonas 1264c5f54f3eSDavid Gibson spapr->htab = qemu_memalign(size, size); 1265c5f54f3eSDavid Gibson if (!spapr->htab) { 1266c5f54f3eSDavid Gibson error_setg_errno(errp, errno, 1267c5f54f3eSDavid Gibson "Could not allocate HPT of order %d", shift); 1268c5f54f3eSDavid Gibson return; 1269b817772aSBharata B Rao } 1270b817772aSBharata B Rao 1271c5f54f3eSDavid Gibson memset(spapr->htab, 0, size); 1272c5f54f3eSDavid Gibson spapr->htab_shift = shift; 1273b817772aSBharata B Rao 1274c5f54f3eSDavid Gibson for (i = 0; i < size / HASH_PTE_SIZE_64; i++) { 1275c5f54f3eSDavid Gibson DIRTY_HPTE(HPTE(spapr->htab, i)); 12767735fedaSBharata B Rao } 127753018216SPaolo Bonzini } 127853018216SPaolo Bonzini } 127953018216SPaolo Bonzini 1280b4db5413SSuraj Jitindar Singh void spapr_setup_hpt_and_vrma(sPAPRMachineState *spapr) 1281b4db5413SSuraj Jitindar Singh { 1282b4db5413SSuraj Jitindar Singh spapr_reallocate_hpt(spapr, 1283b4db5413SSuraj Jitindar Singh spapr_hpt_shift_for_ramsize(MACHINE(spapr)->maxram_size), 1284b4db5413SSuraj Jitindar Singh &error_fatal); 1285b4db5413SSuraj Jitindar Singh if (spapr->vrma_adjust) { 1286b4db5413SSuraj Jitindar Singh spapr->rma_size = kvmppc_rma_size(spapr_node0_size(), 1287b4db5413SSuraj Jitindar Singh spapr->htab_shift); 1288b4db5413SSuraj Jitindar Singh } 1289b4db5413SSuraj Jitindar Singh /* We're setting up a hash table, so that means we're not radix */ 1290b4db5413SSuraj Jitindar Singh spapr->patb_entry = 0; 1291b4db5413SSuraj Jitindar Singh } 1292b4db5413SSuraj Jitindar Singh 12934f01a637SDavid Gibson static void find_unknown_sysbus_device(SysBusDevice *sbdev, void *opaque) 12949e3f9733SAlexander Graf { 12959e3f9733SAlexander Graf bool matched = false; 12969e3f9733SAlexander Graf 12979e3f9733SAlexander Graf if (object_dynamic_cast(OBJECT(sbdev), TYPE_SPAPR_PCI_HOST_BRIDGE)) { 12989e3f9733SAlexander Graf matched = true; 12999e3f9733SAlexander Graf } 13009e3f9733SAlexander Graf 13019e3f9733SAlexander Graf if (!matched) { 13029e3f9733SAlexander Graf error_report("Device %s is not supported by this machine yet.", 13039e3f9733SAlexander Graf qdev_fw_name(DEVICE(sbdev))); 13049e3f9733SAlexander Graf exit(1); 13059e3f9733SAlexander Graf } 13069e3f9733SAlexander Graf } 13079e3f9733SAlexander Graf 130853018216SPaolo Bonzini static void ppc_spapr_reset(void) 130953018216SPaolo Bonzini { 1310c5f54f3eSDavid Gibson MachineState *machine = MACHINE(qdev_get_machine()); 1311c5f54f3eSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(machine); 1312182735efSAndreas Färber PowerPCCPU *first_ppc_cpu; 1313b7d1f77aSBenjamin Herrenschmidt uint32_t rtas_limit; 1314cae172abSDavid Gibson hwaddr rtas_addr, fdt_addr; 1315997b6cfcSDavid Gibson void *fdt; 1316997b6cfcSDavid Gibson int rc; 1317259186a7SAndreas Färber 13189e3f9733SAlexander Graf /* Check for unknown sysbus devices */ 13199e3f9733SAlexander Graf foreach_dynamic_sysbus_device(find_unknown_sysbus_device, NULL); 13209e3f9733SAlexander Graf 1321b4db5413SSuraj Jitindar Singh if (kvm_enabled() && kvmppc_has_cap_mmu_radix()) { 1322b4db5413SSuraj Jitindar Singh /* If using KVM with radix mode available, VCPUs can be started 1323b4db5413SSuraj Jitindar Singh * without a HPT because KVM will start them in radix mode. 1324b4db5413SSuraj Jitindar Singh * Set the GR bit in PATB so that we know there is no HPT. */ 1325b4db5413SSuraj Jitindar Singh spapr->patb_entry = PATBE1_GR; 1326b4db5413SSuraj Jitindar Singh } else { 13279861bb3eSSuraj Jitindar Singh spapr->patb_entry = 0; 1328b4db5413SSuraj Jitindar Singh spapr_setup_hpt_and_vrma(spapr); 1329c5f54f3eSDavid Gibson } 133053018216SPaolo Bonzini 133153018216SPaolo Bonzini qemu_devices_reset(); 133253018216SPaolo Bonzini 1333b7d1f77aSBenjamin Herrenschmidt /* 1334b7d1f77aSBenjamin Herrenschmidt * We place the device tree and RTAS just below either the top of the RMA, 1335b7d1f77aSBenjamin Herrenschmidt * or just below 2GB, whichever is lowere, so that it can be 1336b7d1f77aSBenjamin Herrenschmidt * processed with 32-bit real mode code if necessary 1337b7d1f77aSBenjamin Herrenschmidt */ 1338b7d1f77aSBenjamin Herrenschmidt rtas_limit = MIN(spapr->rma_size, RTAS_MAX_ADDR); 1339cae172abSDavid Gibson rtas_addr = rtas_limit - RTAS_MAX_SIZE; 1340cae172abSDavid Gibson fdt_addr = rtas_addr - FDT_MAX_SIZE; 1341b7d1f77aSBenjamin Herrenschmidt 13426787d27bSMichael Roth /* if this reset wasn't generated by CAS, we should reset our 13436787d27bSMichael Roth * negotiated options and start from scratch */ 13446787d27bSMichael Roth if (!spapr->cas_reboot) { 13456787d27bSMichael Roth spapr_ovec_cleanup(spapr->ov5_cas); 13466787d27bSMichael Roth spapr->ov5_cas = spapr_ovec_new(); 13476787d27bSMichael Roth } 13486787d27bSMichael Roth 1349cae172abSDavid Gibson fdt = spapr_build_fdt(spapr, rtas_addr, spapr->rtas_size); 135053018216SPaolo Bonzini 13512cac78c1SDavid Gibson spapr_load_rtas(spapr, fdt, rtas_addr); 1352b7d1f77aSBenjamin Herrenschmidt 1353997b6cfcSDavid Gibson rc = fdt_pack(fdt); 1354997b6cfcSDavid Gibson 1355997b6cfcSDavid Gibson /* Should only fail if we've built a corrupted tree */ 1356997b6cfcSDavid Gibson assert(rc == 0); 1357997b6cfcSDavid Gibson 1358997b6cfcSDavid Gibson if (fdt_totalsize(fdt) > FDT_MAX_SIZE) { 1359997b6cfcSDavid Gibson error_report("FDT too big ! 0x%x bytes (max is 0x%x)", 1360997b6cfcSDavid Gibson fdt_totalsize(fdt), FDT_MAX_SIZE); 1361997b6cfcSDavid Gibson exit(1); 1362997b6cfcSDavid Gibson } 1363997b6cfcSDavid Gibson 1364997b6cfcSDavid Gibson /* Load the fdt */ 1365997b6cfcSDavid Gibson qemu_fdt_dumpdtb(fdt, fdt_totalsize(fdt)); 1366cae172abSDavid Gibson cpu_physical_memory_write(fdt_addr, fdt, fdt_totalsize(fdt)); 1367997b6cfcSDavid Gibson g_free(fdt); 1368997b6cfcSDavid Gibson 136953018216SPaolo Bonzini /* Set up the entry state */ 1370182735efSAndreas Färber first_ppc_cpu = POWERPC_CPU(first_cpu); 1371cae172abSDavid Gibson first_ppc_cpu->env.gpr[3] = fdt_addr; 1372182735efSAndreas Färber first_ppc_cpu->env.gpr[5] = 0; 1373182735efSAndreas Färber first_cpu->halted = 0; 13741b718907SDavid Gibson first_ppc_cpu->env.nip = SPAPR_ENTRY_POINT; 137553018216SPaolo Bonzini 13766787d27bSMichael Roth spapr->cas_reboot = false; 137753018216SPaolo Bonzini } 137853018216SPaolo Bonzini 137928e02042SDavid Gibson static void spapr_create_nvram(sPAPRMachineState *spapr) 138053018216SPaolo Bonzini { 13812ff3de68SMarkus Armbruster DeviceState *dev = qdev_create(&spapr->vio_bus->bus, "spapr-nvram"); 13823978b863SPaolo Bonzini DriveInfo *dinfo = drive_get(IF_PFLASH, 0, 0); 138353018216SPaolo Bonzini 13843978b863SPaolo Bonzini if (dinfo) { 13856231a6daSMarkus Armbruster qdev_prop_set_drive(dev, "drive", blk_by_legacy_dinfo(dinfo), 13866231a6daSMarkus Armbruster &error_fatal); 138753018216SPaolo Bonzini } 138853018216SPaolo Bonzini 138953018216SPaolo Bonzini qdev_init_nofail(dev); 139053018216SPaolo Bonzini 139153018216SPaolo Bonzini spapr->nvram = (struct sPAPRNVRAM *)dev; 139253018216SPaolo Bonzini } 139353018216SPaolo Bonzini 139428e02042SDavid Gibson static void spapr_rtc_create(sPAPRMachineState *spapr) 139528df36a1SDavid Gibson { 1396147ff807SCédric Le Goater object_initialize(&spapr->rtc, sizeof(spapr->rtc), TYPE_SPAPR_RTC); 1397147ff807SCédric Le Goater object_property_add_child(OBJECT(spapr), "rtc", OBJECT(&spapr->rtc), 1398147ff807SCédric Le Goater &error_fatal); 1399147ff807SCédric Le Goater object_property_set_bool(OBJECT(&spapr->rtc), true, "realized", 1400147ff807SCédric Le Goater &error_fatal); 1401147ff807SCédric Le Goater object_property_add_alias(OBJECT(spapr), "rtc-time", OBJECT(&spapr->rtc), 1402147ff807SCédric Le Goater "date", &error_fatal); 140328df36a1SDavid Gibson } 140428df36a1SDavid Gibson 140553018216SPaolo Bonzini /* Returns whether we want to use VGA or not */ 140614c6a894SDavid Gibson static bool spapr_vga_init(PCIBus *pci_bus, Error **errp) 140753018216SPaolo Bonzini { 140853018216SPaolo Bonzini switch (vga_interface_type) { 140953018216SPaolo Bonzini case VGA_NONE: 14107effdaa3SMark Wu return false; 14117effdaa3SMark Wu case VGA_DEVICE: 14127effdaa3SMark Wu return true; 141353018216SPaolo Bonzini case VGA_STD: 1414b798c190SBenjamin Herrenschmidt case VGA_VIRTIO: 141553018216SPaolo Bonzini return pci_vga_init(pci_bus) != NULL; 141653018216SPaolo Bonzini default: 141714c6a894SDavid Gibson error_setg(errp, 141814c6a894SDavid Gibson "Unsupported VGA mode, only -vga std or -vga virtio is supported"); 141914c6a894SDavid Gibson return false; 142053018216SPaolo Bonzini } 142153018216SPaolo Bonzini } 142253018216SPaolo Bonzini 1423880ae7deSDavid Gibson static int spapr_post_load(void *opaque, int version_id) 1424880ae7deSDavid Gibson { 142528e02042SDavid Gibson sPAPRMachineState *spapr = (sPAPRMachineState *)opaque; 1426880ae7deSDavid Gibson int err = 0; 1427880ae7deSDavid Gibson 1428a7ff1212SCédric Le Goater if (!object_dynamic_cast(OBJECT(spapr->ics), TYPE_ICS_KVM)) { 14295bc8d26dSCédric Le Goater CPUState *cs; 14305bc8d26dSCédric Le Goater CPU_FOREACH(cs) { 14315bc8d26dSCédric Le Goater PowerPCCPU *cpu = POWERPC_CPU(cs); 14325bc8d26dSCédric Le Goater icp_resend(ICP(cpu->intc)); 1433a7ff1212SCédric Le Goater } 1434a7ff1212SCédric Le Goater } 1435a7ff1212SCédric Le Goater 1436631b22eaSStefan Weil /* In earlier versions, there was no separate qdev for the PAPR 1437880ae7deSDavid Gibson * RTC, so the RTC offset was stored directly in sPAPREnvironment. 1438880ae7deSDavid Gibson * So when migrating from those versions, poke the incoming offset 1439880ae7deSDavid Gibson * value into the RTC device */ 1440880ae7deSDavid Gibson if (version_id < 3) { 1441147ff807SCédric Le Goater err = spapr_rtc_import_offset(&spapr->rtc, spapr->rtc_offset); 1442880ae7deSDavid Gibson } 1443880ae7deSDavid Gibson 1444880ae7deSDavid Gibson return err; 1445880ae7deSDavid Gibson } 1446880ae7deSDavid Gibson 1447880ae7deSDavid Gibson static bool version_before_3(void *opaque, int version_id) 1448880ae7deSDavid Gibson { 1449880ae7deSDavid Gibson return version_id < 3; 1450880ae7deSDavid Gibson } 1451880ae7deSDavid Gibson 145262ef3760SMichael Roth static bool spapr_ov5_cas_needed(void *opaque) 145362ef3760SMichael Roth { 145462ef3760SMichael Roth sPAPRMachineState *spapr = opaque; 145562ef3760SMichael Roth sPAPROptionVector *ov5_mask = spapr_ovec_new(); 145662ef3760SMichael Roth sPAPROptionVector *ov5_legacy = spapr_ovec_new(); 145762ef3760SMichael Roth sPAPROptionVector *ov5_removed = spapr_ovec_new(); 145862ef3760SMichael Roth bool cas_needed; 145962ef3760SMichael Roth 146062ef3760SMichael Roth /* Prior to the introduction of sPAPROptionVector, we had two option 146162ef3760SMichael Roth * vectors we dealt with: OV5_FORM1_AFFINITY, and OV5_DRCONF_MEMORY. 146262ef3760SMichael Roth * Both of these options encode machine topology into the device-tree 146362ef3760SMichael Roth * in such a way that the now-booted OS should still be able to interact 146462ef3760SMichael Roth * appropriately with QEMU regardless of what options were actually 146562ef3760SMichael Roth * negotiatied on the source side. 146662ef3760SMichael Roth * 146762ef3760SMichael Roth * As such, we can avoid migrating the CAS-negotiated options if these 146862ef3760SMichael Roth * are the only options available on the current machine/platform. 146962ef3760SMichael Roth * Since these are the only options available for pseries-2.7 and 147062ef3760SMichael Roth * earlier, this allows us to maintain old->new/new->old migration 147162ef3760SMichael Roth * compatibility. 147262ef3760SMichael Roth * 147362ef3760SMichael Roth * For QEMU 2.8+, there are additional CAS-negotiatable options available 147462ef3760SMichael Roth * via default pseries-2.8 machines and explicit command-line parameters. 147562ef3760SMichael Roth * Some of these options, like OV5_HP_EVT, *do* require QEMU to be aware 147662ef3760SMichael Roth * of the actual CAS-negotiated values to continue working properly. For 147762ef3760SMichael Roth * example, availability of memory unplug depends on knowing whether 147862ef3760SMichael Roth * OV5_HP_EVT was negotiated via CAS. 147962ef3760SMichael Roth * 148062ef3760SMichael Roth * Thus, for any cases where the set of available CAS-negotiatable 148162ef3760SMichael Roth * options extends beyond OV5_FORM1_AFFINITY and OV5_DRCONF_MEMORY, we 148262ef3760SMichael Roth * include the CAS-negotiated options in the migration stream. 148362ef3760SMichael Roth */ 148462ef3760SMichael Roth spapr_ovec_set(ov5_mask, OV5_FORM1_AFFINITY); 148562ef3760SMichael Roth spapr_ovec_set(ov5_mask, OV5_DRCONF_MEMORY); 148662ef3760SMichael Roth 148762ef3760SMichael Roth /* spapr_ovec_diff returns true if bits were removed. we avoid using 148862ef3760SMichael Roth * the mask itself since in the future it's possible "legacy" bits may be 148962ef3760SMichael Roth * removed via machine options, which could generate a false positive 149062ef3760SMichael Roth * that breaks migration. 149162ef3760SMichael Roth */ 149262ef3760SMichael Roth spapr_ovec_intersect(ov5_legacy, spapr->ov5, ov5_mask); 149362ef3760SMichael Roth cas_needed = spapr_ovec_diff(ov5_removed, spapr->ov5, ov5_legacy); 149462ef3760SMichael Roth 149562ef3760SMichael Roth spapr_ovec_cleanup(ov5_mask); 149662ef3760SMichael Roth spapr_ovec_cleanup(ov5_legacy); 149762ef3760SMichael Roth spapr_ovec_cleanup(ov5_removed); 149862ef3760SMichael Roth 149962ef3760SMichael Roth return cas_needed; 150062ef3760SMichael Roth } 150162ef3760SMichael Roth 150262ef3760SMichael Roth static const VMStateDescription vmstate_spapr_ov5_cas = { 150362ef3760SMichael Roth .name = "spapr_option_vector_ov5_cas", 150462ef3760SMichael Roth .version_id = 1, 150562ef3760SMichael Roth .minimum_version_id = 1, 150662ef3760SMichael Roth .needed = spapr_ov5_cas_needed, 150762ef3760SMichael Roth .fields = (VMStateField[]) { 150862ef3760SMichael Roth VMSTATE_STRUCT_POINTER_V(ov5_cas, sPAPRMachineState, 1, 150962ef3760SMichael Roth vmstate_spapr_ovec, sPAPROptionVector), 151062ef3760SMichael Roth VMSTATE_END_OF_LIST() 151162ef3760SMichael Roth }, 151262ef3760SMichael Roth }; 151362ef3760SMichael Roth 15149861bb3eSSuraj Jitindar Singh static bool spapr_patb_entry_needed(void *opaque) 15159861bb3eSSuraj Jitindar Singh { 15169861bb3eSSuraj Jitindar Singh sPAPRMachineState *spapr = opaque; 15179861bb3eSSuraj Jitindar Singh 15189861bb3eSSuraj Jitindar Singh return !!spapr->patb_entry; 15199861bb3eSSuraj Jitindar Singh } 15209861bb3eSSuraj Jitindar Singh 15219861bb3eSSuraj Jitindar Singh static const VMStateDescription vmstate_spapr_patb_entry = { 15229861bb3eSSuraj Jitindar Singh .name = "spapr_patb_entry", 15239861bb3eSSuraj Jitindar Singh .version_id = 1, 15249861bb3eSSuraj Jitindar Singh .minimum_version_id = 1, 15259861bb3eSSuraj Jitindar Singh .needed = spapr_patb_entry_needed, 15269861bb3eSSuraj Jitindar Singh .fields = (VMStateField[]) { 15279861bb3eSSuraj Jitindar Singh VMSTATE_UINT64(patb_entry, sPAPRMachineState), 15289861bb3eSSuraj Jitindar Singh VMSTATE_END_OF_LIST() 15299861bb3eSSuraj Jitindar Singh }, 15309861bb3eSSuraj Jitindar Singh }; 15319861bb3eSSuraj Jitindar Singh 15324be21d56SDavid Gibson static const VMStateDescription vmstate_spapr = { 15334be21d56SDavid Gibson .name = "spapr", 1534880ae7deSDavid Gibson .version_id = 3, 15354be21d56SDavid Gibson .minimum_version_id = 1, 1536880ae7deSDavid Gibson .post_load = spapr_post_load, 15374be21d56SDavid Gibson .fields = (VMStateField[]) { 1538880ae7deSDavid Gibson /* used to be @next_irq */ 1539880ae7deSDavid Gibson VMSTATE_UNUSED_BUFFER(version_before_3, 0, 4), 15404be21d56SDavid Gibson 15414be21d56SDavid Gibson /* RTC offset */ 154228e02042SDavid Gibson VMSTATE_UINT64_TEST(rtc_offset, sPAPRMachineState, version_before_3), 1543880ae7deSDavid Gibson 154428e02042SDavid Gibson VMSTATE_PPC_TIMEBASE_V(tb, sPAPRMachineState, 2), 15454be21d56SDavid Gibson VMSTATE_END_OF_LIST() 15464be21d56SDavid Gibson }, 154762ef3760SMichael Roth .subsections = (const VMStateDescription*[]) { 154862ef3760SMichael Roth &vmstate_spapr_ov5_cas, 15499861bb3eSSuraj Jitindar Singh &vmstate_spapr_patb_entry, 155062ef3760SMichael Roth NULL 155162ef3760SMichael Roth } 15524be21d56SDavid Gibson }; 15534be21d56SDavid Gibson 15544be21d56SDavid Gibson static int htab_save_setup(QEMUFile *f, void *opaque) 15554be21d56SDavid Gibson { 155628e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 15574be21d56SDavid Gibson 15584be21d56SDavid Gibson /* "Iteration" header */ 15594be21d56SDavid Gibson qemu_put_be32(f, spapr->htab_shift); 15604be21d56SDavid Gibson 1561e68cb8b4SAlexey Kardashevskiy if (spapr->htab) { 1562e68cb8b4SAlexey Kardashevskiy spapr->htab_save_index = 0; 1563e68cb8b4SAlexey Kardashevskiy spapr->htab_first_pass = true; 1564e68cb8b4SAlexey Kardashevskiy } else { 1565e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 15664be21d56SDavid Gibson } 15674be21d56SDavid Gibson 1568e68cb8b4SAlexey Kardashevskiy 1569e68cb8b4SAlexey Kardashevskiy return 0; 1570e68cb8b4SAlexey Kardashevskiy } 15714be21d56SDavid Gibson 157228e02042SDavid Gibson static void htab_save_first_pass(QEMUFile *f, sPAPRMachineState *spapr, 15734be21d56SDavid Gibson int64_t max_ns) 15744be21d56SDavid Gibson { 1575378bc217SDavid Gibson bool has_timeout = max_ns != -1; 15764be21d56SDavid Gibson int htabslots = HTAB_SIZE(spapr) / HASH_PTE_SIZE_64; 15774be21d56SDavid Gibson int index = spapr->htab_save_index; 1578bc72ad67SAlex Bligh int64_t starttime = qemu_clock_get_ns(QEMU_CLOCK_REALTIME); 15794be21d56SDavid Gibson 15804be21d56SDavid Gibson assert(spapr->htab_first_pass); 15814be21d56SDavid Gibson 15824be21d56SDavid Gibson do { 15834be21d56SDavid Gibson int chunkstart; 15844be21d56SDavid Gibson 15854be21d56SDavid Gibson /* Consume invalid HPTEs */ 15864be21d56SDavid Gibson while ((index < htabslots) 15874be21d56SDavid Gibson && !HPTE_VALID(HPTE(spapr->htab, index))) { 15884be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 158924ec2863SMarc-André Lureau index++; 15904be21d56SDavid Gibson } 15914be21d56SDavid Gibson 15924be21d56SDavid Gibson /* Consume valid HPTEs */ 15934be21d56SDavid Gibson chunkstart = index; 1594338c25b6SSamuel Mendoza-Jonas while ((index < htabslots) && (index - chunkstart < USHRT_MAX) 15954be21d56SDavid Gibson && HPTE_VALID(HPTE(spapr->htab, index))) { 15964be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 159724ec2863SMarc-André Lureau index++; 15984be21d56SDavid Gibson } 15994be21d56SDavid Gibson 16004be21d56SDavid Gibson if (index > chunkstart) { 16014be21d56SDavid Gibson int n_valid = index - chunkstart; 16024be21d56SDavid Gibson 16034be21d56SDavid Gibson qemu_put_be32(f, chunkstart); 16044be21d56SDavid Gibson qemu_put_be16(f, n_valid); 16054be21d56SDavid Gibson qemu_put_be16(f, 0); 16064be21d56SDavid Gibson qemu_put_buffer(f, HPTE(spapr->htab, chunkstart), 16074be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_valid); 16084be21d56SDavid Gibson 1609378bc217SDavid Gibson if (has_timeout && 1610378bc217SDavid Gibson (qemu_clock_get_ns(QEMU_CLOCK_REALTIME) - starttime) > max_ns) { 16114be21d56SDavid Gibson break; 16124be21d56SDavid Gibson } 16134be21d56SDavid Gibson } 16144be21d56SDavid Gibson } while ((index < htabslots) && !qemu_file_rate_limit(f)); 16154be21d56SDavid Gibson 16164be21d56SDavid Gibson if (index >= htabslots) { 16174be21d56SDavid Gibson assert(index == htabslots); 16184be21d56SDavid Gibson index = 0; 16194be21d56SDavid Gibson spapr->htab_first_pass = false; 16204be21d56SDavid Gibson } 16214be21d56SDavid Gibson spapr->htab_save_index = index; 16224be21d56SDavid Gibson } 16234be21d56SDavid Gibson 162428e02042SDavid Gibson static int htab_save_later_pass(QEMUFile *f, sPAPRMachineState *spapr, 16254be21d56SDavid Gibson int64_t max_ns) 16264be21d56SDavid Gibson { 16274be21d56SDavid Gibson bool final = max_ns < 0; 16284be21d56SDavid Gibson int htabslots = HTAB_SIZE(spapr) / HASH_PTE_SIZE_64; 16294be21d56SDavid Gibson int examined = 0, sent = 0; 16304be21d56SDavid Gibson int index = spapr->htab_save_index; 1631bc72ad67SAlex Bligh int64_t starttime = qemu_clock_get_ns(QEMU_CLOCK_REALTIME); 16324be21d56SDavid Gibson 16334be21d56SDavid Gibson assert(!spapr->htab_first_pass); 16344be21d56SDavid Gibson 16354be21d56SDavid Gibson do { 16364be21d56SDavid Gibson int chunkstart, invalidstart; 16374be21d56SDavid Gibson 16384be21d56SDavid Gibson /* Consume non-dirty HPTEs */ 16394be21d56SDavid Gibson while ((index < htabslots) 16404be21d56SDavid Gibson && !HPTE_DIRTY(HPTE(spapr->htab, index))) { 16414be21d56SDavid Gibson index++; 16424be21d56SDavid Gibson examined++; 16434be21d56SDavid Gibson } 16444be21d56SDavid Gibson 16454be21d56SDavid Gibson chunkstart = index; 16464be21d56SDavid Gibson /* Consume valid dirty HPTEs */ 1647338c25b6SSamuel Mendoza-Jonas while ((index < htabslots) && (index - chunkstart < USHRT_MAX) 16484be21d56SDavid Gibson && HPTE_DIRTY(HPTE(spapr->htab, index)) 16494be21d56SDavid Gibson && HPTE_VALID(HPTE(spapr->htab, index))) { 16504be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 16514be21d56SDavid Gibson index++; 16524be21d56SDavid Gibson examined++; 16534be21d56SDavid Gibson } 16544be21d56SDavid Gibson 16554be21d56SDavid Gibson invalidstart = index; 16564be21d56SDavid Gibson /* Consume invalid dirty HPTEs */ 1657338c25b6SSamuel Mendoza-Jonas while ((index < htabslots) && (index - invalidstart < USHRT_MAX) 16584be21d56SDavid Gibson && HPTE_DIRTY(HPTE(spapr->htab, index)) 16594be21d56SDavid Gibson && !HPTE_VALID(HPTE(spapr->htab, index))) { 16604be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 16614be21d56SDavid Gibson index++; 16624be21d56SDavid Gibson examined++; 16634be21d56SDavid Gibson } 16644be21d56SDavid Gibson 16654be21d56SDavid Gibson if (index > chunkstart) { 16664be21d56SDavid Gibson int n_valid = invalidstart - chunkstart; 16674be21d56SDavid Gibson int n_invalid = index - invalidstart; 16684be21d56SDavid Gibson 16694be21d56SDavid Gibson qemu_put_be32(f, chunkstart); 16704be21d56SDavid Gibson qemu_put_be16(f, n_valid); 16714be21d56SDavid Gibson qemu_put_be16(f, n_invalid); 16724be21d56SDavid Gibson qemu_put_buffer(f, HPTE(spapr->htab, chunkstart), 16734be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_valid); 16744be21d56SDavid Gibson sent += index - chunkstart; 16754be21d56SDavid Gibson 1676bc72ad67SAlex Bligh if (!final && (qemu_clock_get_ns(QEMU_CLOCK_REALTIME) - starttime) > max_ns) { 16774be21d56SDavid Gibson break; 16784be21d56SDavid Gibson } 16794be21d56SDavid Gibson } 16804be21d56SDavid Gibson 16814be21d56SDavid Gibson if (examined >= htabslots) { 16824be21d56SDavid Gibson break; 16834be21d56SDavid Gibson } 16844be21d56SDavid Gibson 16854be21d56SDavid Gibson if (index >= htabslots) { 16864be21d56SDavid Gibson assert(index == htabslots); 16874be21d56SDavid Gibson index = 0; 16884be21d56SDavid Gibson } 16894be21d56SDavid Gibson } while ((examined < htabslots) && (!qemu_file_rate_limit(f) || final)); 16904be21d56SDavid Gibson 16914be21d56SDavid Gibson if (index >= htabslots) { 16924be21d56SDavid Gibson assert(index == htabslots); 16934be21d56SDavid Gibson index = 0; 16944be21d56SDavid Gibson } 16954be21d56SDavid Gibson 16964be21d56SDavid Gibson spapr->htab_save_index = index; 16974be21d56SDavid Gibson 1698e68cb8b4SAlexey Kardashevskiy return (examined >= htabslots) && (sent == 0) ? 1 : 0; 16994be21d56SDavid Gibson } 17004be21d56SDavid Gibson 1701e68cb8b4SAlexey Kardashevskiy #define MAX_ITERATION_NS 5000000 /* 5 ms */ 1702e68cb8b4SAlexey Kardashevskiy #define MAX_KVM_BUF_SIZE 2048 1703e68cb8b4SAlexey Kardashevskiy 17044be21d56SDavid Gibson static int htab_save_iterate(QEMUFile *f, void *opaque) 17054be21d56SDavid Gibson { 170628e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 1707715c5407SDavid Gibson int fd; 1708e68cb8b4SAlexey Kardashevskiy int rc = 0; 17094be21d56SDavid Gibson 17104be21d56SDavid Gibson /* Iteration header */ 17114be21d56SDavid Gibson qemu_put_be32(f, 0); 17124be21d56SDavid Gibson 1713e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1714e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 1715e68cb8b4SAlexey Kardashevskiy 1716715c5407SDavid Gibson fd = get_htab_fd(spapr); 1717715c5407SDavid Gibson if (fd < 0) { 1718715c5407SDavid Gibson return fd; 171901a57972SSamuel Mendoza-Jonas } 172001a57972SSamuel Mendoza-Jonas 1721715c5407SDavid Gibson rc = kvmppc_save_htab(f, fd, MAX_KVM_BUF_SIZE, MAX_ITERATION_NS); 1722e68cb8b4SAlexey Kardashevskiy if (rc < 0) { 1723e68cb8b4SAlexey Kardashevskiy return rc; 1724e68cb8b4SAlexey Kardashevskiy } 1725e68cb8b4SAlexey Kardashevskiy } else if (spapr->htab_first_pass) { 17264be21d56SDavid Gibson htab_save_first_pass(f, spapr, MAX_ITERATION_NS); 17274be21d56SDavid Gibson } else { 1728e68cb8b4SAlexey Kardashevskiy rc = htab_save_later_pass(f, spapr, MAX_ITERATION_NS); 17294be21d56SDavid Gibson } 17304be21d56SDavid Gibson 17314be21d56SDavid Gibson /* End marker */ 17324be21d56SDavid Gibson qemu_put_be32(f, 0); 17334be21d56SDavid Gibson qemu_put_be16(f, 0); 17344be21d56SDavid Gibson qemu_put_be16(f, 0); 17354be21d56SDavid Gibson 1736e68cb8b4SAlexey Kardashevskiy return rc; 17374be21d56SDavid Gibson } 17384be21d56SDavid Gibson 17394be21d56SDavid Gibson static int htab_save_complete(QEMUFile *f, void *opaque) 17404be21d56SDavid Gibson { 174128e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 1742715c5407SDavid Gibson int fd; 17434be21d56SDavid Gibson 17444be21d56SDavid Gibson /* Iteration header */ 17454be21d56SDavid Gibson qemu_put_be32(f, 0); 17464be21d56SDavid Gibson 1747e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1748e68cb8b4SAlexey Kardashevskiy int rc; 1749e68cb8b4SAlexey Kardashevskiy 1750e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 1751e68cb8b4SAlexey Kardashevskiy 1752715c5407SDavid Gibson fd = get_htab_fd(spapr); 1753715c5407SDavid Gibson if (fd < 0) { 1754715c5407SDavid Gibson return fd; 175501a57972SSamuel Mendoza-Jonas } 175601a57972SSamuel Mendoza-Jonas 1757715c5407SDavid Gibson rc = kvmppc_save_htab(f, fd, MAX_KVM_BUF_SIZE, -1); 1758e68cb8b4SAlexey Kardashevskiy if (rc < 0) { 1759e68cb8b4SAlexey Kardashevskiy return rc; 1760e68cb8b4SAlexey Kardashevskiy } 1761e68cb8b4SAlexey Kardashevskiy } else { 1762378bc217SDavid Gibson if (spapr->htab_first_pass) { 1763378bc217SDavid Gibson htab_save_first_pass(f, spapr, -1); 1764378bc217SDavid Gibson } 17654be21d56SDavid Gibson htab_save_later_pass(f, spapr, -1); 1766e68cb8b4SAlexey Kardashevskiy } 17674be21d56SDavid Gibson 17684be21d56SDavid Gibson /* End marker */ 17694be21d56SDavid Gibson qemu_put_be32(f, 0); 17704be21d56SDavid Gibson qemu_put_be16(f, 0); 17714be21d56SDavid Gibson qemu_put_be16(f, 0); 17724be21d56SDavid Gibson 17734be21d56SDavid Gibson return 0; 17744be21d56SDavid Gibson } 17754be21d56SDavid Gibson 17764be21d56SDavid Gibson static int htab_load(QEMUFile *f, void *opaque, int version_id) 17774be21d56SDavid Gibson { 177828e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 17794be21d56SDavid Gibson uint32_t section_hdr; 1780e68cb8b4SAlexey Kardashevskiy int fd = -1; 17814be21d56SDavid Gibson 17824be21d56SDavid Gibson if (version_id < 1 || version_id > 1) { 178398a5d100SDavid Gibson error_report("htab_load() bad version"); 17844be21d56SDavid Gibson return -EINVAL; 17854be21d56SDavid Gibson } 17864be21d56SDavid Gibson 17874be21d56SDavid Gibson section_hdr = qemu_get_be32(f); 17884be21d56SDavid Gibson 17894be21d56SDavid Gibson if (section_hdr) { 17909897e462SGreg Kurz Error *local_err = NULL; 1791c5f54f3eSDavid Gibson 1792c5f54f3eSDavid Gibson /* First section gives the htab size */ 1793c5f54f3eSDavid Gibson spapr_reallocate_hpt(spapr, section_hdr, &local_err); 1794c5f54f3eSDavid Gibson if (local_err) { 1795c5f54f3eSDavid Gibson error_report_err(local_err); 17964be21d56SDavid Gibson return -EINVAL; 17974be21d56SDavid Gibson } 17984be21d56SDavid Gibson return 0; 17994be21d56SDavid Gibson } 18004be21d56SDavid Gibson 1801e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1802e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 1803e68cb8b4SAlexey Kardashevskiy 1804e68cb8b4SAlexey Kardashevskiy fd = kvmppc_get_htab_fd(true); 1805e68cb8b4SAlexey Kardashevskiy if (fd < 0) { 180698a5d100SDavid Gibson error_report("Unable to open fd to restore KVM hash table: %s", 1807e68cb8b4SAlexey Kardashevskiy strerror(errno)); 1808e68cb8b4SAlexey Kardashevskiy } 1809e68cb8b4SAlexey Kardashevskiy } 1810e68cb8b4SAlexey Kardashevskiy 18114be21d56SDavid Gibson while (true) { 18124be21d56SDavid Gibson uint32_t index; 18134be21d56SDavid Gibson uint16_t n_valid, n_invalid; 18144be21d56SDavid Gibson 18154be21d56SDavid Gibson index = qemu_get_be32(f); 18164be21d56SDavid Gibson n_valid = qemu_get_be16(f); 18174be21d56SDavid Gibson n_invalid = qemu_get_be16(f); 18184be21d56SDavid Gibson 18194be21d56SDavid Gibson if ((index == 0) && (n_valid == 0) && (n_invalid == 0)) { 18204be21d56SDavid Gibson /* End of Stream */ 18214be21d56SDavid Gibson break; 18224be21d56SDavid Gibson } 18234be21d56SDavid Gibson 1824e68cb8b4SAlexey Kardashevskiy if ((index + n_valid + n_invalid) > 18254be21d56SDavid Gibson (HTAB_SIZE(spapr) / HASH_PTE_SIZE_64)) { 18264be21d56SDavid Gibson /* Bad index in stream */ 182798a5d100SDavid Gibson error_report( 182898a5d100SDavid Gibson "htab_load() bad index %d (%hd+%hd entries) in htab stream (htab_shift=%d)", 182998a5d100SDavid Gibson index, n_valid, n_invalid, spapr->htab_shift); 18304be21d56SDavid Gibson return -EINVAL; 18314be21d56SDavid Gibson } 18324be21d56SDavid Gibson 1833e68cb8b4SAlexey Kardashevskiy if (spapr->htab) { 18344be21d56SDavid Gibson if (n_valid) { 18354be21d56SDavid Gibson qemu_get_buffer(f, HPTE(spapr->htab, index), 18364be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_valid); 18374be21d56SDavid Gibson } 18384be21d56SDavid Gibson if (n_invalid) { 18394be21d56SDavid Gibson memset(HPTE(spapr->htab, index + n_valid), 0, 18404be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_invalid); 18414be21d56SDavid Gibson } 1842e68cb8b4SAlexey Kardashevskiy } else { 1843e68cb8b4SAlexey Kardashevskiy int rc; 1844e68cb8b4SAlexey Kardashevskiy 1845e68cb8b4SAlexey Kardashevskiy assert(fd >= 0); 1846e68cb8b4SAlexey Kardashevskiy 1847e68cb8b4SAlexey Kardashevskiy rc = kvmppc_load_htab_chunk(f, fd, index, n_valid, n_invalid); 1848e68cb8b4SAlexey Kardashevskiy if (rc < 0) { 1849e68cb8b4SAlexey Kardashevskiy return rc; 1850e68cb8b4SAlexey Kardashevskiy } 1851e68cb8b4SAlexey Kardashevskiy } 1852e68cb8b4SAlexey Kardashevskiy } 1853e68cb8b4SAlexey Kardashevskiy 1854e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1855e68cb8b4SAlexey Kardashevskiy assert(fd >= 0); 1856e68cb8b4SAlexey Kardashevskiy close(fd); 18574be21d56SDavid Gibson } 18584be21d56SDavid Gibson 18594be21d56SDavid Gibson return 0; 18604be21d56SDavid Gibson } 18614be21d56SDavid Gibson 1862c573fc03SThomas Huth static void htab_cleanup(void *opaque) 1863c573fc03SThomas Huth { 1864c573fc03SThomas Huth sPAPRMachineState *spapr = opaque; 1865c573fc03SThomas Huth 1866c573fc03SThomas Huth close_htab_fd(spapr); 1867c573fc03SThomas Huth } 1868c573fc03SThomas Huth 18694be21d56SDavid Gibson static SaveVMHandlers savevm_htab_handlers = { 18704be21d56SDavid Gibson .save_live_setup = htab_save_setup, 18714be21d56SDavid Gibson .save_live_iterate = htab_save_iterate, 1872a3e06c3dSDr. David Alan Gilbert .save_live_complete_precopy = htab_save_complete, 1873c573fc03SThomas Huth .cleanup = htab_cleanup, 18744be21d56SDavid Gibson .load_state = htab_load, 18754be21d56SDavid Gibson }; 18764be21d56SDavid Gibson 18775b2128d2SAlexander Graf static void spapr_boot_set(void *opaque, const char *boot_device, 18785b2128d2SAlexander Graf Error **errp) 18795b2128d2SAlexander Graf { 18805b2128d2SAlexander Graf MachineState *machine = MACHINE(qdev_get_machine()); 18815b2128d2SAlexander Graf machine->boot_order = g_strdup(boot_device); 18825b2128d2SAlexander Graf } 18835b2128d2SAlexander Graf 1884224245bfSDavid Gibson /* 1885224245bfSDavid Gibson * Reset routine for LMB DR devices. 1886224245bfSDavid Gibson * 1887224245bfSDavid Gibson * Unlike PCI DR devices, LMB DR devices explicitly register this reset 1888224245bfSDavid Gibson * routine. Reset for PCI DR devices will be handled by PHB reset routine 1889224245bfSDavid Gibson * when it walks all its children devices. LMB devices reset occurs 1890224245bfSDavid Gibson * as part of spapr_ppc_reset(). 1891224245bfSDavid Gibson */ 1892224245bfSDavid Gibson static void spapr_drc_reset(void *opaque) 1893224245bfSDavid Gibson { 1894224245bfSDavid Gibson sPAPRDRConnector *drc = opaque; 1895224245bfSDavid Gibson DeviceState *d = DEVICE(drc); 1896224245bfSDavid Gibson 1897224245bfSDavid Gibson if (d) { 1898224245bfSDavid Gibson device_reset(d); 1899224245bfSDavid Gibson } 1900224245bfSDavid Gibson } 1901224245bfSDavid Gibson 1902224245bfSDavid Gibson static void spapr_create_lmb_dr_connectors(sPAPRMachineState *spapr) 1903224245bfSDavid Gibson { 1904224245bfSDavid Gibson MachineState *machine = MACHINE(spapr); 1905224245bfSDavid Gibson uint64_t lmb_size = SPAPR_MEMORY_BLOCK_SIZE; 1906e8f986fcSBharata B Rao uint32_t nr_lmbs = (machine->maxram_size - machine->ram_size)/lmb_size; 1907224245bfSDavid Gibson int i; 1908224245bfSDavid Gibson 1909224245bfSDavid Gibson for (i = 0; i < nr_lmbs; i++) { 1910224245bfSDavid Gibson sPAPRDRConnector *drc; 1911224245bfSDavid Gibson uint64_t addr; 1912224245bfSDavid Gibson 1913e8f986fcSBharata B Rao addr = i * lmb_size + spapr->hotplug_memory.base; 1914224245bfSDavid Gibson drc = spapr_dr_connector_new(OBJECT(spapr), SPAPR_DR_CONNECTOR_TYPE_LMB, 1915224245bfSDavid Gibson addr/lmb_size); 1916224245bfSDavid Gibson qemu_register_reset(spapr_drc_reset, drc); 1917224245bfSDavid Gibson } 1918224245bfSDavid Gibson } 1919224245bfSDavid Gibson 1920224245bfSDavid Gibson /* 1921224245bfSDavid Gibson * If RAM size, maxmem size and individual node mem sizes aren't aligned 1922224245bfSDavid Gibson * to SPAPR_MEMORY_BLOCK_SIZE(256MB), then refuse to start the guest 1923224245bfSDavid Gibson * since we can't support such unaligned sizes with DRCONF_MEMORY. 1924224245bfSDavid Gibson */ 19257c150d6fSDavid Gibson static void spapr_validate_node_memory(MachineState *machine, Error **errp) 1926224245bfSDavid Gibson { 1927224245bfSDavid Gibson int i; 1928224245bfSDavid Gibson 19297c150d6fSDavid Gibson if (machine->ram_size % SPAPR_MEMORY_BLOCK_SIZE) { 19307c150d6fSDavid Gibson error_setg(errp, "Memory size 0x" RAM_ADDR_FMT 19317c150d6fSDavid Gibson " is not aligned to %llu MiB", 19327c150d6fSDavid Gibson machine->ram_size, 1933224245bfSDavid Gibson SPAPR_MEMORY_BLOCK_SIZE / M_BYTE); 19347c150d6fSDavid Gibson return; 19357c150d6fSDavid Gibson } 19367c150d6fSDavid Gibson 19377c150d6fSDavid Gibson if (machine->maxram_size % SPAPR_MEMORY_BLOCK_SIZE) { 19387c150d6fSDavid Gibson error_setg(errp, "Maximum memory size 0x" RAM_ADDR_FMT 19397c150d6fSDavid Gibson " is not aligned to %llu MiB", 19407c150d6fSDavid Gibson machine->ram_size, 19417c150d6fSDavid Gibson SPAPR_MEMORY_BLOCK_SIZE / M_BYTE); 19427c150d6fSDavid Gibson return; 1943224245bfSDavid Gibson } 1944224245bfSDavid Gibson 1945224245bfSDavid Gibson for (i = 0; i < nb_numa_nodes; i++) { 1946224245bfSDavid Gibson if (numa_info[i].node_mem % SPAPR_MEMORY_BLOCK_SIZE) { 19477c150d6fSDavid Gibson error_setg(errp, 19487c150d6fSDavid Gibson "Node %d memory size 0x%" PRIx64 19497c150d6fSDavid Gibson " is not aligned to %llu MiB", 19507c150d6fSDavid Gibson i, numa_info[i].node_mem, 1951224245bfSDavid Gibson SPAPR_MEMORY_BLOCK_SIZE / M_BYTE); 19527c150d6fSDavid Gibson return; 1953224245bfSDavid Gibson } 1954224245bfSDavid Gibson } 1955224245bfSDavid Gibson } 1956224245bfSDavid Gibson 1957535455fdSIgor Mammedov /* find cpu slot in machine->possible_cpus by core_id */ 1958535455fdSIgor Mammedov static CPUArchId *spapr_find_cpu_slot(MachineState *ms, uint32_t id, int *idx) 1959535455fdSIgor Mammedov { 1960535455fdSIgor Mammedov int index = id / smp_threads; 1961535455fdSIgor Mammedov 1962535455fdSIgor Mammedov if (index >= ms->possible_cpus->len) { 1963535455fdSIgor Mammedov return NULL; 1964535455fdSIgor Mammedov } 1965535455fdSIgor Mammedov if (idx) { 1966535455fdSIgor Mammedov *idx = index; 1967535455fdSIgor Mammedov } 1968535455fdSIgor Mammedov return &ms->possible_cpus->cpus[index]; 1969535455fdSIgor Mammedov } 1970535455fdSIgor Mammedov 19710c86d0fdSDavid Gibson static void spapr_init_cpus(sPAPRMachineState *spapr) 19720c86d0fdSDavid Gibson { 19730c86d0fdSDavid Gibson MachineState *machine = MACHINE(spapr); 19740c86d0fdSDavid Gibson MachineClass *mc = MACHINE_GET_CLASS(machine); 19750c86d0fdSDavid Gibson char *type = spapr_get_cpu_core_type(machine->cpu_model); 19760c86d0fdSDavid Gibson int smt = kvmppc_smt_threads(); 1977535455fdSIgor Mammedov const CPUArchIdList *possible_cpus; 1978535455fdSIgor Mammedov int boot_cores_nr = smp_cpus / smp_threads; 19790c86d0fdSDavid Gibson int i; 19800c86d0fdSDavid Gibson 19810c86d0fdSDavid Gibson if (!type) { 19820c86d0fdSDavid Gibson error_report("Unable to find sPAPR CPU Core definition"); 19830c86d0fdSDavid Gibson exit(1); 19840c86d0fdSDavid Gibson } 19850c86d0fdSDavid Gibson 1986535455fdSIgor Mammedov possible_cpus = mc->possible_cpu_arch_ids(machine); 1987c5514d0eSIgor Mammedov if (mc->has_hotpluggable_cpus) { 19880c86d0fdSDavid Gibson if (smp_cpus % smp_threads) { 19890c86d0fdSDavid Gibson error_report("smp_cpus (%u) must be multiple of threads (%u)", 19900c86d0fdSDavid Gibson smp_cpus, smp_threads); 19910c86d0fdSDavid Gibson exit(1); 19920c86d0fdSDavid Gibson } 19930c86d0fdSDavid Gibson if (max_cpus % smp_threads) { 19940c86d0fdSDavid Gibson error_report("max_cpus (%u) must be multiple of threads (%u)", 19950c86d0fdSDavid Gibson max_cpus, smp_threads); 19960c86d0fdSDavid Gibson exit(1); 19970c86d0fdSDavid Gibson } 19980c86d0fdSDavid Gibson } else { 19990c86d0fdSDavid Gibson if (max_cpus != smp_cpus) { 20000c86d0fdSDavid Gibson error_report("This machine version does not support CPU hotplug"); 20010c86d0fdSDavid Gibson exit(1); 20020c86d0fdSDavid Gibson } 2003535455fdSIgor Mammedov boot_cores_nr = possible_cpus->len; 20040c86d0fdSDavid Gibson } 20050c86d0fdSDavid Gibson 2006535455fdSIgor Mammedov for (i = 0; i < possible_cpus->len; i++) { 20070c86d0fdSDavid Gibson int core_id = i * smp_threads; 20080c86d0fdSDavid Gibson 2009c5514d0eSIgor Mammedov if (mc->has_hotpluggable_cpus) { 20100c86d0fdSDavid Gibson sPAPRDRConnector *drc = 20110c86d0fdSDavid Gibson spapr_dr_connector_new(OBJECT(spapr), 20120c86d0fdSDavid Gibson SPAPR_DR_CONNECTOR_TYPE_CPU, 20130c86d0fdSDavid Gibson (core_id / smp_threads) * smt); 20140c86d0fdSDavid Gibson 20150c86d0fdSDavid Gibson qemu_register_reset(spapr_drc_reset, drc); 20160c86d0fdSDavid Gibson } 20170c86d0fdSDavid Gibson 2018535455fdSIgor Mammedov if (i < boot_cores_nr) { 20190c86d0fdSDavid Gibson Object *core = object_new(type); 20200c86d0fdSDavid Gibson int nr_threads = smp_threads; 20210c86d0fdSDavid Gibson 20220c86d0fdSDavid Gibson /* Handle the partially filled core for older machine types */ 20230c86d0fdSDavid Gibson if ((i + 1) * smp_threads >= smp_cpus) { 20240c86d0fdSDavid Gibson nr_threads = smp_cpus - i * smp_threads; 20250c86d0fdSDavid Gibson } 20260c86d0fdSDavid Gibson 20270c86d0fdSDavid Gibson object_property_set_int(core, nr_threads, "nr-threads", 20280c86d0fdSDavid Gibson &error_fatal); 20290c86d0fdSDavid Gibson object_property_set_int(core, core_id, CPU_CORE_PROP_CORE_ID, 20300c86d0fdSDavid Gibson &error_fatal); 20310c86d0fdSDavid Gibson object_property_set_bool(core, true, "realized", &error_fatal); 20320c86d0fdSDavid Gibson } 20330c86d0fdSDavid Gibson } 20340c86d0fdSDavid Gibson g_free(type); 20350c86d0fdSDavid Gibson } 20360c86d0fdSDavid Gibson 203753018216SPaolo Bonzini /* pSeries LPAR / sPAPR hardware init */ 20383ef96221SMarcel Apfelbaum static void ppc_spapr_init(MachineState *machine) 203953018216SPaolo Bonzini { 204028e02042SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(machine); 2041224245bfSDavid Gibson sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(machine); 20423ef96221SMarcel Apfelbaum const char *kernel_filename = machine->kernel_filename; 20433ef96221SMarcel Apfelbaum const char *initrd_filename = machine->initrd_filename; 204453018216SPaolo Bonzini PCIHostState *phb; 204553018216SPaolo Bonzini int i; 204653018216SPaolo Bonzini MemoryRegion *sysmem = get_system_memory(); 204753018216SPaolo Bonzini MemoryRegion *ram = g_new(MemoryRegion, 1); 2048658fa66bSAlexey Kardashevskiy MemoryRegion *rma_region; 2049658fa66bSAlexey Kardashevskiy void *rma = NULL; 205053018216SPaolo Bonzini hwaddr rma_alloc_size; 2051b082d65aSAlexey Kardashevskiy hwaddr node0_size = spapr_node0_size(); 2052b7d1f77aSBenjamin Herrenschmidt long load_limit, fw_size; 205353018216SPaolo Bonzini char *filename; 205453018216SPaolo Bonzini 2055226419d6SMichael S. Tsirkin msi_nonbroken = true; 205653018216SPaolo Bonzini 205753018216SPaolo Bonzini QLIST_INIT(&spapr->phbs); 205853018216SPaolo Bonzini 205953018216SPaolo Bonzini /* Allocate RMA if necessary */ 2060658fa66bSAlexey Kardashevskiy rma_alloc_size = kvmppc_alloc_rma(&rma); 206153018216SPaolo Bonzini 206253018216SPaolo Bonzini if (rma_alloc_size == -1) { 2063730fce59SThomas Huth error_report("Unable to create RMA"); 206453018216SPaolo Bonzini exit(1); 206553018216SPaolo Bonzini } 206653018216SPaolo Bonzini 2067c4177479SAlexey Kardashevskiy if (rma_alloc_size && (rma_alloc_size < node0_size)) { 206853018216SPaolo Bonzini spapr->rma_size = rma_alloc_size; 206953018216SPaolo Bonzini } else { 2070c4177479SAlexey Kardashevskiy spapr->rma_size = node0_size; 207153018216SPaolo Bonzini 207253018216SPaolo Bonzini /* With KVM, we don't actually know whether KVM supports an 207353018216SPaolo Bonzini * unbounded RMA (PR KVM) or is limited by the hash table size 207453018216SPaolo Bonzini * (HV KVM using VRMA), so we always assume the latter 207553018216SPaolo Bonzini * 207653018216SPaolo Bonzini * In that case, we also limit the initial allocations for RTAS 207753018216SPaolo Bonzini * etc... to 256M since we have no way to know what the VRMA size 207853018216SPaolo Bonzini * is going to be as it depends on the size of the hash table 207953018216SPaolo Bonzini * isn't determined yet. 208053018216SPaolo Bonzini */ 208153018216SPaolo Bonzini if (kvm_enabled()) { 208253018216SPaolo Bonzini spapr->vrma_adjust = 1; 208353018216SPaolo Bonzini spapr->rma_size = MIN(spapr->rma_size, 0x10000000); 208453018216SPaolo Bonzini } 2085912acdf4SBenjamin Herrenschmidt 2086912acdf4SBenjamin Herrenschmidt /* Actually we don't support unbounded RMA anymore since we 2087912acdf4SBenjamin Herrenschmidt * added proper emulation of HV mode. The max we can get is 2088912acdf4SBenjamin Herrenschmidt * 16G which also happens to be what we configure for PAPR 2089912acdf4SBenjamin Herrenschmidt * mode so make sure we don't do anything bigger than that 2090912acdf4SBenjamin Herrenschmidt */ 2091912acdf4SBenjamin Herrenschmidt spapr->rma_size = MIN(spapr->rma_size, 0x400000000ull); 209253018216SPaolo Bonzini } 209353018216SPaolo Bonzini 2094c4177479SAlexey Kardashevskiy if (spapr->rma_size > node0_size) { 2095d54e4d76SDavid Gibson error_report("Numa node 0 has to span the RMA (%#08"HWADDR_PRIx")", 2096c4177479SAlexey Kardashevskiy spapr->rma_size); 2097c4177479SAlexey Kardashevskiy exit(1); 2098c4177479SAlexey Kardashevskiy } 2099c4177479SAlexey Kardashevskiy 2100b7d1f77aSBenjamin Herrenschmidt /* Setup a load limit for the ramdisk leaving room for SLOF and FDT */ 2101b7d1f77aSBenjamin Herrenschmidt load_limit = MIN(spapr->rma_size, RTAS_MAX_ADDR) - FW_OVERHEAD; 210253018216SPaolo Bonzini 21037b565160SDavid Gibson /* Set up Interrupt Controller before we create the VCPUs */ 210471cd4dacSCédric Le Goater xics_system_init(machine, XICS_IRQS_SPAPR, &error_fatal); 21057b565160SDavid Gibson 2106facdb8b6SMichael Roth /* Set up containers for ibm,client-set-architecture negotiated options */ 2107facdb8b6SMichael Roth spapr->ov5 = spapr_ovec_new(); 2108facdb8b6SMichael Roth spapr->ov5_cas = spapr_ovec_new(); 2109facdb8b6SMichael Roth 2110224245bfSDavid Gibson if (smc->dr_lmb_enabled) { 2111facdb8b6SMichael Roth spapr_ovec_set(spapr->ov5, OV5_DRCONF_MEMORY); 21127c150d6fSDavid Gibson spapr_validate_node_memory(machine, &error_fatal); 2113224245bfSDavid Gibson } 2114224245bfSDavid Gibson 2115417ece33SMichael Roth spapr_ovec_set(spapr->ov5, OV5_FORM1_AFFINITY); 2116545d6e2bSSuraj Jitindar Singh if (!kvm_enabled() || kvmppc_has_cap_mmu_radix()) { 2117545d6e2bSSuraj Jitindar Singh /* KVM and TCG always allow GTSE with radix... */ 21189fb4541fSSam Bobroff spapr_ovec_set(spapr->ov5, OV5_MMU_RADIX_GTSE); 21199fb4541fSSam Bobroff } 21209fb4541fSSam Bobroff /* ... but not with hash (currently). */ 2121417ece33SMichael Roth 2122ffbb1705SMichael Roth /* advertise support for dedicated HP event source to guests */ 2123ffbb1705SMichael Roth if (spapr->use_hotplug_event_source) { 2124ffbb1705SMichael Roth spapr_ovec_set(spapr->ov5, OV5_HP_EVT); 2125ffbb1705SMichael Roth } 2126ffbb1705SMichael Roth 212753018216SPaolo Bonzini /* init CPUs */ 212819fb2c36SBharata B Rao if (machine->cpu_model == NULL) { 21293daa4a9fSThomas Huth machine->cpu_model = kvm_enabled() ? "host" : smc->tcg_default_cpu; 213053018216SPaolo Bonzini } 213194a94e4cSBharata B Rao 2132e703d2f7SGreg Kurz ppc_cpu_parse_features(machine->cpu_model); 2133e703d2f7SGreg Kurz 21340c86d0fdSDavid Gibson spapr_init_cpus(spapr); 213553018216SPaolo Bonzini 2136026bfd89SDavid Gibson if (kvm_enabled()) { 2137026bfd89SDavid Gibson /* Enable H_LOGICAL_CI_* so SLOF can talk to in-kernel devices */ 2138026bfd89SDavid Gibson kvmppc_enable_logical_ci_hcalls(); 2139ef9971ddSAlexey Kardashevskiy kvmppc_enable_set_mode_hcall(); 21405145ad4fSNathan Whitehorn 21415145ad4fSNathan Whitehorn /* H_CLEAR_MOD/_REF are mandatory in PAPR, but off by default */ 21425145ad4fSNathan Whitehorn kvmppc_enable_clear_ref_mod_hcalls(); 2143026bfd89SDavid Gibson } 2144026bfd89SDavid Gibson 214553018216SPaolo Bonzini /* allocate RAM */ 2146f92f5da1SAlexey Kardashevskiy memory_region_allocate_system_memory(ram, NULL, "ppc_spapr.ram", 2147fb164994SDavid Gibson machine->ram_size); 2148f92f5da1SAlexey Kardashevskiy memory_region_add_subregion(sysmem, 0, ram); 214953018216SPaolo Bonzini 2150658fa66bSAlexey Kardashevskiy if (rma_alloc_size && rma) { 2151658fa66bSAlexey Kardashevskiy rma_region = g_new(MemoryRegion, 1); 2152658fa66bSAlexey Kardashevskiy memory_region_init_ram_ptr(rma_region, NULL, "ppc_spapr.rma", 2153658fa66bSAlexey Kardashevskiy rma_alloc_size, rma); 2154658fa66bSAlexey Kardashevskiy vmstate_register_ram_global(rma_region); 2155658fa66bSAlexey Kardashevskiy memory_region_add_subregion(sysmem, 0, rma_region); 2156658fa66bSAlexey Kardashevskiy } 2157658fa66bSAlexey Kardashevskiy 21584a1c9cf0SBharata B Rao /* initialize hotplug memory address space */ 21594a1c9cf0SBharata B Rao if (machine->ram_size < machine->maxram_size) { 21604a1c9cf0SBharata B Rao ram_addr_t hotplug_mem_size = machine->maxram_size - machine->ram_size; 216171c9a3ddSBharata B Rao /* 216271c9a3ddSBharata B Rao * Limit the number of hotpluggable memory slots to half the number 216371c9a3ddSBharata B Rao * slots that KVM supports, leaving the other half for PCI and other 216471c9a3ddSBharata B Rao * devices. However ensure that number of slots doesn't drop below 32. 216571c9a3ddSBharata B Rao */ 216671c9a3ddSBharata B Rao int max_memslots = kvm_enabled() ? kvm_get_max_memslots() / 2 : 216771c9a3ddSBharata B Rao SPAPR_MAX_RAM_SLOTS; 21684a1c9cf0SBharata B Rao 216971c9a3ddSBharata B Rao if (max_memslots < SPAPR_MAX_RAM_SLOTS) { 217071c9a3ddSBharata B Rao max_memslots = SPAPR_MAX_RAM_SLOTS; 217171c9a3ddSBharata B Rao } 217271c9a3ddSBharata B Rao if (machine->ram_slots > max_memslots) { 2173d54e4d76SDavid Gibson error_report("Specified number of memory slots %" 2174d54e4d76SDavid Gibson PRIu64" exceeds max supported %d", 217571c9a3ddSBharata B Rao machine->ram_slots, max_memslots); 2176d54e4d76SDavid Gibson exit(1); 21774a1c9cf0SBharata B Rao } 21784a1c9cf0SBharata B Rao 21794a1c9cf0SBharata B Rao spapr->hotplug_memory.base = ROUND_UP(machine->ram_size, 21804a1c9cf0SBharata B Rao SPAPR_HOTPLUG_MEM_ALIGN); 21814a1c9cf0SBharata B Rao memory_region_init(&spapr->hotplug_memory.mr, OBJECT(spapr), 21824a1c9cf0SBharata B Rao "hotplug-memory", hotplug_mem_size); 21834a1c9cf0SBharata B Rao memory_region_add_subregion(sysmem, spapr->hotplug_memory.base, 21844a1c9cf0SBharata B Rao &spapr->hotplug_memory.mr); 21854a1c9cf0SBharata B Rao } 21864a1c9cf0SBharata B Rao 2187224245bfSDavid Gibson if (smc->dr_lmb_enabled) { 2188224245bfSDavid Gibson spapr_create_lmb_dr_connectors(spapr); 2189224245bfSDavid Gibson } 2190224245bfSDavid Gibson 219153018216SPaolo Bonzini filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, "spapr-rtas.bin"); 21924c56440dSStefan Weil if (!filename) { 2193730fce59SThomas Huth error_report("Could not find LPAR rtas '%s'", "spapr-rtas.bin"); 21944c56440dSStefan Weil exit(1); 21954c56440dSStefan Weil } 2196b7d1f77aSBenjamin Herrenschmidt spapr->rtas_size = get_image_size(filename); 21978afc22a2SZhou Jie if (spapr->rtas_size < 0) { 21988afc22a2SZhou Jie error_report("Could not get size of LPAR rtas '%s'", filename); 21998afc22a2SZhou Jie exit(1); 22008afc22a2SZhou Jie } 2201b7d1f77aSBenjamin Herrenschmidt spapr->rtas_blob = g_malloc(spapr->rtas_size); 2202b7d1f77aSBenjamin Herrenschmidt if (load_image_size(filename, spapr->rtas_blob, spapr->rtas_size) < 0) { 2203730fce59SThomas Huth error_report("Could not load LPAR rtas '%s'", filename); 220453018216SPaolo Bonzini exit(1); 220553018216SPaolo Bonzini } 220653018216SPaolo Bonzini if (spapr->rtas_size > RTAS_MAX_SIZE) { 2207730fce59SThomas Huth error_report("RTAS too big ! 0x%zx bytes (max is 0x%x)", 22082f285bddSPeter Maydell (size_t)spapr->rtas_size, RTAS_MAX_SIZE); 220953018216SPaolo Bonzini exit(1); 221053018216SPaolo Bonzini } 221153018216SPaolo Bonzini g_free(filename); 221253018216SPaolo Bonzini 2213ffbb1705SMichael Roth /* Set up RTAS event infrastructure */ 221453018216SPaolo Bonzini spapr_events_init(spapr); 221553018216SPaolo Bonzini 221612f42174SDavid Gibson /* Set up the RTC RTAS interfaces */ 221728df36a1SDavid Gibson spapr_rtc_create(spapr); 221812f42174SDavid Gibson 221953018216SPaolo Bonzini /* Set up VIO bus */ 222053018216SPaolo Bonzini spapr->vio_bus = spapr_vio_bus_init(); 222153018216SPaolo Bonzini 222253018216SPaolo Bonzini for (i = 0; i < MAX_SERIAL_PORTS; i++) { 222353018216SPaolo Bonzini if (serial_hds[i]) { 222453018216SPaolo Bonzini spapr_vty_create(spapr->vio_bus, serial_hds[i]); 222553018216SPaolo Bonzini } 222653018216SPaolo Bonzini } 222753018216SPaolo Bonzini 222853018216SPaolo Bonzini /* We always have at least the nvram device on VIO */ 222953018216SPaolo Bonzini spapr_create_nvram(spapr); 223053018216SPaolo Bonzini 223153018216SPaolo Bonzini /* Set up PCI */ 223253018216SPaolo Bonzini spapr_pci_rtas_init(); 223353018216SPaolo Bonzini 223489dfd6e1SDavid Gibson phb = spapr_create_phb(spapr, 0); 223553018216SPaolo Bonzini 223653018216SPaolo Bonzini for (i = 0; i < nb_nics; i++) { 223753018216SPaolo Bonzini NICInfo *nd = &nd_table[i]; 223853018216SPaolo Bonzini 223953018216SPaolo Bonzini if (!nd->model) { 224053018216SPaolo Bonzini nd->model = g_strdup("ibmveth"); 224153018216SPaolo Bonzini } 224253018216SPaolo Bonzini 224353018216SPaolo Bonzini if (strcmp(nd->model, "ibmveth") == 0) { 224453018216SPaolo Bonzini spapr_vlan_create(spapr->vio_bus, nd); 224553018216SPaolo Bonzini } else { 224629b358f9SDavid Gibson pci_nic_init_nofail(&nd_table[i], phb->bus, nd->model, NULL); 224753018216SPaolo Bonzini } 224853018216SPaolo Bonzini } 224953018216SPaolo Bonzini 225053018216SPaolo Bonzini for (i = 0; i <= drive_get_max_bus(IF_SCSI); i++) { 225153018216SPaolo Bonzini spapr_vscsi_create(spapr->vio_bus); 225253018216SPaolo Bonzini } 225353018216SPaolo Bonzini 225453018216SPaolo Bonzini /* Graphics */ 225514c6a894SDavid Gibson if (spapr_vga_init(phb->bus, &error_fatal)) { 225653018216SPaolo Bonzini spapr->has_graphics = true; 2257c6e76503SPaolo Bonzini machine->usb |= defaults_enabled() && !machine->usb_disabled; 225853018216SPaolo Bonzini } 225953018216SPaolo Bonzini 22604ee9ced9SMarcel Apfelbaum if (machine->usb) { 226157040d45SThomas Huth if (smc->use_ohci_by_default) { 226253018216SPaolo Bonzini pci_create_simple(phb->bus, -1, "pci-ohci"); 226357040d45SThomas Huth } else { 226457040d45SThomas Huth pci_create_simple(phb->bus, -1, "nec-usb-xhci"); 226557040d45SThomas Huth } 2266c86580b8SMarkus Armbruster 226753018216SPaolo Bonzini if (spapr->has_graphics) { 2268c86580b8SMarkus Armbruster USBBus *usb_bus = usb_bus_find(-1); 2269c86580b8SMarkus Armbruster 2270c86580b8SMarkus Armbruster usb_create_simple(usb_bus, "usb-kbd"); 2271c86580b8SMarkus Armbruster usb_create_simple(usb_bus, "usb-mouse"); 227253018216SPaolo Bonzini } 227353018216SPaolo Bonzini } 227453018216SPaolo Bonzini 227553018216SPaolo Bonzini if (spapr->rma_size < (MIN_RMA_SLOF << 20)) { 2276d54e4d76SDavid Gibson error_report( 2277d54e4d76SDavid Gibson "pSeries SLOF firmware requires >= %ldM guest RMA (Real Mode Area memory)", 2278d54e4d76SDavid Gibson MIN_RMA_SLOF); 227953018216SPaolo Bonzini exit(1); 228053018216SPaolo Bonzini } 228153018216SPaolo Bonzini 228253018216SPaolo Bonzini if (kernel_filename) { 228353018216SPaolo Bonzini uint64_t lowaddr = 0; 228453018216SPaolo Bonzini 2285a19f7fb0SDavid Gibson spapr->kernel_size = load_elf(kernel_filename, translate_kernel_address, 2286a19f7fb0SDavid Gibson NULL, NULL, &lowaddr, NULL, 1, 2287a19f7fb0SDavid Gibson PPC_ELF_MACHINE, 0, 0); 2288a19f7fb0SDavid Gibson if (spapr->kernel_size == ELF_LOAD_WRONG_ENDIAN) { 2289a19f7fb0SDavid Gibson spapr->kernel_size = load_elf(kernel_filename, 2290a19f7fb0SDavid Gibson translate_kernel_address, NULL, NULL, 2291a19f7fb0SDavid Gibson &lowaddr, NULL, 0, PPC_ELF_MACHINE, 22927ef295eaSPeter Crosthwaite 0, 0); 2293a19f7fb0SDavid Gibson spapr->kernel_le = spapr->kernel_size > 0; 229416457e7fSBenjamin Herrenschmidt } 2295a19f7fb0SDavid Gibson if (spapr->kernel_size < 0) { 2296a19f7fb0SDavid Gibson error_report("error loading %s: %s", kernel_filename, 2297a19f7fb0SDavid Gibson load_elf_strerror(spapr->kernel_size)); 229853018216SPaolo Bonzini exit(1); 229953018216SPaolo Bonzini } 230053018216SPaolo Bonzini 230153018216SPaolo Bonzini /* load initrd */ 230253018216SPaolo Bonzini if (initrd_filename) { 230353018216SPaolo Bonzini /* Try to locate the initrd in the gap between the kernel 230453018216SPaolo Bonzini * and the firmware. Add a bit of space just in case 230553018216SPaolo Bonzini */ 2306a19f7fb0SDavid Gibson spapr->initrd_base = (KERNEL_LOAD_ADDR + spapr->kernel_size 2307a19f7fb0SDavid Gibson + 0x1ffff) & ~0xffff; 2308a19f7fb0SDavid Gibson spapr->initrd_size = load_image_targphys(initrd_filename, 2309a19f7fb0SDavid Gibson spapr->initrd_base, 2310a19f7fb0SDavid Gibson load_limit 2311a19f7fb0SDavid Gibson - spapr->initrd_base); 2312a19f7fb0SDavid Gibson if (spapr->initrd_size < 0) { 2313d54e4d76SDavid Gibson error_report("could not load initial ram disk '%s'", 231453018216SPaolo Bonzini initrd_filename); 231553018216SPaolo Bonzini exit(1); 231653018216SPaolo Bonzini } 231753018216SPaolo Bonzini } 231853018216SPaolo Bonzini } 231953018216SPaolo Bonzini 23208e7ea787SAndreas Färber if (bios_name == NULL) { 23218e7ea787SAndreas Färber bios_name = FW_FILE_NAME; 23228e7ea787SAndreas Färber } 23238e7ea787SAndreas Färber filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name); 23244c56440dSStefan Weil if (!filename) { 232568fea5a0SThomas Huth error_report("Could not find LPAR firmware '%s'", bios_name); 23264c56440dSStefan Weil exit(1); 23274c56440dSStefan Weil } 232853018216SPaolo Bonzini fw_size = load_image_targphys(filename, 0, FW_MAX_SIZE); 232968fea5a0SThomas Huth if (fw_size <= 0) { 233068fea5a0SThomas Huth error_report("Could not load LPAR firmware '%s'", filename); 233153018216SPaolo Bonzini exit(1); 233253018216SPaolo Bonzini } 233353018216SPaolo Bonzini g_free(filename); 233453018216SPaolo Bonzini 233528e02042SDavid Gibson /* FIXME: Should register things through the MachineState's qdev 233628e02042SDavid Gibson * interface, this is a legacy from the sPAPREnvironment structure 233728e02042SDavid Gibson * which predated MachineState but had a similar function */ 23384be21d56SDavid Gibson vmstate_register(NULL, 0, &vmstate_spapr, spapr); 23394be21d56SDavid Gibson register_savevm_live(NULL, "spapr/htab", -1, 1, 23404be21d56SDavid Gibson &savevm_htab_handlers, spapr); 23414be21d56SDavid Gibson 234246503c2bSMichael Roth /* used by RTAS */ 234346503c2bSMichael Roth QTAILQ_INIT(&spapr->ccs_list); 234446503c2bSMichael Roth qemu_register_reset(spapr_ccs_reset_hook, spapr); 234546503c2bSMichael Roth 23465b2128d2SAlexander Graf qemu_register_boot_set(spapr_boot_set, spapr); 234742043e4fSLaurent Vivier 234842043e4fSLaurent Vivier if (kvm_enabled()) { 23493dc410aeSAlexey Kardashevskiy /* to stop and start vmclock */ 235042043e4fSLaurent Vivier qemu_add_vm_change_state_handler(cpu_ppc_clock_vm_state_change, 235142043e4fSLaurent Vivier &spapr->tb); 23523dc410aeSAlexey Kardashevskiy 23533dc410aeSAlexey Kardashevskiy kvmppc_spapr_enable_inkernel_multitce(); 235442043e4fSLaurent Vivier } 235553018216SPaolo Bonzini } 235653018216SPaolo Bonzini 2357135a129aSAneesh Kumar K.V static int spapr_kvm_type(const char *vm_type) 2358135a129aSAneesh Kumar K.V { 2359135a129aSAneesh Kumar K.V if (!vm_type) { 2360135a129aSAneesh Kumar K.V return 0; 2361135a129aSAneesh Kumar K.V } 2362135a129aSAneesh Kumar K.V 2363135a129aSAneesh Kumar K.V if (!strcmp(vm_type, "HV")) { 2364135a129aSAneesh Kumar K.V return 1; 2365135a129aSAneesh Kumar K.V } 2366135a129aSAneesh Kumar K.V 2367135a129aSAneesh Kumar K.V if (!strcmp(vm_type, "PR")) { 2368135a129aSAneesh Kumar K.V return 2; 2369135a129aSAneesh Kumar K.V } 2370135a129aSAneesh Kumar K.V 2371135a129aSAneesh Kumar K.V error_report("Unknown kvm-type specified '%s'", vm_type); 2372135a129aSAneesh Kumar K.V exit(1); 2373135a129aSAneesh Kumar K.V } 2374135a129aSAneesh Kumar K.V 237571461b0fSAlexey Kardashevskiy /* 2376627b84f4SGonglei * Implementation of an interface to adjust firmware path 237771461b0fSAlexey Kardashevskiy * for the bootindex property handling. 237871461b0fSAlexey Kardashevskiy */ 237971461b0fSAlexey Kardashevskiy static char *spapr_get_fw_dev_path(FWPathProvider *p, BusState *bus, 238071461b0fSAlexey Kardashevskiy DeviceState *dev) 238171461b0fSAlexey Kardashevskiy { 238271461b0fSAlexey Kardashevskiy #define CAST(type, obj, name) \ 238371461b0fSAlexey Kardashevskiy ((type *)object_dynamic_cast(OBJECT(obj), (name))) 238471461b0fSAlexey Kardashevskiy SCSIDevice *d = CAST(SCSIDevice, dev, TYPE_SCSI_DEVICE); 238571461b0fSAlexey Kardashevskiy sPAPRPHBState *phb = CAST(sPAPRPHBState, dev, TYPE_SPAPR_PCI_HOST_BRIDGE); 238671461b0fSAlexey Kardashevskiy 238771461b0fSAlexey Kardashevskiy if (d) { 238871461b0fSAlexey Kardashevskiy void *spapr = CAST(void, bus->parent, "spapr-vscsi"); 238971461b0fSAlexey Kardashevskiy VirtIOSCSI *virtio = CAST(VirtIOSCSI, bus->parent, TYPE_VIRTIO_SCSI); 239071461b0fSAlexey Kardashevskiy USBDevice *usb = CAST(USBDevice, bus->parent, TYPE_USB_DEVICE); 239171461b0fSAlexey Kardashevskiy 239271461b0fSAlexey Kardashevskiy if (spapr) { 239371461b0fSAlexey Kardashevskiy /* 239471461b0fSAlexey Kardashevskiy * Replace "channel@0/disk@0,0" with "disk@8000000000000000": 239571461b0fSAlexey Kardashevskiy * We use SRP luns of the form 8000 | (bus << 8) | (id << 5) | lun 239671461b0fSAlexey Kardashevskiy * in the top 16 bits of the 64-bit LUN 239771461b0fSAlexey Kardashevskiy */ 239871461b0fSAlexey Kardashevskiy unsigned id = 0x8000 | (d->id << 8) | d->lun; 239971461b0fSAlexey Kardashevskiy return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev), 240071461b0fSAlexey Kardashevskiy (uint64_t)id << 48); 240171461b0fSAlexey Kardashevskiy } else if (virtio) { 240271461b0fSAlexey Kardashevskiy /* 240371461b0fSAlexey Kardashevskiy * We use SRP luns of the form 01000000 | (target << 8) | lun 240471461b0fSAlexey Kardashevskiy * in the top 32 bits of the 64-bit LUN 240571461b0fSAlexey Kardashevskiy * Note: the quote above is from SLOF and it is wrong, 240671461b0fSAlexey Kardashevskiy * the actual binding is: 240771461b0fSAlexey Kardashevskiy * swap 0100 or 10 << or 20 << ( target lun-id -- srplun ) 240871461b0fSAlexey Kardashevskiy */ 240971461b0fSAlexey Kardashevskiy unsigned id = 0x1000000 | (d->id << 16) | d->lun; 241071461b0fSAlexey Kardashevskiy return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev), 241171461b0fSAlexey Kardashevskiy (uint64_t)id << 32); 241271461b0fSAlexey Kardashevskiy } else if (usb) { 241371461b0fSAlexey Kardashevskiy /* 241471461b0fSAlexey Kardashevskiy * We use SRP luns of the form 01000000 | (usb-port << 16) | lun 241571461b0fSAlexey Kardashevskiy * in the top 32 bits of the 64-bit LUN 241671461b0fSAlexey Kardashevskiy */ 241771461b0fSAlexey Kardashevskiy unsigned usb_port = atoi(usb->port->path); 241871461b0fSAlexey Kardashevskiy unsigned id = 0x1000000 | (usb_port << 16) | d->lun; 241971461b0fSAlexey Kardashevskiy return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev), 242071461b0fSAlexey Kardashevskiy (uint64_t)id << 32); 242171461b0fSAlexey Kardashevskiy } 242271461b0fSAlexey Kardashevskiy } 242371461b0fSAlexey Kardashevskiy 2424b99260ebSThomas Huth /* 2425b99260ebSThomas Huth * SLOF probes the USB devices, and if it recognizes that the device is a 2426b99260ebSThomas Huth * storage device, it changes its name to "storage" instead of "usb-host", 2427b99260ebSThomas Huth * and additionally adds a child node for the SCSI LUN, so the correct 2428b99260ebSThomas Huth * boot path in SLOF is something like .../storage@1/disk@xxx" instead. 2429b99260ebSThomas Huth */ 2430b99260ebSThomas Huth if (strcmp("usb-host", qdev_fw_name(dev)) == 0) { 2431b99260ebSThomas Huth USBDevice *usbdev = CAST(USBDevice, dev, TYPE_USB_DEVICE); 2432b99260ebSThomas Huth if (usb_host_dev_is_scsi_storage(usbdev)) { 2433b99260ebSThomas Huth return g_strdup_printf("storage@%s/disk", usbdev->port->path); 2434b99260ebSThomas Huth } 2435b99260ebSThomas Huth } 2436b99260ebSThomas Huth 243771461b0fSAlexey Kardashevskiy if (phb) { 243871461b0fSAlexey Kardashevskiy /* Replace "pci" with "pci@800000020000000" */ 243971461b0fSAlexey Kardashevskiy return g_strdup_printf("pci@%"PRIX64, phb->buid); 244071461b0fSAlexey Kardashevskiy } 244171461b0fSAlexey Kardashevskiy 244271461b0fSAlexey Kardashevskiy return NULL; 244371461b0fSAlexey Kardashevskiy } 244471461b0fSAlexey Kardashevskiy 244523825581SEduardo Habkost static char *spapr_get_kvm_type(Object *obj, Error **errp) 244623825581SEduardo Habkost { 244728e02042SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 244823825581SEduardo Habkost 244928e02042SDavid Gibson return g_strdup(spapr->kvm_type); 245023825581SEduardo Habkost } 245123825581SEduardo Habkost 245223825581SEduardo Habkost static void spapr_set_kvm_type(Object *obj, const char *value, Error **errp) 245323825581SEduardo Habkost { 245428e02042SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 245523825581SEduardo Habkost 245628e02042SDavid Gibson g_free(spapr->kvm_type); 245728e02042SDavid Gibson spapr->kvm_type = g_strdup(value); 245823825581SEduardo Habkost } 245923825581SEduardo Habkost 2460f6229214SMichael Roth static bool spapr_get_modern_hotplug_events(Object *obj, Error **errp) 2461f6229214SMichael Roth { 2462f6229214SMichael Roth sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 2463f6229214SMichael Roth 2464f6229214SMichael Roth return spapr->use_hotplug_event_source; 2465f6229214SMichael Roth } 2466f6229214SMichael Roth 2467f6229214SMichael Roth static void spapr_set_modern_hotplug_events(Object *obj, bool value, 2468f6229214SMichael Roth Error **errp) 2469f6229214SMichael Roth { 2470f6229214SMichael Roth sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 2471f6229214SMichael Roth 2472f6229214SMichael Roth spapr->use_hotplug_event_source = value; 2473f6229214SMichael Roth } 2474f6229214SMichael Roth 247523825581SEduardo Habkost static void spapr_machine_initfn(Object *obj) 247623825581SEduardo Habkost { 2477715c5407SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 2478715c5407SDavid Gibson 2479715c5407SDavid Gibson spapr->htab_fd = -1; 2480f6229214SMichael Roth spapr->use_hotplug_event_source = true; 248123825581SEduardo Habkost object_property_add_str(obj, "kvm-type", 248223825581SEduardo Habkost spapr_get_kvm_type, spapr_set_kvm_type, NULL); 248349d2e648SMarcel Apfelbaum object_property_set_description(obj, "kvm-type", 248449d2e648SMarcel Apfelbaum "Specifies the KVM virtualization mode (HV, PR)", 248549d2e648SMarcel Apfelbaum NULL); 2486f6229214SMichael Roth object_property_add_bool(obj, "modern-hotplug-events", 2487f6229214SMichael Roth spapr_get_modern_hotplug_events, 2488f6229214SMichael Roth spapr_set_modern_hotplug_events, 2489f6229214SMichael Roth NULL); 2490f6229214SMichael Roth object_property_set_description(obj, "modern-hotplug-events", 2491f6229214SMichael Roth "Use dedicated hotplug event mechanism in" 2492f6229214SMichael Roth " place of standard EPOW events when possible" 2493f6229214SMichael Roth " (required for memory hot-unplug support)", 2494f6229214SMichael Roth NULL); 249523825581SEduardo Habkost } 249623825581SEduardo Habkost 249787bbdd9cSDavid Gibson static void spapr_machine_finalizefn(Object *obj) 249887bbdd9cSDavid Gibson { 249987bbdd9cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 250087bbdd9cSDavid Gibson 250187bbdd9cSDavid Gibson g_free(spapr->kvm_type); 250287bbdd9cSDavid Gibson } 250387bbdd9cSDavid Gibson 25041c7ad77eSNicholas Piggin void spapr_do_system_reset_on_cpu(CPUState *cs, run_on_cpu_data arg) 250534316482SAlexey Kardashevskiy { 250634316482SAlexey Kardashevskiy cpu_synchronize_state(cs); 250734316482SAlexey Kardashevskiy ppc_cpu_do_system_reset(cs); 250834316482SAlexey Kardashevskiy } 250934316482SAlexey Kardashevskiy 251034316482SAlexey Kardashevskiy static void spapr_nmi(NMIState *n, int cpu_index, Error **errp) 251134316482SAlexey Kardashevskiy { 251234316482SAlexey Kardashevskiy CPUState *cs; 251334316482SAlexey Kardashevskiy 251434316482SAlexey Kardashevskiy CPU_FOREACH(cs) { 25151c7ad77eSNicholas Piggin async_run_on_cpu(cs, spapr_do_system_reset_on_cpu, RUN_ON_CPU_NULL); 251634316482SAlexey Kardashevskiy } 251734316482SAlexey Kardashevskiy } 251834316482SAlexey Kardashevskiy 251979b78a6bSMichael Roth static void spapr_add_lmbs(DeviceState *dev, uint64_t addr_start, uint64_t size, 252079b78a6bSMichael Roth uint32_t node, bool dedicated_hp_event_source, 252179b78a6bSMichael Roth Error **errp) 2522c20d332aSBharata B Rao { 2523c20d332aSBharata B Rao sPAPRDRConnector *drc; 2524c20d332aSBharata B Rao sPAPRDRConnectorClass *drck; 2525c20d332aSBharata B Rao uint32_t nr_lmbs = size/SPAPR_MEMORY_BLOCK_SIZE; 2526c20d332aSBharata B Rao int i, fdt_offset, fdt_size; 2527c20d332aSBharata B Rao void *fdt; 252879b78a6bSMichael Roth uint64_t addr = addr_start; 2529c20d332aSBharata B Rao 2530c20d332aSBharata B Rao for (i = 0; i < nr_lmbs; i++) { 2531c20d332aSBharata B Rao drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_LMB, 2532c20d332aSBharata B Rao addr/SPAPR_MEMORY_BLOCK_SIZE); 2533c20d332aSBharata B Rao g_assert(drc); 2534c20d332aSBharata B Rao 2535c20d332aSBharata B Rao fdt = create_device_tree(&fdt_size); 2536c20d332aSBharata B Rao fdt_offset = spapr_populate_memory_node(fdt, node, addr, 2537c20d332aSBharata B Rao SPAPR_MEMORY_BLOCK_SIZE); 2538c20d332aSBharata B Rao 2539c20d332aSBharata B Rao drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 2540c20d332aSBharata B Rao drck->attach(drc, dev, fdt, fdt_offset, !dev->hotplugged, errp); 2541c20d332aSBharata B Rao addr += SPAPR_MEMORY_BLOCK_SIZE; 25425c0139a8SMichael Roth if (!dev->hotplugged) { 25435c0139a8SMichael Roth /* guests expect coldplugged LMBs to be pre-allocated */ 25445c0139a8SMichael Roth drck->set_allocation_state(drc, SPAPR_DR_ALLOCATION_STATE_USABLE); 25455c0139a8SMichael Roth drck->set_isolation_state(drc, SPAPR_DR_ISOLATION_STATE_UNISOLATED); 25465c0139a8SMichael Roth } 2547c20d332aSBharata B Rao } 25485dd5238cSJianjun Duan /* send hotplug notification to the 25495dd5238cSJianjun Duan * guest only in case of hotplugged memory 25505dd5238cSJianjun Duan */ 25515dd5238cSJianjun Duan if (dev->hotplugged) { 255279b78a6bSMichael Roth if (dedicated_hp_event_source) { 255379b78a6bSMichael Roth drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_LMB, 255479b78a6bSMichael Roth addr_start / SPAPR_MEMORY_BLOCK_SIZE); 255579b78a6bSMichael Roth drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 255679b78a6bSMichael Roth spapr_hotplug_req_add_by_count_indexed(SPAPR_DR_CONNECTOR_TYPE_LMB, 255779b78a6bSMichael Roth nr_lmbs, 255879b78a6bSMichael Roth drck->get_index(drc)); 255979b78a6bSMichael Roth } else { 256079b78a6bSMichael Roth spapr_hotplug_req_add_by_count(SPAPR_DR_CONNECTOR_TYPE_LMB, 256179b78a6bSMichael Roth nr_lmbs); 256279b78a6bSMichael Roth } 2563c20d332aSBharata B Rao } 25645dd5238cSJianjun Duan } 2565c20d332aSBharata B Rao 2566c20d332aSBharata B Rao static void spapr_memory_plug(HotplugHandler *hotplug_dev, DeviceState *dev, 2567c20d332aSBharata B Rao uint32_t node, Error **errp) 2568c20d332aSBharata B Rao { 2569c20d332aSBharata B Rao Error *local_err = NULL; 2570c20d332aSBharata B Rao sPAPRMachineState *ms = SPAPR_MACHINE(hotplug_dev); 2571c20d332aSBharata B Rao PCDIMMDevice *dimm = PC_DIMM(dev); 2572c20d332aSBharata B Rao PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); 2573c20d332aSBharata B Rao MemoryRegion *mr = ddc->get_memory_region(dimm); 2574c20d332aSBharata B Rao uint64_t align = memory_region_get_alignment(mr); 2575c20d332aSBharata B Rao uint64_t size = memory_region_size(mr); 2576c20d332aSBharata B Rao uint64_t addr; 2577df587133SThomas Huth char *mem_dev; 2578c20d332aSBharata B Rao 2579c20d332aSBharata B Rao if (size % SPAPR_MEMORY_BLOCK_SIZE) { 2580c20d332aSBharata B Rao error_setg(&local_err, "Hotplugged memory size must be a multiple of " 2581c20d332aSBharata B Rao "%lld MB", SPAPR_MEMORY_BLOCK_SIZE/M_BYTE); 2582c20d332aSBharata B Rao goto out; 2583c20d332aSBharata B Rao } 2584c20d332aSBharata B Rao 2585df587133SThomas Huth mem_dev = object_property_get_str(OBJECT(dimm), PC_DIMM_MEMDEV_PROP, NULL); 2586df587133SThomas Huth if (mem_dev && !kvmppc_is_mem_backend_page_size_ok(mem_dev)) { 2587df587133SThomas Huth error_setg(&local_err, "Memory backend has bad page size. " 2588df587133SThomas Huth "Use 'memory-backend-file' with correct mem-path."); 2589df587133SThomas Huth goto out; 2590df587133SThomas Huth } 2591df587133SThomas Huth 2592d6a9b0b8SMichael S. Tsirkin pc_dimm_memory_plug(dev, &ms->hotplug_memory, mr, align, &local_err); 2593c20d332aSBharata B Rao if (local_err) { 2594c20d332aSBharata B Rao goto out; 2595c20d332aSBharata B Rao } 2596c20d332aSBharata B Rao 2597c20d332aSBharata B Rao addr = object_property_get_int(OBJECT(dimm), PC_DIMM_ADDR_PROP, &local_err); 2598c20d332aSBharata B Rao if (local_err) { 2599c20d332aSBharata B Rao pc_dimm_memory_unplug(dev, &ms->hotplug_memory, mr); 2600c20d332aSBharata B Rao goto out; 2601c20d332aSBharata B Rao } 2602c20d332aSBharata B Rao 260379b78a6bSMichael Roth spapr_add_lmbs(dev, addr, size, node, 260479b78a6bSMichael Roth spapr_ovec_test(ms->ov5_cas, OV5_HP_EVT), 260579b78a6bSMichael Roth &error_abort); 2606c20d332aSBharata B Rao 2607c20d332aSBharata B Rao out: 2608c20d332aSBharata B Rao error_propagate(errp, local_err); 2609c20d332aSBharata B Rao } 2610c20d332aSBharata B Rao 2611cf632463SBharata B Rao typedef struct sPAPRDIMMState { 2612cf632463SBharata B Rao uint32_t nr_lmbs; 2613cf632463SBharata B Rao } sPAPRDIMMState; 2614cf632463SBharata B Rao 2615cf632463SBharata B Rao static void spapr_lmb_release(DeviceState *dev, void *opaque) 2616cf632463SBharata B Rao { 2617cf632463SBharata B Rao sPAPRDIMMState *ds = (sPAPRDIMMState *)opaque; 2618cf632463SBharata B Rao HotplugHandler *hotplug_ctrl; 2619cf632463SBharata B Rao 2620cf632463SBharata B Rao if (--ds->nr_lmbs) { 2621cf632463SBharata B Rao return; 2622cf632463SBharata B Rao } 2623cf632463SBharata B Rao 2624cf632463SBharata B Rao g_free(ds); 2625cf632463SBharata B Rao 2626cf632463SBharata B Rao /* 2627cf632463SBharata B Rao * Now that all the LMBs have been removed by the guest, call the 2628cf632463SBharata B Rao * pc-dimm unplug handler to cleanup up the pc-dimm device. 2629cf632463SBharata B Rao */ 2630cf632463SBharata B Rao hotplug_ctrl = qdev_get_hotplug_handler(dev); 2631cf632463SBharata B Rao hotplug_handler_unplug(hotplug_ctrl, dev, &error_abort); 2632cf632463SBharata B Rao } 2633cf632463SBharata B Rao 2634cf632463SBharata B Rao static void spapr_del_lmbs(DeviceState *dev, uint64_t addr_start, uint64_t size, 2635cf632463SBharata B Rao Error **errp) 2636cf632463SBharata B Rao { 2637cf632463SBharata B Rao sPAPRDRConnector *drc; 2638cf632463SBharata B Rao sPAPRDRConnectorClass *drck; 2639cf632463SBharata B Rao uint32_t nr_lmbs = size / SPAPR_MEMORY_BLOCK_SIZE; 2640cf632463SBharata B Rao int i; 2641cf632463SBharata B Rao sPAPRDIMMState *ds = g_malloc0(sizeof(sPAPRDIMMState)); 2642cf632463SBharata B Rao uint64_t addr = addr_start; 2643cf632463SBharata B Rao 2644cf632463SBharata B Rao ds->nr_lmbs = nr_lmbs; 2645cf632463SBharata B Rao for (i = 0; i < nr_lmbs; i++) { 2646cf632463SBharata B Rao drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_LMB, 2647cf632463SBharata B Rao addr / SPAPR_MEMORY_BLOCK_SIZE); 2648cf632463SBharata B Rao g_assert(drc); 2649cf632463SBharata B Rao 2650cf632463SBharata B Rao drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 2651cf632463SBharata B Rao drck->detach(drc, dev, spapr_lmb_release, ds, errp); 2652cf632463SBharata B Rao addr += SPAPR_MEMORY_BLOCK_SIZE; 2653cf632463SBharata B Rao } 2654cf632463SBharata B Rao 2655cf632463SBharata B Rao drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_LMB, 2656cf632463SBharata B Rao addr_start / SPAPR_MEMORY_BLOCK_SIZE); 2657cf632463SBharata B Rao drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 2658cf632463SBharata B Rao spapr_hotplug_req_remove_by_count_indexed(SPAPR_DR_CONNECTOR_TYPE_LMB, 2659cf632463SBharata B Rao nr_lmbs, 2660cf632463SBharata B Rao drck->get_index(drc)); 2661cf632463SBharata B Rao } 2662cf632463SBharata B Rao 2663cf632463SBharata B Rao static void spapr_memory_unplug(HotplugHandler *hotplug_dev, DeviceState *dev, 2664cf632463SBharata B Rao Error **errp) 2665cf632463SBharata B Rao { 2666cf632463SBharata B Rao sPAPRMachineState *ms = SPAPR_MACHINE(hotplug_dev); 2667cf632463SBharata B Rao PCDIMMDevice *dimm = PC_DIMM(dev); 2668cf632463SBharata B Rao PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); 2669cf632463SBharata B Rao MemoryRegion *mr = ddc->get_memory_region(dimm); 2670cf632463SBharata B Rao 2671cf632463SBharata B Rao pc_dimm_memory_unplug(dev, &ms->hotplug_memory, mr); 2672cf632463SBharata B Rao object_unparent(OBJECT(dev)); 2673cf632463SBharata B Rao } 2674cf632463SBharata B Rao 2675cf632463SBharata B Rao static void spapr_memory_unplug_request(HotplugHandler *hotplug_dev, 2676cf632463SBharata B Rao DeviceState *dev, Error **errp) 2677cf632463SBharata B Rao { 2678cf632463SBharata B Rao Error *local_err = NULL; 2679cf632463SBharata B Rao PCDIMMDevice *dimm = PC_DIMM(dev); 2680cf632463SBharata B Rao PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); 2681cf632463SBharata B Rao MemoryRegion *mr = ddc->get_memory_region(dimm); 2682cf632463SBharata B Rao uint64_t size = memory_region_size(mr); 2683cf632463SBharata B Rao uint64_t addr; 2684cf632463SBharata B Rao 2685cf632463SBharata B Rao addr = object_property_get_int(OBJECT(dimm), PC_DIMM_ADDR_PROP, &local_err); 2686cf632463SBharata B Rao if (local_err) { 2687cf632463SBharata B Rao goto out; 2688cf632463SBharata B Rao } 2689cf632463SBharata B Rao 2690cf632463SBharata B Rao spapr_del_lmbs(dev, addr, size, &error_abort); 2691cf632463SBharata B Rao out: 2692cf632463SBharata B Rao error_propagate(errp, local_err); 2693cf632463SBharata B Rao } 2694cf632463SBharata B Rao 2695af81cf32SBharata B Rao void *spapr_populate_hotplug_cpu_dt(CPUState *cs, int *fdt_offset, 2696af81cf32SBharata B Rao sPAPRMachineState *spapr) 2697af81cf32SBharata B Rao { 2698af81cf32SBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(cs); 2699af81cf32SBharata B Rao DeviceClass *dc = DEVICE_GET_CLASS(cs); 2700af81cf32SBharata B Rao int id = ppc_get_vcpu_dt_id(cpu); 2701af81cf32SBharata B Rao void *fdt; 2702af81cf32SBharata B Rao int offset, fdt_size; 2703af81cf32SBharata B Rao char *nodename; 2704af81cf32SBharata B Rao 2705af81cf32SBharata B Rao fdt = create_device_tree(&fdt_size); 2706af81cf32SBharata B Rao nodename = g_strdup_printf("%s@%x", dc->fw_name, id); 2707af81cf32SBharata B Rao offset = fdt_add_subnode(fdt, 0, nodename); 2708af81cf32SBharata B Rao 2709af81cf32SBharata B Rao spapr_populate_cpu_dt(cs, fdt, offset, spapr); 2710af81cf32SBharata B Rao g_free(nodename); 2711af81cf32SBharata B Rao 2712af81cf32SBharata B Rao *fdt_offset = offset; 2713af81cf32SBharata B Rao return fdt; 2714af81cf32SBharata B Rao } 2715af81cf32SBharata B Rao 2716115debf2SIgor Mammedov static void spapr_core_unplug(HotplugHandler *hotplug_dev, DeviceState *dev, 2717115debf2SIgor Mammedov Error **errp) 2718ff9006ddSIgor Mammedov { 2719535455fdSIgor Mammedov MachineState *ms = MACHINE(qdev_get_machine()); 2720ff9006ddSIgor Mammedov CPUCore *cc = CPU_CORE(dev); 2721535455fdSIgor Mammedov CPUArchId *core_slot = spapr_find_cpu_slot(ms, cc->core_id, NULL); 2722ff9006ddSIgor Mammedov 2723535455fdSIgor Mammedov core_slot->cpu = NULL; 2724ff9006ddSIgor Mammedov object_unparent(OBJECT(dev)); 2725ff9006ddSIgor Mammedov } 2726ff9006ddSIgor Mammedov 2727115debf2SIgor Mammedov static void spapr_core_release(DeviceState *dev, void *opaque) 2728115debf2SIgor Mammedov { 2729115debf2SIgor Mammedov HotplugHandler *hotplug_ctrl; 2730115debf2SIgor Mammedov 2731115debf2SIgor Mammedov hotplug_ctrl = qdev_get_hotplug_handler(dev); 2732115debf2SIgor Mammedov hotplug_handler_unplug(hotplug_ctrl, dev, &error_abort); 2733115debf2SIgor Mammedov } 2734115debf2SIgor Mammedov 2735115debf2SIgor Mammedov static 2736115debf2SIgor Mammedov void spapr_core_unplug_request(HotplugHandler *hotplug_dev, DeviceState *dev, 2737ff9006ddSIgor Mammedov Error **errp) 2738ff9006ddSIgor Mammedov { 2739535455fdSIgor Mammedov int index; 2740535455fdSIgor Mammedov sPAPRDRConnector *drc; 2741ff9006ddSIgor Mammedov sPAPRDRConnectorClass *drck; 2742ff9006ddSIgor Mammedov Error *local_err = NULL; 2743535455fdSIgor Mammedov CPUCore *cc = CPU_CORE(dev); 2744535455fdSIgor Mammedov int smt = kvmppc_smt_threads(); 2745ff9006ddSIgor Mammedov 2746535455fdSIgor Mammedov if (!spapr_find_cpu_slot(MACHINE(hotplug_dev), cc->core_id, &index)) { 2747535455fdSIgor Mammedov error_setg(errp, "Unable to find CPU core with core-id: %d", 2748535455fdSIgor Mammedov cc->core_id); 2749535455fdSIgor Mammedov return; 2750535455fdSIgor Mammedov } 2751ff9006ddSIgor Mammedov if (index == 0) { 2752ff9006ddSIgor Mammedov error_setg(errp, "Boot CPU core may not be unplugged"); 2753ff9006ddSIgor Mammedov return; 2754ff9006ddSIgor Mammedov } 2755ff9006ddSIgor Mammedov 2756535455fdSIgor Mammedov drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_CPU, index * smt); 2757ff9006ddSIgor Mammedov g_assert(drc); 2758ff9006ddSIgor Mammedov 2759ff9006ddSIgor Mammedov drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 2760ff9006ddSIgor Mammedov drck->detach(drc, dev, spapr_core_release, NULL, &local_err); 2761ff9006ddSIgor Mammedov if (local_err) { 2762ff9006ddSIgor Mammedov error_propagate(errp, local_err); 2763ff9006ddSIgor Mammedov return; 2764ff9006ddSIgor Mammedov } 2765ff9006ddSIgor Mammedov 2766ff9006ddSIgor Mammedov spapr_hotplug_req_remove_by_index(drc); 2767ff9006ddSIgor Mammedov } 2768ff9006ddSIgor Mammedov 2769ff9006ddSIgor Mammedov static void spapr_core_plug(HotplugHandler *hotplug_dev, DeviceState *dev, 2770ff9006ddSIgor Mammedov Error **errp) 2771ff9006ddSIgor Mammedov { 2772ff9006ddSIgor Mammedov sPAPRMachineState *spapr = SPAPR_MACHINE(OBJECT(hotplug_dev)); 2773ff9006ddSIgor Mammedov MachineClass *mc = MACHINE_GET_CLASS(spapr); 2774ff9006ddSIgor Mammedov sPAPRCPUCore *core = SPAPR_CPU_CORE(OBJECT(dev)); 2775ff9006ddSIgor Mammedov CPUCore *cc = CPU_CORE(dev); 2776ff9006ddSIgor Mammedov CPUState *cs = CPU(core->threads); 2777ff9006ddSIgor Mammedov sPAPRDRConnector *drc; 2778ff9006ddSIgor Mammedov Error *local_err = NULL; 2779ff9006ddSIgor Mammedov void *fdt = NULL; 2780ff9006ddSIgor Mammedov int fdt_offset = 0; 2781ff9006ddSIgor Mammedov int smt = kvmppc_smt_threads(); 2782535455fdSIgor Mammedov CPUArchId *core_slot; 2783535455fdSIgor Mammedov int index; 2784ff9006ddSIgor Mammedov 2785535455fdSIgor Mammedov core_slot = spapr_find_cpu_slot(MACHINE(hotplug_dev), cc->core_id, &index); 2786535455fdSIgor Mammedov if (!core_slot) { 2787535455fdSIgor Mammedov error_setg(errp, "Unable to find CPU core with core-id: %d", 2788535455fdSIgor Mammedov cc->core_id); 2789535455fdSIgor Mammedov return; 2790535455fdSIgor Mammedov } 2791ff9006ddSIgor Mammedov drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_CPU, index * smt); 2792ff9006ddSIgor Mammedov 2793c5514d0eSIgor Mammedov g_assert(drc || !mc->has_hotpluggable_cpus); 2794ff9006ddSIgor Mammedov 2795ff9006ddSIgor Mammedov /* 2796ff9006ddSIgor Mammedov * Setup CPU DT entries only for hotplugged CPUs. For boot time or 2797ff9006ddSIgor Mammedov * coldplugged CPUs DT entries are setup in spapr_build_fdt(). 2798ff9006ddSIgor Mammedov */ 2799ff9006ddSIgor Mammedov if (dev->hotplugged) { 2800ff9006ddSIgor Mammedov fdt = spapr_populate_hotplug_cpu_dt(cs, &fdt_offset, spapr); 2801ff9006ddSIgor Mammedov } 2802ff9006ddSIgor Mammedov 2803ff9006ddSIgor Mammedov if (drc) { 2804ff9006ddSIgor Mammedov sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 2805ff9006ddSIgor Mammedov drck->attach(drc, dev, fdt, fdt_offset, !dev->hotplugged, &local_err); 2806ff9006ddSIgor Mammedov if (local_err) { 2807ff9006ddSIgor Mammedov g_free(fdt); 2808ff9006ddSIgor Mammedov error_propagate(errp, local_err); 2809ff9006ddSIgor Mammedov return; 2810ff9006ddSIgor Mammedov } 2811ff9006ddSIgor Mammedov } 2812ff9006ddSIgor Mammedov 2813ff9006ddSIgor Mammedov if (dev->hotplugged) { 2814ff9006ddSIgor Mammedov /* 2815ff9006ddSIgor Mammedov * Send hotplug notification interrupt to the guest only in case 2816ff9006ddSIgor Mammedov * of hotplugged CPUs. 2817ff9006ddSIgor Mammedov */ 2818ff9006ddSIgor Mammedov spapr_hotplug_req_add_by_index(drc); 2819ff9006ddSIgor Mammedov } else { 2820ff9006ddSIgor Mammedov /* 2821ff9006ddSIgor Mammedov * Set the right DRC states for cold plugged CPU. 2822ff9006ddSIgor Mammedov */ 2823ff9006ddSIgor Mammedov if (drc) { 2824ff9006ddSIgor Mammedov sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 2825ff9006ddSIgor Mammedov drck->set_allocation_state(drc, SPAPR_DR_ALLOCATION_STATE_USABLE); 2826ff9006ddSIgor Mammedov drck->set_isolation_state(drc, SPAPR_DR_ISOLATION_STATE_UNISOLATED); 2827ff9006ddSIgor Mammedov } 2828ff9006ddSIgor Mammedov } 2829535455fdSIgor Mammedov core_slot->cpu = OBJECT(dev); 2830ff9006ddSIgor Mammedov } 2831ff9006ddSIgor Mammedov 2832ff9006ddSIgor Mammedov static void spapr_core_pre_plug(HotplugHandler *hotplug_dev, DeviceState *dev, 2833ff9006ddSIgor Mammedov Error **errp) 2834ff9006ddSIgor Mammedov { 2835ff9006ddSIgor Mammedov MachineState *machine = MACHINE(OBJECT(hotplug_dev)); 2836ff9006ddSIgor Mammedov MachineClass *mc = MACHINE_GET_CLASS(hotplug_dev); 2837ff9006ddSIgor Mammedov Error *local_err = NULL; 2838ff9006ddSIgor Mammedov CPUCore *cc = CPU_CORE(dev); 28390b8497f0SIgor Mammedov sPAPRCPUCore *sc = SPAPR_CPU_CORE(dev); 2840ff9006ddSIgor Mammedov char *base_core_type = spapr_get_cpu_core_type(machine->cpu_model); 2841ff9006ddSIgor Mammedov const char *type = object_get_typename(OBJECT(dev)); 2842535455fdSIgor Mammedov CPUArchId *core_slot; 28430b8497f0SIgor Mammedov int node_id; 2844535455fdSIgor Mammedov int index; 2845ff9006ddSIgor Mammedov 2846c5514d0eSIgor Mammedov if (dev->hotplugged && !mc->has_hotpluggable_cpus) { 2847ff9006ddSIgor Mammedov error_setg(&local_err, "CPU hotplug not supported for this machine"); 2848ff9006ddSIgor Mammedov goto out; 2849ff9006ddSIgor Mammedov } 2850ff9006ddSIgor Mammedov 2851ff9006ddSIgor Mammedov if (strcmp(base_core_type, type)) { 2852ff9006ddSIgor Mammedov error_setg(&local_err, "CPU core type should be %s", base_core_type); 2853ff9006ddSIgor Mammedov goto out; 2854ff9006ddSIgor Mammedov } 2855ff9006ddSIgor Mammedov 2856ff9006ddSIgor Mammedov if (cc->core_id % smp_threads) { 2857ff9006ddSIgor Mammedov error_setg(&local_err, "invalid core id %d", cc->core_id); 2858ff9006ddSIgor Mammedov goto out; 2859ff9006ddSIgor Mammedov } 2860ff9006ddSIgor Mammedov 28618149e299SDavid Gibson if (cc->nr_threads != smp_threads) { 28628149e299SDavid Gibson error_setg(errp, "invalid nr-threads %d, must be %d", 28638149e299SDavid Gibson cc->nr_threads, smp_threads); 28648149e299SDavid Gibson return; 28658149e299SDavid Gibson } 28668149e299SDavid Gibson 2867535455fdSIgor Mammedov core_slot = spapr_find_cpu_slot(MACHINE(hotplug_dev), cc->core_id, &index); 2868535455fdSIgor Mammedov if (!core_slot) { 2869ff9006ddSIgor Mammedov error_setg(&local_err, "core id %d out of range", cc->core_id); 2870ff9006ddSIgor Mammedov goto out; 2871ff9006ddSIgor Mammedov } 2872ff9006ddSIgor Mammedov 2873535455fdSIgor Mammedov if (core_slot->cpu) { 2874ff9006ddSIgor Mammedov error_setg(&local_err, "core %d already populated", cc->core_id); 2875ff9006ddSIgor Mammedov goto out; 2876ff9006ddSIgor Mammedov } 2877ff9006ddSIgor Mammedov 2878722387e7SIgor Mammedov node_id = core_slot->props.node_id; 2879722387e7SIgor Mammedov if (!core_slot->props.has_node_id) { 28800b8497f0SIgor Mammedov /* by default CPUState::numa_node was 0 if it's not set via CLI 28810b8497f0SIgor Mammedov * keep it this way for now but in future we probably should 28820b8497f0SIgor Mammedov * refuse to start up with incomplete numa mapping */ 28830b8497f0SIgor Mammedov node_id = 0; 28840b8497f0SIgor Mammedov } 28850b8497f0SIgor Mammedov if (sc->node_id == CPU_UNSET_NUMA_NODE_ID) { 28860b8497f0SIgor Mammedov sc->node_id = node_id; 28870b8497f0SIgor Mammedov } else if (sc->node_id != node_id) { 28880b8497f0SIgor Mammedov error_setg(&local_err, "node-id %d must match numa node specified" 28890b8497f0SIgor Mammedov "with -numa option for cpu-index %d", sc->node_id, cc->core_id); 28900b8497f0SIgor Mammedov goto out; 28910b8497f0SIgor Mammedov } 28920b8497f0SIgor Mammedov 2893ff9006ddSIgor Mammedov out: 2894ff9006ddSIgor Mammedov g_free(base_core_type); 2895ff9006ddSIgor Mammedov error_propagate(errp, local_err); 2896ff9006ddSIgor Mammedov } 2897ff9006ddSIgor Mammedov 2898c20d332aSBharata B Rao static void spapr_machine_device_plug(HotplugHandler *hotplug_dev, 2899c20d332aSBharata B Rao DeviceState *dev, Error **errp) 2900c20d332aSBharata B Rao { 2901c20d332aSBharata B Rao sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(qdev_get_machine()); 2902c20d332aSBharata B Rao 2903c20d332aSBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { 2904b556854bSBharata B Rao int node; 2905c20d332aSBharata B Rao 2906c20d332aSBharata B Rao if (!smc->dr_lmb_enabled) { 2907c20d332aSBharata B Rao error_setg(errp, "Memory hotplug not supported for this machine"); 2908c20d332aSBharata B Rao return; 2909c20d332aSBharata B Rao } 2910c20d332aSBharata B Rao node = object_property_get_int(OBJECT(dev), PC_DIMM_NODE_PROP, errp); 2911c20d332aSBharata B Rao if (*errp) { 2912c20d332aSBharata B Rao return; 2913c20d332aSBharata B Rao } 29141a5512bbSGonglei if (node < 0 || node >= MAX_NODES) { 29151a5512bbSGonglei error_setg(errp, "Invaild node %d", node); 29161a5512bbSGonglei return; 29171a5512bbSGonglei } 2918c20d332aSBharata B Rao 2919b556854bSBharata B Rao /* 2920b556854bSBharata B Rao * Currently PowerPC kernel doesn't allow hot-adding memory to 2921b556854bSBharata B Rao * memory-less node, but instead will silently add the memory 2922b556854bSBharata B Rao * to the first node that has some memory. This causes two 2923b556854bSBharata B Rao * unexpected behaviours for the user. 2924b556854bSBharata B Rao * 2925b556854bSBharata B Rao * - Memory gets hotplugged to a different node than what the user 2926b556854bSBharata B Rao * specified. 2927b556854bSBharata B Rao * - Since pc-dimm subsystem in QEMU still thinks that memory belongs 2928b556854bSBharata B Rao * to memory-less node, a reboot will set things accordingly 2929b556854bSBharata B Rao * and the previously hotplugged memory now ends in the right node. 2930b556854bSBharata B Rao * This appears as if some memory moved from one node to another. 2931b556854bSBharata B Rao * 2932b556854bSBharata B Rao * So until kernel starts supporting memory hotplug to memory-less 2933b556854bSBharata B Rao * nodes, just prevent such attempts upfront in QEMU. 2934b556854bSBharata B Rao */ 2935b556854bSBharata B Rao if (nb_numa_nodes && !numa_info[node].node_mem) { 2936b556854bSBharata B Rao error_setg(errp, "Can't hotplug memory to memory-less node %d", 2937b556854bSBharata B Rao node); 2938b556854bSBharata B Rao return; 2939b556854bSBharata B Rao } 2940b556854bSBharata B Rao 2941c20d332aSBharata B Rao spapr_memory_plug(hotplug_dev, dev, node, errp); 2942af81cf32SBharata B Rao } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 2943af81cf32SBharata B Rao spapr_core_plug(hotplug_dev, dev, errp); 2944c20d332aSBharata B Rao } 2945c20d332aSBharata B Rao } 2946c20d332aSBharata B Rao 2947c20d332aSBharata B Rao static void spapr_machine_device_unplug(HotplugHandler *hotplug_dev, 2948c20d332aSBharata B Rao DeviceState *dev, Error **errp) 2949c20d332aSBharata B Rao { 2950cf632463SBharata B Rao sPAPRMachineState *sms = SPAPR_MACHINE(qdev_get_machine()); 29513c0c47e3SDavid Gibson MachineClass *mc = MACHINE_GET_CLASS(qdev_get_machine()); 29526f4b5c3eSBharata B Rao 2953c20d332aSBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { 2954cf632463SBharata B Rao if (spapr_ovec_test(sms->ov5_cas, OV5_HP_EVT)) { 2955cf632463SBharata B Rao spapr_memory_unplug(hotplug_dev, dev, errp); 2956cf632463SBharata B Rao } else { 2957cf632463SBharata B Rao error_setg(errp, "Memory hot unplug not supported for this guest"); 2958cf632463SBharata B Rao } 2959cf632463SBharata B Rao } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 2960c5514d0eSIgor Mammedov if (!mc->has_hotpluggable_cpus) { 2961cf632463SBharata B Rao error_setg(errp, "CPU hot unplug not supported on this machine"); 2962cf632463SBharata B Rao return; 2963cf632463SBharata B Rao } 2964cf632463SBharata B Rao spapr_core_unplug(hotplug_dev, dev, errp); 2965cf632463SBharata B Rao } 2966cf632463SBharata B Rao } 2967cf632463SBharata B Rao 2968cf632463SBharata B Rao static void spapr_machine_device_unplug_request(HotplugHandler *hotplug_dev, 2969cf632463SBharata B Rao DeviceState *dev, Error **errp) 2970cf632463SBharata B Rao { 2971cf632463SBharata B Rao sPAPRMachineState *sms = SPAPR_MACHINE(qdev_get_machine()); 2972cf632463SBharata B Rao MachineClass *mc = MACHINE_GET_CLASS(qdev_get_machine()); 2973cf632463SBharata B Rao 2974cf632463SBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { 2975cf632463SBharata B Rao if (spapr_ovec_test(sms->ov5_cas, OV5_HP_EVT)) { 2976cf632463SBharata B Rao spapr_memory_unplug_request(hotplug_dev, dev, errp); 2977cf632463SBharata B Rao } else { 2978cf632463SBharata B Rao /* NOTE: this means there is a window after guest reset, prior to 2979cf632463SBharata B Rao * CAS negotiation, where unplug requests will fail due to the 2980cf632463SBharata B Rao * capability not being detected yet. This is a bit different than 2981cf632463SBharata B Rao * the case with PCI unplug, where the events will be queued and 2982cf632463SBharata B Rao * eventually handled by the guest after boot 2983cf632463SBharata B Rao */ 2984cf632463SBharata B Rao error_setg(errp, "Memory hot unplug not supported for this guest"); 2985cf632463SBharata B Rao } 29866f4b5c3eSBharata B Rao } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 2987c5514d0eSIgor Mammedov if (!mc->has_hotpluggable_cpus) { 29886f4b5c3eSBharata B Rao error_setg(errp, "CPU hot unplug not supported on this machine"); 29896f4b5c3eSBharata B Rao return; 29906f4b5c3eSBharata B Rao } 2991115debf2SIgor Mammedov spapr_core_unplug_request(hotplug_dev, dev, errp); 2992c20d332aSBharata B Rao } 2993c20d332aSBharata B Rao } 2994c20d332aSBharata B Rao 299594a94e4cSBharata B Rao static void spapr_machine_device_pre_plug(HotplugHandler *hotplug_dev, 299694a94e4cSBharata B Rao DeviceState *dev, Error **errp) 299794a94e4cSBharata B Rao { 299894a94e4cSBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 299994a94e4cSBharata B Rao spapr_core_pre_plug(hotplug_dev, dev, errp); 300094a94e4cSBharata B Rao } 300194a94e4cSBharata B Rao } 300294a94e4cSBharata B Rao 30037ebaf795SBharata B Rao static HotplugHandler *spapr_get_hotplug_handler(MachineState *machine, 3004c20d332aSBharata B Rao DeviceState *dev) 3005c20d332aSBharata B Rao { 300694a94e4cSBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM) || 300794a94e4cSBharata B Rao object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 3008c20d332aSBharata B Rao return HOTPLUG_HANDLER(machine); 3009c20d332aSBharata B Rao } 3010c20d332aSBharata B Rao return NULL; 3011c20d332aSBharata B Rao } 3012c20d332aSBharata B Rao 3013ea089eebSIgor Mammedov static CpuInstanceProperties 3014ea089eebSIgor Mammedov spapr_cpu_index_to_props(MachineState *machine, unsigned cpu_index) 301520bb648dSDavid Gibson { 3016ea089eebSIgor Mammedov CPUArchId *core_slot; 3017ea089eebSIgor Mammedov MachineClass *mc = MACHINE_GET_CLASS(machine); 3018ea089eebSIgor Mammedov 3019ea089eebSIgor Mammedov /* make sure possible_cpu are intialized */ 3020ea089eebSIgor Mammedov mc->possible_cpu_arch_ids(machine); 3021ea089eebSIgor Mammedov /* get CPU core slot containing thread that matches cpu_index */ 3022ea089eebSIgor Mammedov core_slot = spapr_find_cpu_slot(machine, cpu_index, NULL); 3023ea089eebSIgor Mammedov assert(core_slot); 3024ea089eebSIgor Mammedov return core_slot->props; 302520bb648dSDavid Gibson } 302620bb648dSDavid Gibson 3027535455fdSIgor Mammedov static const CPUArchIdList *spapr_possible_cpu_arch_ids(MachineState *machine) 3028535455fdSIgor Mammedov { 3029535455fdSIgor Mammedov int i; 3030535455fdSIgor Mammedov int spapr_max_cores = max_cpus / smp_threads; 3031535455fdSIgor Mammedov MachineClass *mc = MACHINE_GET_CLASS(machine); 3032535455fdSIgor Mammedov 3033c5514d0eSIgor Mammedov if (!mc->has_hotpluggable_cpus) { 3034535455fdSIgor Mammedov spapr_max_cores = QEMU_ALIGN_UP(smp_cpus, smp_threads) / smp_threads; 3035535455fdSIgor Mammedov } 3036535455fdSIgor Mammedov if (machine->possible_cpus) { 3037535455fdSIgor Mammedov assert(machine->possible_cpus->len == spapr_max_cores); 3038535455fdSIgor Mammedov return machine->possible_cpus; 3039535455fdSIgor Mammedov } 3040535455fdSIgor Mammedov 3041535455fdSIgor Mammedov machine->possible_cpus = g_malloc0(sizeof(CPUArchIdList) + 3042535455fdSIgor Mammedov sizeof(CPUArchId) * spapr_max_cores); 3043535455fdSIgor Mammedov machine->possible_cpus->len = spapr_max_cores; 3044535455fdSIgor Mammedov for (i = 0; i < machine->possible_cpus->len; i++) { 3045535455fdSIgor Mammedov int core_id = i * smp_threads; 3046535455fdSIgor Mammedov 3047f2d672c2SIgor Mammedov machine->possible_cpus->cpus[i].vcpus_count = smp_threads; 3048535455fdSIgor Mammedov machine->possible_cpus->cpus[i].arch_id = core_id; 3049535455fdSIgor Mammedov machine->possible_cpus->cpus[i].props.has_core_id = true; 3050535455fdSIgor Mammedov machine->possible_cpus->cpus[i].props.core_id = core_id; 3051ea089eebSIgor Mammedov 3052ea089eebSIgor Mammedov /* default distribution of CPUs over NUMA nodes */ 3053ea089eebSIgor Mammedov if (nb_numa_nodes) { 3054ea089eebSIgor Mammedov /* preset values but do not enable them i.e. 'has_node_id = false', 3055ea089eebSIgor Mammedov * numa init code will enable them later if manual mapping wasn't 3056ea089eebSIgor Mammedov * present on CLI */ 3057ea089eebSIgor Mammedov machine->possible_cpus->cpus[i].props.node_id = 3058ea089eebSIgor Mammedov core_id / smp_threads / smp_cores % nb_numa_nodes; 3059ea089eebSIgor Mammedov } 3060535455fdSIgor Mammedov } 3061535455fdSIgor Mammedov return machine->possible_cpus; 3062535455fdSIgor Mammedov } 3063535455fdSIgor Mammedov 30646737d9adSDavid Gibson static void spapr_phb_placement(sPAPRMachineState *spapr, uint32_t index, 3065daa23699SDavid Gibson uint64_t *buid, hwaddr *pio, 3066daa23699SDavid Gibson hwaddr *mmio32, hwaddr *mmio64, 30676737d9adSDavid Gibson unsigned n_dma, uint32_t *liobns, Error **errp) 30686737d9adSDavid Gibson { 3069357d1e3bSDavid Gibson /* 3070357d1e3bSDavid Gibson * New-style PHB window placement. 3071357d1e3bSDavid Gibson * 3072357d1e3bSDavid Gibson * Goals: Gives large (1TiB), naturally aligned 64-bit MMIO window 3073357d1e3bSDavid Gibson * for each PHB, in addition to 2GiB 32-bit MMIO and 64kiB PIO 3074357d1e3bSDavid Gibson * windows. 3075357d1e3bSDavid Gibson * 3076357d1e3bSDavid Gibson * Some guest kernels can't work with MMIO windows above 1<<46 3077357d1e3bSDavid Gibson * (64TiB), so we place up to 31 PHBs in the area 32TiB..64TiB 3078357d1e3bSDavid Gibson * 3079357d1e3bSDavid Gibson * 32TiB..(33TiB+1984kiB) contains the 64kiB PIO windows for each 3080357d1e3bSDavid Gibson * PHB stacked together. (32TiB+2GiB)..(32TiB+64GiB) contains the 3081357d1e3bSDavid Gibson * 2GiB 32-bit MMIO windows for each PHB. Then 33..64TiB has the 3082357d1e3bSDavid Gibson * 1TiB 64-bit MMIO windows for each PHB. 3083357d1e3bSDavid Gibson */ 30846737d9adSDavid Gibson const uint64_t base_buid = 0x800000020000000ULL; 308525e6a118SMichael S. Tsirkin #define SPAPR_MAX_PHBS ((SPAPR_PCI_LIMIT - SPAPR_PCI_BASE) / \ 308625e6a118SMichael S. Tsirkin SPAPR_PCI_MEM64_WIN_SIZE - 1) 30876737d9adSDavid Gibson int i; 30886737d9adSDavid Gibson 3089357d1e3bSDavid Gibson /* Sanity check natural alignments */ 3090357d1e3bSDavid Gibson QEMU_BUILD_BUG_ON((SPAPR_PCI_BASE % SPAPR_PCI_MEM64_WIN_SIZE) != 0); 3091357d1e3bSDavid Gibson QEMU_BUILD_BUG_ON((SPAPR_PCI_LIMIT % SPAPR_PCI_MEM64_WIN_SIZE) != 0); 3092357d1e3bSDavid Gibson QEMU_BUILD_BUG_ON((SPAPR_PCI_MEM64_WIN_SIZE % SPAPR_PCI_MEM32_WIN_SIZE) != 0); 3093357d1e3bSDavid Gibson QEMU_BUILD_BUG_ON((SPAPR_PCI_MEM32_WIN_SIZE % SPAPR_PCI_IO_WIN_SIZE) != 0); 3094357d1e3bSDavid Gibson /* Sanity check bounds */ 309525e6a118SMichael S. Tsirkin QEMU_BUILD_BUG_ON((SPAPR_MAX_PHBS * SPAPR_PCI_IO_WIN_SIZE) > 309625e6a118SMichael S. Tsirkin SPAPR_PCI_MEM32_WIN_SIZE); 309725e6a118SMichael S. Tsirkin QEMU_BUILD_BUG_ON((SPAPR_MAX_PHBS * SPAPR_PCI_MEM32_WIN_SIZE) > 309825e6a118SMichael S. Tsirkin SPAPR_PCI_MEM64_WIN_SIZE); 30992efff1c0SDavid Gibson 310025e6a118SMichael S. Tsirkin if (index >= SPAPR_MAX_PHBS) { 310125e6a118SMichael S. Tsirkin error_setg(errp, "\"index\" for PAPR PHB is too large (max %llu)", 310225e6a118SMichael S. Tsirkin SPAPR_MAX_PHBS - 1); 31036737d9adSDavid Gibson return; 31046737d9adSDavid Gibson } 31056737d9adSDavid Gibson 31066737d9adSDavid Gibson *buid = base_buid + index; 31076737d9adSDavid Gibson for (i = 0; i < n_dma; ++i) { 31086737d9adSDavid Gibson liobns[i] = SPAPR_PCI_LIOBN(index, i); 31096737d9adSDavid Gibson } 31106737d9adSDavid Gibson 3111357d1e3bSDavid Gibson *pio = SPAPR_PCI_BASE + index * SPAPR_PCI_IO_WIN_SIZE; 3112357d1e3bSDavid Gibson *mmio32 = SPAPR_PCI_BASE + (index + 1) * SPAPR_PCI_MEM32_WIN_SIZE; 3113357d1e3bSDavid Gibson *mmio64 = SPAPR_PCI_BASE + (index + 1) * SPAPR_PCI_MEM64_WIN_SIZE; 31146737d9adSDavid Gibson } 31156737d9adSDavid Gibson 31167844e12bSCédric Le Goater static ICSState *spapr_ics_get(XICSFabric *dev, int irq) 31177844e12bSCédric Le Goater { 31187844e12bSCédric Le Goater sPAPRMachineState *spapr = SPAPR_MACHINE(dev); 31197844e12bSCédric Le Goater 31207844e12bSCédric Le Goater return ics_valid_irq(spapr->ics, irq) ? spapr->ics : NULL; 31217844e12bSCédric Le Goater } 31227844e12bSCédric Le Goater 31237844e12bSCédric Le Goater static void spapr_ics_resend(XICSFabric *dev) 31247844e12bSCédric Le Goater { 31257844e12bSCédric Le Goater sPAPRMachineState *spapr = SPAPR_MACHINE(dev); 31267844e12bSCédric Le Goater 31277844e12bSCédric Le Goater ics_resend(spapr->ics); 31287844e12bSCédric Le Goater } 31297844e12bSCédric Le Goater 313006747ba6SCédric Le Goater static ICPState *spapr_icp_get(XICSFabric *xi, int cpu_dt_id) 3131b2fc59aaSCédric Le Goater { 31325bc8d26dSCédric Le Goater PowerPCCPU *cpu = ppc_get_vcpu_by_dt_id(cpu_dt_id); 3133b2fc59aaSCédric Le Goater 31345bc8d26dSCédric Le Goater return cpu ? ICP(cpu->intc) : NULL; 3135b2fc59aaSCédric Le Goater } 3136b2fc59aaSCédric Le Goater 31376449da45SCédric Le Goater static void spapr_pic_print_info(InterruptStatsProvider *obj, 31386449da45SCédric Le Goater Monitor *mon) 31396449da45SCédric Le Goater { 31406449da45SCédric Le Goater sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 31415bc8d26dSCédric Le Goater CPUState *cs; 31426449da45SCédric Le Goater 31435bc8d26dSCédric Le Goater CPU_FOREACH(cs) { 31445bc8d26dSCédric Le Goater PowerPCCPU *cpu = POWERPC_CPU(cs); 31455bc8d26dSCédric Le Goater 31465bc8d26dSCédric Le Goater icp_pic_print_info(ICP(cpu->intc), mon); 31476449da45SCédric Le Goater } 31486449da45SCédric Le Goater 31496449da45SCédric Le Goater ics_pic_print_info(spapr->ics, mon); 31506449da45SCédric Le Goater } 31516449da45SCédric Le Goater 315229ee3247SAlexey Kardashevskiy static void spapr_machine_class_init(ObjectClass *oc, void *data) 315353018216SPaolo Bonzini { 315429ee3247SAlexey Kardashevskiy MachineClass *mc = MACHINE_CLASS(oc); 3155224245bfSDavid Gibson sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(oc); 315671461b0fSAlexey Kardashevskiy FWPathProviderClass *fwc = FW_PATH_PROVIDER_CLASS(oc); 315734316482SAlexey Kardashevskiy NMIClass *nc = NMI_CLASS(oc); 3158c20d332aSBharata B Rao HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(oc); 31591d1be34dSDavid Gibson PPCVirtualHypervisorClass *vhc = PPC_VIRTUAL_HYPERVISOR_CLASS(oc); 31607844e12bSCédric Le Goater XICSFabricClass *xic = XICS_FABRIC_CLASS(oc); 31616449da45SCédric Le Goater InterruptStatsProviderClass *ispc = INTERRUPT_STATS_PROVIDER_CLASS(oc); 316229ee3247SAlexey Kardashevskiy 31630eb9054cSDavid Gibson mc->desc = "pSeries Logical Partition (PAPR compliant)"; 3164fc9f38c3SDavid Gibson 3165fc9f38c3SDavid Gibson /* 3166fc9f38c3SDavid Gibson * We set up the default / latest behaviour here. The class_init 3167fc9f38c3SDavid Gibson * functions for the specific versioned machine types can override 3168fc9f38c3SDavid Gibson * these details for backwards compatibility 3169fc9f38c3SDavid Gibson */ 3170958db90cSMarcel Apfelbaum mc->init = ppc_spapr_init; 3171958db90cSMarcel Apfelbaum mc->reset = ppc_spapr_reset; 3172958db90cSMarcel Apfelbaum mc->block_default_type = IF_SCSI; 31736244bb7eSGreg Kurz mc->max_cpus = 1024; 3174958db90cSMarcel Apfelbaum mc->no_parallel = 1; 31755b2128d2SAlexander Graf mc->default_boot_order = ""; 3176a34944feSNikunj A Dadhania mc->default_ram_size = 512 * M_BYTE; 3177958db90cSMarcel Apfelbaum mc->kvm_type = spapr_kvm_type; 31789e3f9733SAlexander Graf mc->has_dynamic_sysbus = true; 3179e4024630SLaurent Vivier mc->pci_allow_0_address = true; 31807ebaf795SBharata B Rao mc->get_hotplug_handler = spapr_get_hotplug_handler; 318194a94e4cSBharata B Rao hc->pre_plug = spapr_machine_device_pre_plug; 3182c20d332aSBharata B Rao hc->plug = spapr_machine_device_plug; 3183c20d332aSBharata B Rao hc->unplug = spapr_machine_device_unplug; 3184ea089eebSIgor Mammedov mc->cpu_index_to_instance_props = spapr_cpu_index_to_props; 3185535455fdSIgor Mammedov mc->possible_cpu_arch_ids = spapr_possible_cpu_arch_ids; 3186cf632463SBharata B Rao hc->unplug_request = spapr_machine_device_unplug_request; 318700b4fbe2SMarcel Apfelbaum 3188fc9f38c3SDavid Gibson smc->dr_lmb_enabled = true; 31893daa4a9fSThomas Huth smc->tcg_default_cpu = "POWER8"; 3190c5514d0eSIgor Mammedov mc->has_hotpluggable_cpus = true; 319171461b0fSAlexey Kardashevskiy fwc->get_dev_path = spapr_get_fw_dev_path; 319234316482SAlexey Kardashevskiy nc->nmi_monitor_handler = spapr_nmi; 31936737d9adSDavid Gibson smc->phb_placement = spapr_phb_placement; 31941d1be34dSDavid Gibson vhc->hypercall = emulate_spapr_hypercall; 3195e57ca75cSDavid Gibson vhc->hpt_mask = spapr_hpt_mask; 3196e57ca75cSDavid Gibson vhc->map_hptes = spapr_map_hptes; 3197e57ca75cSDavid Gibson vhc->unmap_hptes = spapr_unmap_hptes; 3198e57ca75cSDavid Gibson vhc->store_hpte = spapr_store_hpte; 31999861bb3eSSuraj Jitindar Singh vhc->get_patbe = spapr_get_patbe; 32007844e12bSCédric Le Goater xic->ics_get = spapr_ics_get; 32017844e12bSCédric Le Goater xic->ics_resend = spapr_ics_resend; 3202b2fc59aaSCédric Le Goater xic->icp_get = spapr_icp_get; 32036449da45SCédric Le Goater ispc->print_info = spapr_pic_print_info; 320455641213SLaurent Vivier /* Force NUMA node memory size to be a multiple of 320555641213SLaurent Vivier * SPAPR_MEMORY_BLOCK_SIZE (256M) since that's the granularity 320655641213SLaurent Vivier * in which LMBs are represented and hot-added 320755641213SLaurent Vivier */ 320855641213SLaurent Vivier mc->numa_mem_align_shift = 28; 320953018216SPaolo Bonzini } 321053018216SPaolo Bonzini 321129ee3247SAlexey Kardashevskiy static const TypeInfo spapr_machine_info = { 321229ee3247SAlexey Kardashevskiy .name = TYPE_SPAPR_MACHINE, 321329ee3247SAlexey Kardashevskiy .parent = TYPE_MACHINE, 32144aee7362SDavid Gibson .abstract = true, 32156ca1502eSAlexey Kardashevskiy .instance_size = sizeof(sPAPRMachineState), 321623825581SEduardo Habkost .instance_init = spapr_machine_initfn, 321787bbdd9cSDavid Gibson .instance_finalize = spapr_machine_finalizefn, 3218183930c0SDavid Gibson .class_size = sizeof(sPAPRMachineClass), 321929ee3247SAlexey Kardashevskiy .class_init = spapr_machine_class_init, 322071461b0fSAlexey Kardashevskiy .interfaces = (InterfaceInfo[]) { 322171461b0fSAlexey Kardashevskiy { TYPE_FW_PATH_PROVIDER }, 322234316482SAlexey Kardashevskiy { TYPE_NMI }, 3223c20d332aSBharata B Rao { TYPE_HOTPLUG_HANDLER }, 32241d1be34dSDavid Gibson { TYPE_PPC_VIRTUAL_HYPERVISOR }, 32257844e12bSCédric Le Goater { TYPE_XICS_FABRIC }, 32266449da45SCédric Le Goater { TYPE_INTERRUPT_STATS_PROVIDER }, 322771461b0fSAlexey Kardashevskiy { } 322871461b0fSAlexey Kardashevskiy }, 322929ee3247SAlexey Kardashevskiy }; 323029ee3247SAlexey Kardashevskiy 3231fccbc785SDavid Gibson #define DEFINE_SPAPR_MACHINE(suffix, verstr, latest) \ 32325013c547SDavid Gibson static void spapr_machine_##suffix##_class_init(ObjectClass *oc, \ 32335013c547SDavid Gibson void *data) \ 32345013c547SDavid Gibson { \ 32355013c547SDavid Gibson MachineClass *mc = MACHINE_CLASS(oc); \ 32365013c547SDavid Gibson spapr_machine_##suffix##_class_options(mc); \ 3237fccbc785SDavid Gibson if (latest) { \ 3238fccbc785SDavid Gibson mc->alias = "pseries"; \ 3239fccbc785SDavid Gibson mc->is_default = 1; \ 3240fccbc785SDavid Gibson } \ 32415013c547SDavid Gibson } \ 32425013c547SDavid Gibson static void spapr_machine_##suffix##_instance_init(Object *obj) \ 32435013c547SDavid Gibson { \ 32445013c547SDavid Gibson MachineState *machine = MACHINE(obj); \ 32455013c547SDavid Gibson spapr_machine_##suffix##_instance_options(machine); \ 32465013c547SDavid Gibson } \ 32475013c547SDavid Gibson static const TypeInfo spapr_machine_##suffix##_info = { \ 32485013c547SDavid Gibson .name = MACHINE_TYPE_NAME("pseries-" verstr), \ 32495013c547SDavid Gibson .parent = TYPE_SPAPR_MACHINE, \ 32505013c547SDavid Gibson .class_init = spapr_machine_##suffix##_class_init, \ 32515013c547SDavid Gibson .instance_init = spapr_machine_##suffix##_instance_init, \ 32525013c547SDavid Gibson }; \ 32535013c547SDavid Gibson static void spapr_machine_register_##suffix(void) \ 32545013c547SDavid Gibson { \ 32555013c547SDavid Gibson type_register(&spapr_machine_##suffix##_info); \ 32565013c547SDavid Gibson } \ 32570e6aac87SEduardo Habkost type_init(spapr_machine_register_##suffix) 32585013c547SDavid Gibson 32591c5f29bbSDavid Gibson /* 32603fa14fbeSDavid Gibson * pseries-2.10 3261db800b21SDavid Gibson */ 32623fa14fbeSDavid Gibson static void spapr_machine_2_10_instance_options(MachineState *machine) 3263db800b21SDavid Gibson { 3264db800b21SDavid Gibson } 3265db800b21SDavid Gibson 32663fa14fbeSDavid Gibson static void spapr_machine_2_10_class_options(MachineClass *mc) 3267db800b21SDavid Gibson { 3268db800b21SDavid Gibson /* Defaults for the latest behaviour inherited from the base class */ 3269db800b21SDavid Gibson } 3270db800b21SDavid Gibson 32713fa14fbeSDavid Gibson DEFINE_SPAPR_MACHINE(2_10, "2.10", true); 32723fa14fbeSDavid Gibson 32733fa14fbeSDavid Gibson /* 32743fa14fbeSDavid Gibson * pseries-2.9 32753fa14fbeSDavid Gibson */ 32763fa14fbeSDavid Gibson #define SPAPR_COMPAT_2_9 \ 32773fa14fbeSDavid Gibson HW_COMPAT_2_9 32783fa14fbeSDavid Gibson 32793fa14fbeSDavid Gibson static void spapr_machine_2_9_instance_options(MachineState *machine) 32803fa14fbeSDavid Gibson { 32813fa14fbeSDavid Gibson spapr_machine_2_10_instance_options(machine); 32823fa14fbeSDavid Gibson } 32833fa14fbeSDavid Gibson 32843fa14fbeSDavid Gibson static void spapr_machine_2_9_class_options(MachineClass *mc) 32853fa14fbeSDavid Gibson { 32863fa14fbeSDavid Gibson spapr_machine_2_10_class_options(mc); 32873fa14fbeSDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_9); 32883bfe5716SLaurent Vivier mc->numa_auto_assign_ram = numa_legacy_auto_assign_ram; 32893fa14fbeSDavid Gibson } 32903fa14fbeSDavid Gibson 32913fa14fbeSDavid Gibson DEFINE_SPAPR_MACHINE(2_9, "2.9", false); 3292fa325e6cSDavid Gibson 3293fa325e6cSDavid Gibson /* 3294fa325e6cSDavid Gibson * pseries-2.8 3295fa325e6cSDavid Gibson */ 3296fa325e6cSDavid Gibson #define SPAPR_COMPAT_2_8 \ 329782516263SDavid Gibson HW_COMPAT_2_8 \ 329882516263SDavid Gibson { \ 329982516263SDavid Gibson .driver = TYPE_SPAPR_PCI_HOST_BRIDGE, \ 330082516263SDavid Gibson .property = "pcie-extended-configuration-space", \ 330182516263SDavid Gibson .value = "off", \ 330282516263SDavid Gibson }, 3303fa325e6cSDavid Gibson 3304fa325e6cSDavid Gibson static void spapr_machine_2_8_instance_options(MachineState *machine) 3305fa325e6cSDavid Gibson { 3306fa325e6cSDavid Gibson spapr_machine_2_9_instance_options(machine); 3307fa325e6cSDavid Gibson } 3308fa325e6cSDavid Gibson 3309fa325e6cSDavid Gibson static void spapr_machine_2_8_class_options(MachineClass *mc) 3310fa325e6cSDavid Gibson { 3311fa325e6cSDavid Gibson spapr_machine_2_9_class_options(mc); 3312fa325e6cSDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_8); 331355641213SLaurent Vivier mc->numa_mem_align_shift = 23; 3314fa325e6cSDavid Gibson } 3315fa325e6cSDavid Gibson 3316fa325e6cSDavid Gibson DEFINE_SPAPR_MACHINE(2_8, "2.8", false); 3317db800b21SDavid Gibson 3318db800b21SDavid Gibson /* 33191ea1eefcSBharata B Rao * pseries-2.7 33201ea1eefcSBharata B Rao */ 3321db800b21SDavid Gibson #define SPAPR_COMPAT_2_7 \ 3322db800b21SDavid Gibson HW_COMPAT_2_7 \ 3323357d1e3bSDavid Gibson { \ 3324357d1e3bSDavid Gibson .driver = TYPE_SPAPR_PCI_HOST_BRIDGE, \ 3325357d1e3bSDavid Gibson .property = "mem_win_size", \ 3326357d1e3bSDavid Gibson .value = stringify(SPAPR_PCI_2_7_MMIO_WIN_SIZE),\ 3327357d1e3bSDavid Gibson }, \ 3328357d1e3bSDavid Gibson { \ 3329357d1e3bSDavid Gibson .driver = TYPE_SPAPR_PCI_HOST_BRIDGE, \ 3330357d1e3bSDavid Gibson .property = "mem64_win_size", \ 3331357d1e3bSDavid Gibson .value = "0", \ 3332146c11f1SDavid Gibson }, \ 3333146c11f1SDavid Gibson { \ 3334146c11f1SDavid Gibson .driver = TYPE_POWERPC_CPU, \ 3335146c11f1SDavid Gibson .property = "pre-2.8-migration", \ 3336146c11f1SDavid Gibson .value = "on", \ 33375c4537bdSDavid Gibson }, \ 33385c4537bdSDavid Gibson { \ 33395c4537bdSDavid Gibson .driver = TYPE_SPAPR_PCI_HOST_BRIDGE, \ 33405c4537bdSDavid Gibson .property = "pre-2.8-migration", \ 33415c4537bdSDavid Gibson .value = "on", \ 3342357d1e3bSDavid Gibson }, 3343357d1e3bSDavid Gibson 3344357d1e3bSDavid Gibson static void phb_placement_2_7(sPAPRMachineState *spapr, uint32_t index, 3345357d1e3bSDavid Gibson uint64_t *buid, hwaddr *pio, 3346357d1e3bSDavid Gibson hwaddr *mmio32, hwaddr *mmio64, 3347357d1e3bSDavid Gibson unsigned n_dma, uint32_t *liobns, Error **errp) 3348357d1e3bSDavid Gibson { 3349357d1e3bSDavid Gibson /* Legacy PHB placement for pseries-2.7 and earlier machine types */ 3350357d1e3bSDavid Gibson const uint64_t base_buid = 0x800000020000000ULL; 3351357d1e3bSDavid Gibson const hwaddr phb_spacing = 0x1000000000ULL; /* 64 GiB */ 3352357d1e3bSDavid Gibson const hwaddr mmio_offset = 0xa0000000; /* 2 GiB + 512 MiB */ 3353357d1e3bSDavid Gibson const hwaddr pio_offset = 0x80000000; /* 2 GiB */ 3354357d1e3bSDavid Gibson const uint32_t max_index = 255; 3355357d1e3bSDavid Gibson const hwaddr phb0_alignment = 0x10000000000ULL; /* 1 TiB */ 3356357d1e3bSDavid Gibson 3357357d1e3bSDavid Gibson uint64_t ram_top = MACHINE(spapr)->ram_size; 3358357d1e3bSDavid Gibson hwaddr phb0_base, phb_base; 3359357d1e3bSDavid Gibson int i; 3360357d1e3bSDavid Gibson 3361357d1e3bSDavid Gibson /* Do we have hotpluggable memory? */ 3362357d1e3bSDavid Gibson if (MACHINE(spapr)->maxram_size > ram_top) { 3363357d1e3bSDavid Gibson /* Can't just use maxram_size, because there may be an 3364357d1e3bSDavid Gibson * alignment gap between normal and hotpluggable memory 3365357d1e3bSDavid Gibson * regions */ 3366357d1e3bSDavid Gibson ram_top = spapr->hotplug_memory.base + 3367357d1e3bSDavid Gibson memory_region_size(&spapr->hotplug_memory.mr); 3368357d1e3bSDavid Gibson } 3369357d1e3bSDavid Gibson 3370357d1e3bSDavid Gibson phb0_base = QEMU_ALIGN_UP(ram_top, phb0_alignment); 3371357d1e3bSDavid Gibson 3372357d1e3bSDavid Gibson if (index > max_index) { 3373357d1e3bSDavid Gibson error_setg(errp, "\"index\" for PAPR PHB is too large (max %u)", 3374357d1e3bSDavid Gibson max_index); 3375357d1e3bSDavid Gibson return; 3376357d1e3bSDavid Gibson } 3377357d1e3bSDavid Gibson 3378357d1e3bSDavid Gibson *buid = base_buid + index; 3379357d1e3bSDavid Gibson for (i = 0; i < n_dma; ++i) { 3380357d1e3bSDavid Gibson liobns[i] = SPAPR_PCI_LIOBN(index, i); 3381357d1e3bSDavid Gibson } 3382357d1e3bSDavid Gibson 3383357d1e3bSDavid Gibson phb_base = phb0_base + index * phb_spacing; 3384357d1e3bSDavid Gibson *pio = phb_base + pio_offset; 3385357d1e3bSDavid Gibson *mmio32 = phb_base + mmio_offset; 3386357d1e3bSDavid Gibson /* 3387357d1e3bSDavid Gibson * We don't set the 64-bit MMIO window, relying on the PHB's 3388357d1e3bSDavid Gibson * fallback behaviour of automatically splitting a large "32-bit" 3389357d1e3bSDavid Gibson * window into contiguous 32-bit and 64-bit windows 3390357d1e3bSDavid Gibson */ 3391357d1e3bSDavid Gibson } 3392db800b21SDavid Gibson 33931ea1eefcSBharata B Rao static void spapr_machine_2_7_instance_options(MachineState *machine) 33941ea1eefcSBharata B Rao { 3395f6229214SMichael Roth sPAPRMachineState *spapr = SPAPR_MACHINE(machine); 3396f6229214SMichael Roth 3397672de881SMichael Roth spapr_machine_2_8_instance_options(machine); 3398f6229214SMichael Roth spapr->use_hotplug_event_source = false; 33991ea1eefcSBharata B Rao } 34001ea1eefcSBharata B Rao 34011ea1eefcSBharata B Rao static void spapr_machine_2_7_class_options(MachineClass *mc) 34021ea1eefcSBharata B Rao { 34033daa4a9fSThomas Huth sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); 34043daa4a9fSThomas Huth 3405db800b21SDavid Gibson spapr_machine_2_8_class_options(mc); 34063daa4a9fSThomas Huth smc->tcg_default_cpu = "POWER7"; 3407db800b21SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_7); 3408357d1e3bSDavid Gibson smc->phb_placement = phb_placement_2_7; 34091ea1eefcSBharata B Rao } 34101ea1eefcSBharata B Rao 3411db800b21SDavid Gibson DEFINE_SPAPR_MACHINE(2_7, "2.7", false); 34121ea1eefcSBharata B Rao 34131ea1eefcSBharata B Rao /* 34144b23699cSDavid Gibson * pseries-2.6 34154b23699cSDavid Gibson */ 34161ea1eefcSBharata B Rao #define SPAPR_COMPAT_2_6 \ 3417ae4de14cSAlexey Kardashevskiy HW_COMPAT_2_6 \ 3418ae4de14cSAlexey Kardashevskiy { \ 3419ae4de14cSAlexey Kardashevskiy .driver = TYPE_SPAPR_PCI_HOST_BRIDGE,\ 3420ae4de14cSAlexey Kardashevskiy .property = "ddw",\ 3421ae4de14cSAlexey Kardashevskiy .value = stringify(off),\ 3422ae4de14cSAlexey Kardashevskiy }, 34231ea1eefcSBharata B Rao 34244b23699cSDavid Gibson static void spapr_machine_2_6_instance_options(MachineState *machine) 34254b23699cSDavid Gibson { 3426672de881SMichael Roth spapr_machine_2_7_instance_options(machine); 34274b23699cSDavid Gibson } 34284b23699cSDavid Gibson 34294b23699cSDavid Gibson static void spapr_machine_2_6_class_options(MachineClass *mc) 34304b23699cSDavid Gibson { 34311ea1eefcSBharata B Rao spapr_machine_2_7_class_options(mc); 3432c5514d0eSIgor Mammedov mc->has_hotpluggable_cpus = false; 34331ea1eefcSBharata B Rao SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_6); 34344b23699cSDavid Gibson } 34354b23699cSDavid Gibson 34361ea1eefcSBharata B Rao DEFINE_SPAPR_MACHINE(2_6, "2.6", false); 34374b23699cSDavid Gibson 34384b23699cSDavid Gibson /* 34391c5f29bbSDavid Gibson * pseries-2.5 34401c5f29bbSDavid Gibson */ 34414b23699cSDavid Gibson #define SPAPR_COMPAT_2_5 \ 344257c522f4SThomas Huth HW_COMPAT_2_5 \ 344357c522f4SThomas Huth { \ 344457c522f4SThomas Huth .driver = "spapr-vlan", \ 344557c522f4SThomas Huth .property = "use-rx-buffer-pools", \ 344657c522f4SThomas Huth .value = "off", \ 344757c522f4SThomas Huth }, 34484b23699cSDavid Gibson 34495013c547SDavid Gibson static void spapr_machine_2_5_instance_options(MachineState *machine) 34501c5f29bbSDavid Gibson { 3451672de881SMichael Roth spapr_machine_2_6_instance_options(machine); 34525013c547SDavid Gibson } 34535013c547SDavid Gibson 34545013c547SDavid Gibson static void spapr_machine_2_5_class_options(MachineClass *mc) 34555013c547SDavid Gibson { 345657040d45SThomas Huth sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); 345757040d45SThomas Huth 34584b23699cSDavid Gibson spapr_machine_2_6_class_options(mc); 345957040d45SThomas Huth smc->use_ohci_by_default = true; 34604b23699cSDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_5); 34611c5f29bbSDavid Gibson } 34621c5f29bbSDavid Gibson 34634b23699cSDavid Gibson DEFINE_SPAPR_MACHINE(2_5, "2.5", false); 34641c5f29bbSDavid Gibson 34651c5f29bbSDavid Gibson /* 34661c5f29bbSDavid Gibson * pseries-2.4 34671c5f29bbSDavid Gibson */ 346880fd50f9SCornelia Huck #define SPAPR_COMPAT_2_4 \ 346980fd50f9SCornelia Huck HW_COMPAT_2_4 347080fd50f9SCornelia Huck 34715013c547SDavid Gibson static void spapr_machine_2_4_instance_options(MachineState *machine) 34721c5f29bbSDavid Gibson { 34735013c547SDavid Gibson spapr_machine_2_5_instance_options(machine); 34745013c547SDavid Gibson } 34751c5f29bbSDavid Gibson 34765013c547SDavid Gibson static void spapr_machine_2_4_class_options(MachineClass *mc) 34775013c547SDavid Gibson { 3478fc9f38c3SDavid Gibson sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); 3479fc9f38c3SDavid Gibson 3480fc9f38c3SDavid Gibson spapr_machine_2_5_class_options(mc); 3481fc9f38c3SDavid Gibson smc->dr_lmb_enabled = false; 3482f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_4); 34831c5f29bbSDavid Gibson } 34841c5f29bbSDavid Gibson 3485fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_4, "2.4", false); 34861c5f29bbSDavid Gibson 34871c5f29bbSDavid Gibson /* 34881c5f29bbSDavid Gibson * pseries-2.3 34891c5f29bbSDavid Gibson */ 349038ff32c6SEduardo Habkost #define SPAPR_COMPAT_2_3 \ 34917619c7b0SMichael Roth HW_COMPAT_2_3 \ 34927619c7b0SMichael Roth {\ 34937619c7b0SMichael Roth .driver = "spapr-pci-host-bridge",\ 34947619c7b0SMichael Roth .property = "dynamic-reconfiguration",\ 34957619c7b0SMichael Roth .value = "off",\ 34967619c7b0SMichael Roth }, 349738ff32c6SEduardo Habkost 34985013c547SDavid Gibson static void spapr_machine_2_3_instance_options(MachineState *machine) 34991c5f29bbSDavid Gibson { 35005013c547SDavid Gibson spapr_machine_2_4_instance_options(machine); 35011c5f29bbSDavid Gibson savevm_skip_section_footers(); 35021c5f29bbSDavid Gibson global_state_set_optional(); 350309b5e30dSGreg Kurz savevm_skip_configuration(); 35041c5f29bbSDavid Gibson } 35051c5f29bbSDavid Gibson 35065013c547SDavid Gibson static void spapr_machine_2_3_class_options(MachineClass *mc) 35071c5f29bbSDavid Gibson { 3508fc9f38c3SDavid Gibson spapr_machine_2_4_class_options(mc); 3509f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_3); 35101c5f29bbSDavid Gibson } 3511fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_3, "2.3", false); 35121c5f29bbSDavid Gibson 35131c5f29bbSDavid Gibson /* 35141c5f29bbSDavid Gibson * pseries-2.2 35151c5f29bbSDavid Gibson */ 35161c5f29bbSDavid Gibson 3517b194df47SAlexey Kardashevskiy #define SPAPR_COMPAT_2_2 \ 35184dfd8eaaSEduardo Habkost HW_COMPAT_2_2 \ 3519b194df47SAlexey Kardashevskiy {\ 3520b194df47SAlexey Kardashevskiy .driver = TYPE_SPAPR_PCI_HOST_BRIDGE,\ 3521b194df47SAlexey Kardashevskiy .property = "mem_win_size",\ 3522b194df47SAlexey Kardashevskiy .value = "0x20000000",\ 3523dd754bafSEduardo Habkost }, 3524b194df47SAlexey Kardashevskiy 35255013c547SDavid Gibson static void spapr_machine_2_2_instance_options(MachineState *machine) 3526b0e966d0SJason Wang { 35275013c547SDavid Gibson spapr_machine_2_3_instance_options(machine); 3528cba0e779SGreg Kurz machine->suppress_vmdesc = true; 3529b0e966d0SJason Wang } 3530b0e966d0SJason Wang 35315013c547SDavid Gibson static void spapr_machine_2_2_class_options(MachineClass *mc) 3532b0e966d0SJason Wang { 3533fc9f38c3SDavid Gibson spapr_machine_2_3_class_options(mc); 3534f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_2); 35351c5f29bbSDavid Gibson } 3536fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_2, "2.2", false); 35371c5f29bbSDavid Gibson 35381c5f29bbSDavid Gibson /* 35391c5f29bbSDavid Gibson * pseries-2.1 35401c5f29bbSDavid Gibson */ 35411c5f29bbSDavid Gibson #define SPAPR_COMPAT_2_1 \ 35421c5f29bbSDavid Gibson HW_COMPAT_2_1 35431c5f29bbSDavid Gibson 35445013c547SDavid Gibson static void spapr_machine_2_1_instance_options(MachineState *machine) 35451c5f29bbSDavid Gibson { 35465013c547SDavid Gibson spapr_machine_2_2_instance_options(machine); 35471c5f29bbSDavid Gibson } 35481c5f29bbSDavid Gibson 35495013c547SDavid Gibson static void spapr_machine_2_1_class_options(MachineClass *mc) 3550b0e966d0SJason Wang { 3551fc9f38c3SDavid Gibson spapr_machine_2_2_class_options(mc); 3552f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_1); 35536026db45SAlexey Kardashevskiy } 3554fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_1, "2.1", false); 35556026db45SAlexey Kardashevskiy 355629ee3247SAlexey Kardashevskiy static void spapr_machine_register_types(void) 355729ee3247SAlexey Kardashevskiy { 355829ee3247SAlexey Kardashevskiy type_register_static(&spapr_machine_info); 355929ee3247SAlexey Kardashevskiy } 356029ee3247SAlexey Kardashevskiy 356129ee3247SAlexey Kardashevskiy type_init(spapr_machine_register_types) 3562