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" 433794d548SAlexey Kardashevskiy #include "qom/cpu.h" 4453018216SPaolo Bonzini 4553018216SPaolo Bonzini #include "hw/boards.h" 460d09e41aSPaolo Bonzini #include "hw/ppc/ppc.h" 4753018216SPaolo Bonzini #include "hw/loader.h" 4853018216SPaolo Bonzini 497804c353SCédric Le Goater #include "hw/ppc/fdt.h" 500d09e41aSPaolo Bonzini #include "hw/ppc/spapr.h" 510d09e41aSPaolo Bonzini #include "hw/ppc/spapr_vio.h" 520d09e41aSPaolo Bonzini #include "hw/pci-host/spapr.h" 530d09e41aSPaolo Bonzini #include "hw/ppc/xics.h" 5453018216SPaolo Bonzini #include "hw/pci/msi.h" 5553018216SPaolo Bonzini 5653018216SPaolo Bonzini #include "hw/pci/pci.h" 5771461b0fSAlexey Kardashevskiy #include "hw/scsi/scsi.h" 5871461b0fSAlexey Kardashevskiy #include "hw/virtio/virtio-scsi.h" 5953018216SPaolo Bonzini 6053018216SPaolo Bonzini #include "exec/address-spaces.h" 6153018216SPaolo Bonzini #include "hw/usb.h" 6253018216SPaolo Bonzini #include "qemu/config-file.h" 63135a129aSAneesh Kumar K.V #include "qemu/error-report.h" 642a6593cbSAlexey Kardashevskiy #include "trace.h" 6534316482SAlexey Kardashevskiy #include "hw/nmi.h" 6653018216SPaolo Bonzini 6768a27b20SMichael S. Tsirkin #include "hw/compat.h" 68f348b6d1SVeronia Bahaa #include "qemu/cutils.h" 6994a94e4cSBharata B Rao #include "hw/ppc/spapr_cpu_core.h" 702474bfd4SIgor Mammedov #include "qmp-commands.h" 7168a27b20SMichael S. Tsirkin 7253018216SPaolo Bonzini #include <libfdt.h> 7353018216SPaolo Bonzini 7453018216SPaolo Bonzini /* SLOF memory layout: 7553018216SPaolo Bonzini * 7653018216SPaolo Bonzini * SLOF raw image loaded at 0, copies its romfs right below the flat 7753018216SPaolo Bonzini * device-tree, then position SLOF itself 31M below that 7853018216SPaolo Bonzini * 7953018216SPaolo Bonzini * So we set FW_OVERHEAD to 40MB which should account for all of that 8053018216SPaolo Bonzini * and more 8153018216SPaolo Bonzini * 8253018216SPaolo Bonzini * We load our kernel at 4M, leaving space for SLOF initial image 8353018216SPaolo Bonzini */ 8438b02bd8SAlexey Kardashevskiy #define FDT_MAX_SIZE 0x100000 8553018216SPaolo Bonzini #define RTAS_MAX_SIZE 0x10000 86b7d1f77aSBenjamin Herrenschmidt #define RTAS_MAX_ADDR 0x80000000 /* RTAS must stay below that */ 8753018216SPaolo Bonzini #define FW_MAX_SIZE 0x400000 8853018216SPaolo Bonzini #define FW_FILE_NAME "slof.bin" 8953018216SPaolo Bonzini #define FW_OVERHEAD 0x2800000 9053018216SPaolo Bonzini #define KERNEL_LOAD_ADDR FW_MAX_SIZE 9153018216SPaolo Bonzini 9253018216SPaolo Bonzini #define MIN_RMA_SLOF 128UL 9353018216SPaolo Bonzini 9453018216SPaolo Bonzini #define PHANDLE_XICP 0x00001111 9553018216SPaolo Bonzini 9653018216SPaolo Bonzini #define HTAB_SIZE(spapr) (1ULL << ((spapr)->htab_shift)) 9753018216SPaolo Bonzini 98681bfadeSCédric Le Goater static XICSState *try_create_xics(sPAPRMachineState *spapr, 99681bfadeSCédric Le Goater const char *type, const char *type_ics, 100817bb6a4SCédric Le Goater const char *type_icp, int nr_servers, 101817bb6a4SCédric Le Goater int nr_irqs, Error **errp) 102c04d6cfaSAnthony Liguori { 1032cd908d0SCédric Le Goater XICSFabric *xi = XICS_FABRIC(spapr); 1044e4169f7SCédric Le Goater Error *err = NULL, *local_err = NULL; 1054e4169f7SCédric Le Goater XICSState *xics; 1064e4169f7SCédric Le Goater ICSState *ics = NULL; 107817bb6a4SCédric Le Goater int i; 108c04d6cfaSAnthony Liguori 1094e4169f7SCédric Le Goater xics = XICS_COMMON(object_new(type)); 1104e4169f7SCédric Le Goater qdev_set_parent_bus(DEVICE(xics), sysbus_get_default()); 111817bb6a4SCédric Le Goater object_property_set_bool(OBJECT(xics), true, "realized", &err); 11234f2af3dSMarkus Armbruster if (err) { 1134e4169f7SCédric Le Goater goto error; 114c04d6cfaSAnthony Liguori } 1154e4169f7SCédric Le Goater 1164e4169f7SCédric Le Goater ics = ICS_SIMPLE(object_new(type_ics)); 117*c79b2fddSCédric Le Goater qdev_set_parent_bus(DEVICE(ics), sysbus_get_default()); 118681bfadeSCédric Le Goater object_property_add_child(OBJECT(spapr), "ics", OBJECT(ics), NULL); 1194e4169f7SCédric Le Goater object_property_set_int(OBJECT(ics), nr_irqs, "nr-irqs", &err); 1204e4169f7SCédric Le Goater object_property_add_const_link(OBJECT(ics), "xics", OBJECT(xics), NULL); 1214e4169f7SCédric Le Goater object_property_set_bool(OBJECT(ics), true, "realized", &local_err); 1224e4169f7SCédric Le Goater error_propagate(&err, local_err); 1234e4169f7SCédric Le Goater if (err) { 1244e4169f7SCédric Le Goater goto error; 1254e4169f7SCédric Le Goater } 1264e4169f7SCédric Le Goater QLIST_INSERT_HEAD(&xics->ics, ics, list); 1274e4169f7SCédric Le Goater 128817bb6a4SCédric Le Goater xics->ss = g_malloc0(nr_servers * sizeof(ICPState)); 129817bb6a4SCédric Le Goater xics->nr_servers = nr_servers; 130817bb6a4SCédric Le Goater 131817bb6a4SCédric Le Goater for (i = 0; i < nr_servers; i++) { 132817bb6a4SCédric Le Goater ICPState *icp = &xics->ss[i]; 133817bb6a4SCédric Le Goater 134817bb6a4SCédric Le Goater object_initialize(icp, sizeof(*icp), type_icp); 135817bb6a4SCédric Le Goater object_property_add_child(OBJECT(xics), "icp[*]", OBJECT(icp), NULL); 1362cd908d0SCédric Le Goater object_property_add_const_link(OBJECT(icp), "xics", OBJECT(xi), NULL); 137817bb6a4SCédric Le Goater object_property_set_bool(OBJECT(icp), true, "realized", &err); 138817bb6a4SCédric Le Goater if (err) { 139817bb6a4SCédric Le Goater goto error; 140817bb6a4SCédric Le Goater } 141817bb6a4SCédric Le Goater object_unref(OBJECT(icp)); 142817bb6a4SCédric Le Goater } 143817bb6a4SCédric Le Goater 144681bfadeSCédric Le Goater spapr->ics = ics; 1454e4169f7SCédric Le Goater return xics; 1464e4169f7SCédric Le Goater 1474e4169f7SCédric Le Goater error: 1484e4169f7SCédric Le Goater error_propagate(errp, err); 1494e4169f7SCédric Le Goater if (ics) { 1504e4169f7SCédric Le Goater object_unparent(OBJECT(ics)); 1514e4169f7SCédric Le Goater } 1524e4169f7SCédric Le Goater object_unparent(OBJECT(xics)); 1534e4169f7SCédric Le Goater return NULL; 154c04d6cfaSAnthony Liguori } 155c04d6cfaSAnthony Liguori 156446f16a6SMarcel Apfelbaum static XICSState *xics_system_init(MachineState *machine, 1571e49182dSDavid Gibson int nr_servers, int nr_irqs, Error **errp) 158c04d6cfaSAnthony Liguori { 15927f24582SBenjamin Herrenschmidt XICSState *xics = NULL; 160c04d6cfaSAnthony Liguori 16111ad93f6SDavid Gibson if (kvm_enabled()) { 16234f2af3dSMarkus Armbruster Error *err = NULL; 16334f2af3dSMarkus Armbruster 164446f16a6SMarcel Apfelbaum if (machine_kernel_irqchip_allowed(machine)) { 165681bfadeSCédric Le Goater xics = try_create_xics(SPAPR_MACHINE(machine), 166681bfadeSCédric Le Goater TYPE_XICS_SPAPR_KVM, TYPE_ICS_KVM, 167817bb6a4SCédric Le Goater TYPE_KVM_ICP, nr_servers, nr_irqs, &err); 16811ad93f6SDavid Gibson } 16927f24582SBenjamin Herrenschmidt if (machine_kernel_irqchip_required(machine) && !xics) { 170b83baa60SMarkus Armbruster error_reportf_err(err, 171b83baa60SMarkus Armbruster "kernel_irqchip requested but unavailable: "); 172b83baa60SMarkus Armbruster } else { 173903a41d3SStefano Dong (董兴水) error_free(err); 17411ad93f6SDavid Gibson } 175b83baa60SMarkus Armbruster } 17611ad93f6SDavid Gibson 17727f24582SBenjamin Herrenschmidt if (!xics) { 178681bfadeSCédric Le Goater xics = try_create_xics(SPAPR_MACHINE(machine), 179681bfadeSCédric Le Goater TYPE_XICS_SPAPR, TYPE_ICS_SIMPLE, 180681bfadeSCédric Le Goater TYPE_ICP, nr_servers, nr_irqs, errp); 181c04d6cfaSAnthony Liguori } 182c04d6cfaSAnthony Liguori 18327f24582SBenjamin Herrenschmidt return xics; 184c04d6cfaSAnthony Liguori } 185c04d6cfaSAnthony Liguori 186833d4668SAlexey Kardashevskiy static int spapr_fixup_cpu_smt_dt(void *fdt, int offset, PowerPCCPU *cpu, 187833d4668SAlexey Kardashevskiy int smt_threads) 188833d4668SAlexey Kardashevskiy { 189833d4668SAlexey Kardashevskiy int i, ret = 0; 190833d4668SAlexey Kardashevskiy uint32_t servers_prop[smt_threads]; 191833d4668SAlexey Kardashevskiy uint32_t gservers_prop[smt_threads * 2]; 192833d4668SAlexey Kardashevskiy int index = ppc_get_vcpu_dt_id(cpu); 193833d4668SAlexey Kardashevskiy 194d6e166c0SDavid Gibson if (cpu->compat_pvr) { 195d6e166c0SDavid Gibson ret = fdt_setprop_cell(fdt, offset, "cpu-version", cpu->compat_pvr); 1966d9412eaSAlexey Kardashevskiy if (ret < 0) { 1976d9412eaSAlexey Kardashevskiy return ret; 1986d9412eaSAlexey Kardashevskiy } 1996d9412eaSAlexey Kardashevskiy } 2006d9412eaSAlexey Kardashevskiy 201833d4668SAlexey Kardashevskiy /* Build interrupt servers and gservers properties */ 202833d4668SAlexey Kardashevskiy for (i = 0; i < smt_threads; i++) { 203833d4668SAlexey Kardashevskiy servers_prop[i] = cpu_to_be32(index + i); 204833d4668SAlexey Kardashevskiy /* Hack, direct the group queues back to cpu 0 */ 205833d4668SAlexey Kardashevskiy gservers_prop[i*2] = cpu_to_be32(index + i); 206833d4668SAlexey Kardashevskiy gservers_prop[i*2 + 1] = 0; 207833d4668SAlexey Kardashevskiy } 208833d4668SAlexey Kardashevskiy ret = fdt_setprop(fdt, offset, "ibm,ppc-interrupt-server#s", 209833d4668SAlexey Kardashevskiy servers_prop, sizeof(servers_prop)); 210833d4668SAlexey Kardashevskiy if (ret < 0) { 211833d4668SAlexey Kardashevskiy return ret; 212833d4668SAlexey Kardashevskiy } 213833d4668SAlexey Kardashevskiy ret = fdt_setprop(fdt, offset, "ibm,ppc-interrupt-gserver#s", 214833d4668SAlexey Kardashevskiy gservers_prop, sizeof(gservers_prop)); 215833d4668SAlexey Kardashevskiy 216833d4668SAlexey Kardashevskiy return ret; 217833d4668SAlexey Kardashevskiy } 218833d4668SAlexey Kardashevskiy 2190da6f3feSBharata B Rao static int spapr_fixup_cpu_numa_dt(void *fdt, int offset, CPUState *cs) 2200da6f3feSBharata B Rao { 2210da6f3feSBharata B Rao int ret = 0; 2220da6f3feSBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(cs); 2230da6f3feSBharata B Rao int index = ppc_get_vcpu_dt_id(cpu); 2240da6f3feSBharata B Rao uint32_t associativity[] = {cpu_to_be32(0x5), 2250da6f3feSBharata B Rao cpu_to_be32(0x0), 2260da6f3feSBharata B Rao cpu_to_be32(0x0), 2270da6f3feSBharata B Rao cpu_to_be32(0x0), 2280da6f3feSBharata B Rao cpu_to_be32(cs->numa_node), 2290da6f3feSBharata B Rao cpu_to_be32(index)}; 2300da6f3feSBharata B Rao 2310da6f3feSBharata B Rao /* Advertise NUMA via ibm,associativity */ 2320da6f3feSBharata B Rao if (nb_numa_nodes > 1) { 2330da6f3feSBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,associativity", associativity, 2340da6f3feSBharata B Rao sizeof(associativity)); 2350da6f3feSBharata B Rao } 2360da6f3feSBharata B Rao 2370da6f3feSBharata B Rao return ret; 2380da6f3feSBharata B Rao } 2390da6f3feSBharata B Rao 24028e02042SDavid Gibson static int spapr_fixup_cpu_dt(void *fdt, sPAPRMachineState *spapr) 24153018216SPaolo Bonzini { 24282677ed2SAlexey Kardashevskiy int ret = 0, offset, cpus_offset; 24382677ed2SAlexey Kardashevskiy CPUState *cs; 24453018216SPaolo Bonzini char cpu_model[32]; 24553018216SPaolo Bonzini int smt = kvmppc_smt_threads(); 24653018216SPaolo Bonzini uint32_t pft_size_prop[] = {0, cpu_to_be32(spapr->htab_shift)}; 24753018216SPaolo Bonzini 24882677ed2SAlexey Kardashevskiy CPU_FOREACH(cs) { 24982677ed2SAlexey Kardashevskiy PowerPCCPU *cpu = POWERPC_CPU(cs); 25082677ed2SAlexey Kardashevskiy DeviceClass *dc = DEVICE_GET_CLASS(cs); 25182677ed2SAlexey Kardashevskiy int index = ppc_get_vcpu_dt_id(cpu); 25212dbeb16SDavid Gibson int compat_smt = MIN(smp_threads, ppc_compat_max_threads(cpu)); 25353018216SPaolo Bonzini 2540f20ba62SAlexey Kardashevskiy if ((index % smt) != 0) { 25553018216SPaolo Bonzini continue; 25653018216SPaolo Bonzini } 25753018216SPaolo Bonzini 25882677ed2SAlexey Kardashevskiy snprintf(cpu_model, 32, "%s@%x", dc->fw_name, index); 25953018216SPaolo Bonzini 26082677ed2SAlexey Kardashevskiy cpus_offset = fdt_path_offset(fdt, "/cpus"); 26182677ed2SAlexey Kardashevskiy if (cpus_offset < 0) { 26282677ed2SAlexey Kardashevskiy cpus_offset = fdt_add_subnode(fdt, fdt_path_offset(fdt, "/"), 26382677ed2SAlexey Kardashevskiy "cpus"); 26482677ed2SAlexey Kardashevskiy if (cpus_offset < 0) { 26582677ed2SAlexey Kardashevskiy return cpus_offset; 26682677ed2SAlexey Kardashevskiy } 26782677ed2SAlexey Kardashevskiy } 26882677ed2SAlexey Kardashevskiy offset = fdt_subnode_offset(fdt, cpus_offset, cpu_model); 26982677ed2SAlexey Kardashevskiy if (offset < 0) { 27082677ed2SAlexey Kardashevskiy offset = fdt_add_subnode(fdt, cpus_offset, cpu_model); 27153018216SPaolo Bonzini if (offset < 0) { 27253018216SPaolo Bonzini return offset; 27353018216SPaolo Bonzini } 27482677ed2SAlexey Kardashevskiy } 27553018216SPaolo Bonzini 2760da6f3feSBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,pft-size", 2770da6f3feSBharata B Rao pft_size_prop, sizeof(pft_size_prop)); 27853018216SPaolo Bonzini if (ret < 0) { 27953018216SPaolo Bonzini return ret; 28053018216SPaolo Bonzini } 28153018216SPaolo Bonzini 2820da6f3feSBharata B Rao ret = spapr_fixup_cpu_numa_dt(fdt, offset, cs); 28353018216SPaolo Bonzini if (ret < 0) { 28453018216SPaolo Bonzini return ret; 28553018216SPaolo Bonzini } 286833d4668SAlexey Kardashevskiy 28712dbeb16SDavid Gibson ret = spapr_fixup_cpu_smt_dt(fdt, offset, cpu, compat_smt); 288833d4668SAlexey Kardashevskiy if (ret < 0) { 289833d4668SAlexey Kardashevskiy return ret; 290833d4668SAlexey Kardashevskiy } 29153018216SPaolo Bonzini } 29253018216SPaolo Bonzini return ret; 29353018216SPaolo Bonzini } 29453018216SPaolo Bonzini 295b082d65aSAlexey Kardashevskiy static hwaddr spapr_node0_size(void) 296b082d65aSAlexey Kardashevskiy { 297fb164994SDavid Gibson MachineState *machine = MACHINE(qdev_get_machine()); 298fb164994SDavid Gibson 299b082d65aSAlexey Kardashevskiy if (nb_numa_nodes) { 300b082d65aSAlexey Kardashevskiy int i; 301b082d65aSAlexey Kardashevskiy for (i = 0; i < nb_numa_nodes; ++i) { 302b082d65aSAlexey Kardashevskiy if (numa_info[i].node_mem) { 303fb164994SDavid Gibson return MIN(pow2floor(numa_info[i].node_mem), 304fb164994SDavid Gibson machine->ram_size); 305b082d65aSAlexey Kardashevskiy } 306b082d65aSAlexey Kardashevskiy } 307b082d65aSAlexey Kardashevskiy } 308fb164994SDavid Gibson return machine->ram_size; 309b082d65aSAlexey Kardashevskiy } 310b082d65aSAlexey Kardashevskiy 311a1d59c0fSAlexey Kardashevskiy static void add_str(GString *s, const gchar *s1) 312a1d59c0fSAlexey Kardashevskiy { 313a1d59c0fSAlexey Kardashevskiy g_string_append_len(s, s1, strlen(s1) + 1); 314a1d59c0fSAlexey Kardashevskiy } 31553018216SPaolo Bonzini 31603d196b7SBharata B Rao static int spapr_populate_memory_node(void *fdt, int nodeid, hwaddr start, 31726a8c353SAlexey Kardashevskiy hwaddr size) 31826a8c353SAlexey Kardashevskiy { 31926a8c353SAlexey Kardashevskiy uint32_t associativity[] = { 32026a8c353SAlexey Kardashevskiy cpu_to_be32(0x4), /* length */ 32126a8c353SAlexey Kardashevskiy cpu_to_be32(0x0), cpu_to_be32(0x0), 322c3b4f589SAlexey Kardashevskiy cpu_to_be32(0x0), cpu_to_be32(nodeid) 32326a8c353SAlexey Kardashevskiy }; 32426a8c353SAlexey Kardashevskiy char mem_name[32]; 32526a8c353SAlexey Kardashevskiy uint64_t mem_reg_property[2]; 32626a8c353SAlexey Kardashevskiy int off; 32726a8c353SAlexey Kardashevskiy 32826a8c353SAlexey Kardashevskiy mem_reg_property[0] = cpu_to_be64(start); 32926a8c353SAlexey Kardashevskiy mem_reg_property[1] = cpu_to_be64(size); 33026a8c353SAlexey Kardashevskiy 33126a8c353SAlexey Kardashevskiy sprintf(mem_name, "memory@" TARGET_FMT_lx, start); 33226a8c353SAlexey Kardashevskiy off = fdt_add_subnode(fdt, 0, mem_name); 33326a8c353SAlexey Kardashevskiy _FDT(off); 33426a8c353SAlexey Kardashevskiy _FDT((fdt_setprop_string(fdt, off, "device_type", "memory"))); 33526a8c353SAlexey Kardashevskiy _FDT((fdt_setprop(fdt, off, "reg", mem_reg_property, 33626a8c353SAlexey Kardashevskiy sizeof(mem_reg_property)))); 33726a8c353SAlexey Kardashevskiy _FDT((fdt_setprop(fdt, off, "ibm,associativity", associativity, 33826a8c353SAlexey Kardashevskiy sizeof(associativity)))); 33903d196b7SBharata B Rao return off; 34026a8c353SAlexey Kardashevskiy } 34126a8c353SAlexey Kardashevskiy 34228e02042SDavid Gibson static int spapr_populate_memory(sPAPRMachineState *spapr, void *fdt) 34353018216SPaolo Bonzini { 344fb164994SDavid Gibson MachineState *machine = MACHINE(spapr); 3457db8a127SAlexey Kardashevskiy hwaddr mem_start, node_size; 3467db8a127SAlexey Kardashevskiy int i, nb_nodes = nb_numa_nodes; 3477db8a127SAlexey Kardashevskiy NodeInfo *nodes = numa_info; 3487db8a127SAlexey Kardashevskiy NodeInfo ramnode; 34953018216SPaolo Bonzini 3507db8a127SAlexey Kardashevskiy /* No NUMA nodes, assume there is just one node with whole RAM */ 3517db8a127SAlexey Kardashevskiy if (!nb_numa_nodes) { 3527db8a127SAlexey Kardashevskiy nb_nodes = 1; 353fb164994SDavid Gibson ramnode.node_mem = machine->ram_size; 3547db8a127SAlexey Kardashevskiy nodes = &ramnode; 3555fe269b1SPaul Mackerras } 35653018216SPaolo Bonzini 3577db8a127SAlexey Kardashevskiy for (i = 0, mem_start = 0; i < nb_nodes; ++i) { 3587db8a127SAlexey Kardashevskiy if (!nodes[i].node_mem) { 3597db8a127SAlexey Kardashevskiy continue; 36053018216SPaolo Bonzini } 361fb164994SDavid Gibson if (mem_start >= machine->ram_size) { 3625fe269b1SPaul Mackerras node_size = 0; 3635fe269b1SPaul Mackerras } else { 3647db8a127SAlexey Kardashevskiy node_size = nodes[i].node_mem; 365fb164994SDavid Gibson if (node_size > machine->ram_size - mem_start) { 366fb164994SDavid Gibson node_size = machine->ram_size - mem_start; 3675fe269b1SPaul Mackerras } 3685fe269b1SPaul Mackerras } 3697db8a127SAlexey Kardashevskiy if (!mem_start) { 3707db8a127SAlexey Kardashevskiy /* ppc_spapr_init() checks for rma_size <= node0_size already */ 371e8f986fcSBharata B Rao spapr_populate_memory_node(fdt, i, 0, spapr->rma_size); 3727db8a127SAlexey Kardashevskiy mem_start += spapr->rma_size; 3737db8a127SAlexey Kardashevskiy node_size -= spapr->rma_size; 3747db8a127SAlexey Kardashevskiy } 3756010818cSAlexey Kardashevskiy for ( ; node_size; ) { 3766010818cSAlexey Kardashevskiy hwaddr sizetmp = pow2floor(node_size); 3776010818cSAlexey Kardashevskiy 3786010818cSAlexey Kardashevskiy /* mem_start != 0 here */ 3796010818cSAlexey Kardashevskiy if (ctzl(mem_start) < ctzl(sizetmp)) { 3806010818cSAlexey Kardashevskiy sizetmp = 1ULL << ctzl(mem_start); 3816010818cSAlexey Kardashevskiy } 3826010818cSAlexey Kardashevskiy 3836010818cSAlexey Kardashevskiy spapr_populate_memory_node(fdt, i, mem_start, sizetmp); 3846010818cSAlexey Kardashevskiy node_size -= sizetmp; 3856010818cSAlexey Kardashevskiy mem_start += sizetmp; 3866010818cSAlexey Kardashevskiy } 38753018216SPaolo Bonzini } 38853018216SPaolo Bonzini 38953018216SPaolo Bonzini return 0; 39053018216SPaolo Bonzini } 39153018216SPaolo Bonzini 392230bf719SThomas Huth /* Populate the "ibm,pa-features" property */ 393230bf719SThomas Huth static void spapr_populate_pa_features(CPUPPCState *env, void *fdt, int offset) 394230bf719SThomas Huth { 395230bf719SThomas Huth uint8_t pa_features_206[] = { 6, 0, 396230bf719SThomas Huth 0xf6, 0x1f, 0xc7, 0x00, 0x80, 0xc0 }; 397230bf719SThomas Huth uint8_t pa_features_207[] = { 24, 0, 398230bf719SThomas Huth 0xf6, 0x1f, 0xc7, 0xc0, 0x80, 0xf0, 399230bf719SThomas Huth 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 400230bf719SThomas Huth 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 401bac3bf28SThomas Huth 0x80, 0x00, 0x80, 0x00, 0x00, 0x00 }; 402230bf719SThomas Huth uint8_t *pa_features; 403230bf719SThomas Huth size_t pa_size; 404230bf719SThomas Huth 4054cbec30dSThomas Huth switch (env->mmu_model) { 4064cbec30dSThomas Huth case POWERPC_MMU_2_06: 4074cbec30dSThomas Huth case POWERPC_MMU_2_06a: 408230bf719SThomas Huth pa_features = pa_features_206; 409230bf719SThomas Huth pa_size = sizeof(pa_features_206); 4104cbec30dSThomas Huth break; 4114cbec30dSThomas Huth case POWERPC_MMU_2_07: 4124cbec30dSThomas Huth case POWERPC_MMU_2_07a: 413230bf719SThomas Huth pa_features = pa_features_207; 414230bf719SThomas Huth pa_size = sizeof(pa_features_207); 4154cbec30dSThomas Huth break; 4164cbec30dSThomas Huth default: 4174cbec30dSThomas Huth return; 418230bf719SThomas Huth } 419230bf719SThomas Huth 420230bf719SThomas Huth if (env->ci_large_pages) { 421230bf719SThomas Huth /* 422230bf719SThomas Huth * Note: we keep CI large pages off by default because a 64K capable 423230bf719SThomas Huth * guest provisioned with large pages might otherwise try to map a qemu 424230bf719SThomas Huth * framebuffer (or other kind of memory mapped PCI BAR) using 64K pages 425230bf719SThomas Huth * even if that qemu runs on a 4k host. 426230bf719SThomas Huth * We dd this bit back here if we are confident this is not an issue 427230bf719SThomas Huth */ 428230bf719SThomas Huth pa_features[3] |= 0x20; 429230bf719SThomas Huth } 430bac3bf28SThomas Huth if (kvmppc_has_cap_htm() && pa_size > 24) { 431bac3bf28SThomas Huth pa_features[24] |= 0x80; /* Transactional memory support */ 432bac3bf28SThomas Huth } 433230bf719SThomas Huth 434230bf719SThomas Huth _FDT((fdt_setprop(fdt, offset, "ibm,pa-features", pa_features, pa_size))); 435230bf719SThomas Huth } 436230bf719SThomas Huth 4370da6f3feSBharata B Rao static void spapr_populate_cpu_dt(CPUState *cs, void *fdt, int offset, 4380da6f3feSBharata B Rao sPAPRMachineState *spapr) 4390da6f3feSBharata B Rao { 4400da6f3feSBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(cs); 4410da6f3feSBharata B Rao CPUPPCState *env = &cpu->env; 4420da6f3feSBharata B Rao PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(cs); 4430da6f3feSBharata B Rao int index = ppc_get_vcpu_dt_id(cpu); 4440da6f3feSBharata B Rao uint32_t segs[] = {cpu_to_be32(28), cpu_to_be32(40), 4450da6f3feSBharata B Rao 0xffffffff, 0xffffffff}; 446afd10a0fSBharata B Rao uint32_t tbfreq = kvm_enabled() ? kvmppc_get_tbfreq() 447afd10a0fSBharata B Rao : SPAPR_TIMEBASE_FREQ; 4480da6f3feSBharata B Rao uint32_t cpufreq = kvm_enabled() ? kvmppc_get_clockfreq() : 1000000000; 4490da6f3feSBharata B Rao uint32_t page_sizes_prop[64]; 4500da6f3feSBharata B Rao size_t page_sizes_prop_size; 45122419c2aSDavid Gibson uint32_t vcpus_per_socket = smp_threads * smp_cores; 4520da6f3feSBharata B Rao uint32_t pft_size_prop[] = {0, cpu_to_be32(spapr->htab_shift)}; 45312dbeb16SDavid Gibson int compat_smt = MIN(smp_threads, ppc_compat_max_threads(cpu)); 454af81cf32SBharata B Rao sPAPRDRConnector *drc; 455af81cf32SBharata B Rao sPAPRDRConnectorClass *drck; 456af81cf32SBharata B Rao int drc_index; 457af81cf32SBharata B Rao 458af81cf32SBharata B Rao drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_CPU, index); 459af81cf32SBharata B Rao if (drc) { 460af81cf32SBharata B Rao drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 461af81cf32SBharata B Rao drc_index = drck->get_index(drc); 462af81cf32SBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,my-drc-index", drc_index))); 463af81cf32SBharata B Rao } 4640da6f3feSBharata B Rao 4650da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "reg", index))); 4660da6f3feSBharata B Rao _FDT((fdt_setprop_string(fdt, offset, "device_type", "cpu"))); 4670da6f3feSBharata B Rao 4680da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "cpu-version", env->spr[SPR_PVR]))); 4690da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "d-cache-block-size", 4700da6f3feSBharata B Rao env->dcache_line_size))); 4710da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "d-cache-line-size", 4720da6f3feSBharata B Rao env->dcache_line_size))); 4730da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "i-cache-block-size", 4740da6f3feSBharata B Rao env->icache_line_size))); 4750da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "i-cache-line-size", 4760da6f3feSBharata B Rao env->icache_line_size))); 4770da6f3feSBharata B Rao 4780da6f3feSBharata B Rao if (pcc->l1_dcache_size) { 4790da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "d-cache-size", 4800da6f3feSBharata B Rao pcc->l1_dcache_size))); 4810da6f3feSBharata B Rao } else { 482ce9863b7SCédric Le Goater error_report("Warning: Unknown L1 dcache size for cpu"); 4830da6f3feSBharata B Rao } 4840da6f3feSBharata B Rao if (pcc->l1_icache_size) { 4850da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "i-cache-size", 4860da6f3feSBharata B Rao pcc->l1_icache_size))); 4870da6f3feSBharata B Rao } else { 488ce9863b7SCédric Le Goater error_report("Warning: Unknown L1 icache size for cpu"); 4890da6f3feSBharata B Rao } 4900da6f3feSBharata B Rao 4910da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "timebase-frequency", tbfreq))); 4920da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "clock-frequency", cpufreq))); 493fd5da5c4SThomas Huth _FDT((fdt_setprop_cell(fdt, offset, "slb-size", env->slb_nr))); 4940da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,slb-size", env->slb_nr))); 4950da6f3feSBharata B Rao _FDT((fdt_setprop_string(fdt, offset, "status", "okay"))); 4960da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "64-bit", NULL, 0))); 4970da6f3feSBharata B Rao 4980da6f3feSBharata B Rao if (env->spr_cb[SPR_PURR].oea_read) { 4990da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,purr", NULL, 0))); 5000da6f3feSBharata B Rao } 5010da6f3feSBharata B Rao 5020da6f3feSBharata B Rao if (env->mmu_model & POWERPC_MMU_1TSEG) { 5030da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,processor-segment-sizes", 5040da6f3feSBharata B Rao segs, sizeof(segs)))); 5050da6f3feSBharata B Rao } 5060da6f3feSBharata B Rao 5070da6f3feSBharata B Rao /* Advertise VMX/VSX (vector extensions) if available 5080da6f3feSBharata B Rao * 0 / no property == no vector extensions 5090da6f3feSBharata B Rao * 1 == VMX / Altivec available 5100da6f3feSBharata B Rao * 2 == VSX available */ 5110da6f3feSBharata B Rao if (env->insns_flags & PPC_ALTIVEC) { 5120da6f3feSBharata B Rao uint32_t vmx = (env->insns_flags2 & PPC2_VSX) ? 2 : 1; 5130da6f3feSBharata B Rao 5140da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,vmx", vmx))); 5150da6f3feSBharata B Rao } 5160da6f3feSBharata B Rao 5170da6f3feSBharata B Rao /* Advertise DFP (Decimal Floating Point) if available 5180da6f3feSBharata B Rao * 0 / no property == no DFP 5190da6f3feSBharata B Rao * 1 == DFP available */ 5200da6f3feSBharata B Rao if (env->insns_flags2 & PPC2_DFP) { 5210da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,dfp", 1))); 5220da6f3feSBharata B Rao } 5230da6f3feSBharata B Rao 5243654fa95SCédric Le Goater page_sizes_prop_size = ppc_create_page_sizes_prop(env, page_sizes_prop, 5250da6f3feSBharata B Rao sizeof(page_sizes_prop)); 5260da6f3feSBharata B Rao if (page_sizes_prop_size) { 5270da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,segment-page-sizes", 5280da6f3feSBharata B Rao page_sizes_prop, page_sizes_prop_size))); 5290da6f3feSBharata B Rao } 5300da6f3feSBharata B Rao 531230bf719SThomas Huth spapr_populate_pa_features(env, fdt, offset); 53290da0d5aSBenjamin Herrenschmidt 5330da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,chip-id", 53422419c2aSDavid Gibson cs->cpu_index / vcpus_per_socket))); 5350da6f3feSBharata B Rao 5360da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,pft-size", 5370da6f3feSBharata B Rao pft_size_prop, sizeof(pft_size_prop)))); 5380da6f3feSBharata B Rao 5390da6f3feSBharata B Rao _FDT(spapr_fixup_cpu_numa_dt(fdt, offset, cs)); 5400da6f3feSBharata B Rao 54112dbeb16SDavid Gibson _FDT(spapr_fixup_cpu_smt_dt(fdt, offset, cpu, compat_smt)); 5420da6f3feSBharata B Rao } 5430da6f3feSBharata B Rao 5440da6f3feSBharata B Rao static void spapr_populate_cpus_dt_node(void *fdt, sPAPRMachineState *spapr) 5450da6f3feSBharata B Rao { 5460da6f3feSBharata B Rao CPUState *cs; 5470da6f3feSBharata B Rao int cpus_offset; 5480da6f3feSBharata B Rao char *nodename; 5490da6f3feSBharata B Rao int smt = kvmppc_smt_threads(); 5500da6f3feSBharata B Rao 5510da6f3feSBharata B Rao cpus_offset = fdt_add_subnode(fdt, 0, "cpus"); 5520da6f3feSBharata B Rao _FDT(cpus_offset); 5530da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, cpus_offset, "#address-cells", 0x1))); 5540da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, cpus_offset, "#size-cells", 0x0))); 5550da6f3feSBharata B Rao 5560da6f3feSBharata B Rao /* 5570da6f3feSBharata B Rao * We walk the CPUs in reverse order to ensure that CPU DT nodes 5580da6f3feSBharata B Rao * created by fdt_add_subnode() end up in the right order in FDT 5590da6f3feSBharata B Rao * for the guest kernel the enumerate the CPUs correctly. 5600da6f3feSBharata B Rao */ 5610da6f3feSBharata B Rao CPU_FOREACH_REVERSE(cs) { 5620da6f3feSBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(cs); 5630da6f3feSBharata B Rao int index = ppc_get_vcpu_dt_id(cpu); 5640da6f3feSBharata B Rao DeviceClass *dc = DEVICE_GET_CLASS(cs); 5650da6f3feSBharata B Rao int offset; 5660da6f3feSBharata B Rao 5670da6f3feSBharata B Rao if ((index % smt) != 0) { 5680da6f3feSBharata B Rao continue; 5690da6f3feSBharata B Rao } 5700da6f3feSBharata B Rao 5710da6f3feSBharata B Rao nodename = g_strdup_printf("%s@%x", dc->fw_name, index); 5720da6f3feSBharata B Rao offset = fdt_add_subnode(fdt, cpus_offset, nodename); 5730da6f3feSBharata B Rao g_free(nodename); 5740da6f3feSBharata B Rao _FDT(offset); 5750da6f3feSBharata B Rao spapr_populate_cpu_dt(cs, fdt, offset, spapr); 5760da6f3feSBharata B Rao } 5770da6f3feSBharata B Rao 5780da6f3feSBharata B Rao } 5790da6f3feSBharata B Rao 58003d196b7SBharata B Rao /* 58103d196b7SBharata B Rao * Adds ibm,dynamic-reconfiguration-memory node. 58203d196b7SBharata B Rao * Refer to docs/specs/ppc-spapr-hotplug.txt for the documentation 58303d196b7SBharata B Rao * of this device tree node. 58403d196b7SBharata B Rao */ 58503d196b7SBharata B Rao static int spapr_populate_drconf_memory(sPAPRMachineState *spapr, void *fdt) 58603d196b7SBharata B Rao { 58703d196b7SBharata B Rao MachineState *machine = MACHINE(spapr); 58803d196b7SBharata B Rao int ret, i, offset; 58903d196b7SBharata B Rao uint64_t lmb_size = SPAPR_MEMORY_BLOCK_SIZE; 59003d196b7SBharata B Rao uint32_t prop_lmb_size[] = {0, cpu_to_be32(lmb_size)}; 591d0e5a8f2SBharata B Rao uint32_t hotplug_lmb_start = spapr->hotplug_memory.base / lmb_size; 592d0e5a8f2SBharata B Rao uint32_t nr_lmbs = (spapr->hotplug_memory.base + 593d0e5a8f2SBharata B Rao memory_region_size(&spapr->hotplug_memory.mr)) / 594d0e5a8f2SBharata B Rao lmb_size; 59503d196b7SBharata B Rao uint32_t *int_buf, *cur_index, buf_len; 5966663864eSBharata B Rao int nr_nodes = nb_numa_nodes ? nb_numa_nodes : 1; 59703d196b7SBharata B Rao 598ef001f06SThomas Huth /* 599d0e5a8f2SBharata B Rao * Don't create the node if there is no hotpluggable memory 60016c25aefSBharata B Rao */ 601d0e5a8f2SBharata B Rao if (machine->ram_size == machine->maxram_size) { 60216c25aefSBharata B Rao return 0; 60316c25aefSBharata B Rao } 60416c25aefSBharata B Rao 60516c25aefSBharata B Rao /* 606ef001f06SThomas Huth * Allocate enough buffer size to fit in ibm,dynamic-memory 607ef001f06SThomas Huth * or ibm,associativity-lookup-arrays 608ef001f06SThomas Huth */ 609ef001f06SThomas Huth buf_len = MAX(nr_lmbs * SPAPR_DR_LMB_LIST_ENTRY_SIZE + 1, nr_nodes * 4 + 2) 610ef001f06SThomas Huth * sizeof(uint32_t); 61103d196b7SBharata B Rao cur_index = int_buf = g_malloc0(buf_len); 61203d196b7SBharata B Rao 61303d196b7SBharata B Rao offset = fdt_add_subnode(fdt, 0, "ibm,dynamic-reconfiguration-memory"); 61403d196b7SBharata B Rao 61503d196b7SBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,lmb-size", prop_lmb_size, 61603d196b7SBharata B Rao sizeof(prop_lmb_size)); 61703d196b7SBharata B Rao if (ret < 0) { 61803d196b7SBharata B Rao goto out; 61903d196b7SBharata B Rao } 62003d196b7SBharata B Rao 62103d196b7SBharata B Rao ret = fdt_setprop_cell(fdt, offset, "ibm,memory-flags-mask", 0xff); 62203d196b7SBharata B Rao if (ret < 0) { 62303d196b7SBharata B Rao goto out; 62403d196b7SBharata B Rao } 62503d196b7SBharata B Rao 62603d196b7SBharata B Rao ret = fdt_setprop_cell(fdt, offset, "ibm,memory-preservation-time", 0x0); 62703d196b7SBharata B Rao if (ret < 0) { 62803d196b7SBharata B Rao goto out; 62903d196b7SBharata B Rao } 63003d196b7SBharata B Rao 63103d196b7SBharata B Rao /* ibm,dynamic-memory */ 63203d196b7SBharata B Rao int_buf[0] = cpu_to_be32(nr_lmbs); 63303d196b7SBharata B Rao cur_index++; 63403d196b7SBharata B Rao for (i = 0; i < nr_lmbs; i++) { 635d0e5a8f2SBharata B Rao uint64_t addr = i * lmb_size; 63603d196b7SBharata B Rao uint32_t *dynamic_memory = cur_index; 63703d196b7SBharata B Rao 638d0e5a8f2SBharata B Rao if (i >= hotplug_lmb_start) { 639d0e5a8f2SBharata B Rao sPAPRDRConnector *drc; 640d0e5a8f2SBharata B Rao sPAPRDRConnectorClass *drck; 641d0e5a8f2SBharata B Rao 642d0e5a8f2SBharata B Rao drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_LMB, i); 64303d196b7SBharata B Rao g_assert(drc); 64403d196b7SBharata B Rao drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 64503d196b7SBharata B Rao 64603d196b7SBharata B Rao dynamic_memory[0] = cpu_to_be32(addr >> 32); 64703d196b7SBharata B Rao dynamic_memory[1] = cpu_to_be32(addr & 0xffffffff); 64803d196b7SBharata B Rao dynamic_memory[2] = cpu_to_be32(drck->get_index(drc)); 64903d196b7SBharata B Rao dynamic_memory[3] = cpu_to_be32(0); /* reserved */ 65003d196b7SBharata B Rao dynamic_memory[4] = cpu_to_be32(numa_get_node(addr, NULL)); 651d0e5a8f2SBharata B Rao if (memory_region_present(get_system_memory(), addr)) { 65203d196b7SBharata B Rao dynamic_memory[5] = cpu_to_be32(SPAPR_LMB_FLAGS_ASSIGNED); 65303d196b7SBharata B Rao } else { 65403d196b7SBharata B Rao dynamic_memory[5] = cpu_to_be32(0); 65503d196b7SBharata B Rao } 656d0e5a8f2SBharata B Rao } else { 657d0e5a8f2SBharata B Rao /* 658d0e5a8f2SBharata B Rao * LMB information for RMA, boot time RAM and gap b/n RAM and 659d0e5a8f2SBharata B Rao * hotplug memory region -- all these are marked as reserved 660d0e5a8f2SBharata B Rao * and as having no valid DRC. 661d0e5a8f2SBharata B Rao */ 662d0e5a8f2SBharata B Rao dynamic_memory[0] = cpu_to_be32(addr >> 32); 663d0e5a8f2SBharata B Rao dynamic_memory[1] = cpu_to_be32(addr & 0xffffffff); 664d0e5a8f2SBharata B Rao dynamic_memory[2] = cpu_to_be32(0); 665d0e5a8f2SBharata B Rao dynamic_memory[3] = cpu_to_be32(0); /* reserved */ 666d0e5a8f2SBharata B Rao dynamic_memory[4] = cpu_to_be32(-1); 667d0e5a8f2SBharata B Rao dynamic_memory[5] = cpu_to_be32(SPAPR_LMB_FLAGS_RESERVED | 668d0e5a8f2SBharata B Rao SPAPR_LMB_FLAGS_DRC_INVALID); 669d0e5a8f2SBharata B Rao } 67003d196b7SBharata B Rao 67103d196b7SBharata B Rao cur_index += SPAPR_DR_LMB_LIST_ENTRY_SIZE; 67203d196b7SBharata B Rao } 67303d196b7SBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,dynamic-memory", int_buf, buf_len); 67403d196b7SBharata B Rao if (ret < 0) { 67503d196b7SBharata B Rao goto out; 67603d196b7SBharata B Rao } 67703d196b7SBharata B Rao 67803d196b7SBharata B Rao /* ibm,associativity-lookup-arrays */ 67903d196b7SBharata B Rao cur_index = int_buf; 6806663864eSBharata B Rao int_buf[0] = cpu_to_be32(nr_nodes); 68103d196b7SBharata B Rao int_buf[1] = cpu_to_be32(4); /* Number of entries per associativity list */ 68203d196b7SBharata B Rao cur_index += 2; 6836663864eSBharata B Rao for (i = 0; i < nr_nodes; i++) { 68403d196b7SBharata B Rao uint32_t associativity[] = { 68503d196b7SBharata B Rao cpu_to_be32(0x0), 68603d196b7SBharata B Rao cpu_to_be32(0x0), 68703d196b7SBharata B Rao cpu_to_be32(0x0), 68803d196b7SBharata B Rao cpu_to_be32(i) 68903d196b7SBharata B Rao }; 69003d196b7SBharata B Rao memcpy(cur_index, associativity, sizeof(associativity)); 69103d196b7SBharata B Rao cur_index += 4; 69203d196b7SBharata B Rao } 69303d196b7SBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,associativity-lookup-arrays", int_buf, 69403d196b7SBharata B Rao (cur_index - int_buf) * sizeof(uint32_t)); 69503d196b7SBharata B Rao out: 69603d196b7SBharata B Rao g_free(int_buf); 69703d196b7SBharata B Rao return ret; 69803d196b7SBharata B Rao } 69903d196b7SBharata B Rao 7006787d27bSMichael Roth static int spapr_dt_cas_updates(sPAPRMachineState *spapr, void *fdt, 7016787d27bSMichael Roth sPAPROptionVector *ov5_updates) 7026787d27bSMichael Roth { 7036787d27bSMichael Roth sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(spapr); 704417ece33SMichael Roth int ret = 0, offset; 7056787d27bSMichael Roth 7066787d27bSMichael Roth /* Generate ibm,dynamic-reconfiguration-memory node if required */ 7076787d27bSMichael Roth if (spapr_ovec_test(ov5_updates, OV5_DRCONF_MEMORY)) { 7086787d27bSMichael Roth g_assert(smc->dr_lmb_enabled); 7096787d27bSMichael Roth ret = spapr_populate_drconf_memory(spapr, fdt); 710417ece33SMichael Roth if (ret) { 711417ece33SMichael Roth goto out; 712417ece33SMichael Roth } 7136787d27bSMichael Roth } 7146787d27bSMichael Roth 715417ece33SMichael Roth offset = fdt_path_offset(fdt, "/chosen"); 716417ece33SMichael Roth if (offset < 0) { 717417ece33SMichael Roth offset = fdt_add_subnode(fdt, 0, "chosen"); 718417ece33SMichael Roth if (offset < 0) { 719417ece33SMichael Roth return offset; 720417ece33SMichael Roth } 721417ece33SMichael Roth } 722417ece33SMichael Roth ret = spapr_ovec_populate_dt(fdt, offset, spapr->ov5_cas, 723417ece33SMichael Roth "ibm,architecture-vec-5"); 724417ece33SMichael Roth 725417ece33SMichael Roth out: 7266787d27bSMichael Roth return ret; 7276787d27bSMichael Roth } 7286787d27bSMichael Roth 72903d196b7SBharata B Rao int spapr_h_cas_compose_response(sPAPRMachineState *spapr, 73003d196b7SBharata B Rao target_ulong addr, target_ulong size, 7316787d27bSMichael Roth sPAPROptionVector *ov5_updates) 73203d196b7SBharata B Rao { 73303d196b7SBharata B Rao void *fdt, *fdt_skel; 73403d196b7SBharata B Rao sPAPRDeviceTreeUpdateHeader hdr = { .version_id = 1 }; 73503d196b7SBharata B Rao 73603d196b7SBharata B Rao size -= sizeof(hdr); 73703d196b7SBharata B Rao 73803d196b7SBharata B Rao /* Create sceleton */ 73903d196b7SBharata B Rao fdt_skel = g_malloc0(size); 74003d196b7SBharata B Rao _FDT((fdt_create(fdt_skel, size))); 74103d196b7SBharata B Rao _FDT((fdt_begin_node(fdt_skel, ""))); 74203d196b7SBharata B Rao _FDT((fdt_end_node(fdt_skel))); 74303d196b7SBharata B Rao _FDT((fdt_finish(fdt_skel))); 74403d196b7SBharata B Rao fdt = g_malloc0(size); 74503d196b7SBharata B Rao _FDT((fdt_open_into(fdt_skel, fdt, size))); 74603d196b7SBharata B Rao g_free(fdt_skel); 74703d196b7SBharata B Rao 74803d196b7SBharata B Rao /* Fixup cpu nodes */ 74903d196b7SBharata B Rao _FDT((spapr_fixup_cpu_dt(fdt, spapr))); 75003d196b7SBharata B Rao 7516787d27bSMichael Roth if (spapr_dt_cas_updates(spapr, fdt, ov5_updates)) { 7526787d27bSMichael Roth return -1; 75303d196b7SBharata B Rao } 75403d196b7SBharata B Rao 75503d196b7SBharata B Rao /* Pack resulting tree */ 75603d196b7SBharata B Rao _FDT((fdt_pack(fdt))); 75703d196b7SBharata B Rao 75803d196b7SBharata B Rao if (fdt_totalsize(fdt) + sizeof(hdr) > size) { 75903d196b7SBharata B Rao trace_spapr_cas_failed(size); 76003d196b7SBharata B Rao return -1; 76103d196b7SBharata B Rao } 76203d196b7SBharata B Rao 76303d196b7SBharata B Rao cpu_physical_memory_write(addr, &hdr, sizeof(hdr)); 76403d196b7SBharata B Rao cpu_physical_memory_write(addr + sizeof(hdr), fdt, fdt_totalsize(fdt)); 76503d196b7SBharata B Rao trace_spapr_cas_continue(fdt_totalsize(fdt) + sizeof(hdr)); 76603d196b7SBharata B Rao g_free(fdt); 76703d196b7SBharata B Rao 76803d196b7SBharata B Rao return 0; 76903d196b7SBharata B Rao } 77003d196b7SBharata B Rao 7713f5dabceSDavid Gibson static void spapr_dt_rtas(sPAPRMachineState *spapr, void *fdt) 7723f5dabceSDavid Gibson { 7733f5dabceSDavid Gibson int rtas; 7743f5dabceSDavid Gibson GString *hypertas = g_string_sized_new(256); 7753f5dabceSDavid Gibson GString *qemu_hypertas = g_string_sized_new(256); 7763f5dabceSDavid Gibson uint32_t refpoints[] = { cpu_to_be32(0x4), cpu_to_be32(0x4) }; 7773f5dabceSDavid Gibson uint64_t max_hotplug_addr = spapr->hotplug_memory.base + 7783f5dabceSDavid Gibson memory_region_size(&spapr->hotplug_memory.mr); 7793f5dabceSDavid Gibson uint32_t lrdr_capacity[] = { 7803f5dabceSDavid Gibson cpu_to_be32(max_hotplug_addr >> 32), 7813f5dabceSDavid Gibson cpu_to_be32(max_hotplug_addr & 0xffffffff), 7823f5dabceSDavid Gibson 0, cpu_to_be32(SPAPR_MEMORY_BLOCK_SIZE), 7833f5dabceSDavid Gibson cpu_to_be32(max_cpus / smp_threads), 7843f5dabceSDavid Gibson }; 7853f5dabceSDavid Gibson 7863f5dabceSDavid Gibson _FDT(rtas = fdt_add_subnode(fdt, 0, "rtas")); 7873f5dabceSDavid Gibson 7883f5dabceSDavid Gibson /* hypertas */ 7893f5dabceSDavid Gibson add_str(hypertas, "hcall-pft"); 7903f5dabceSDavid Gibson add_str(hypertas, "hcall-term"); 7913f5dabceSDavid Gibson add_str(hypertas, "hcall-dabr"); 7923f5dabceSDavid Gibson add_str(hypertas, "hcall-interrupt"); 7933f5dabceSDavid Gibson add_str(hypertas, "hcall-tce"); 7943f5dabceSDavid Gibson add_str(hypertas, "hcall-vio"); 7953f5dabceSDavid Gibson add_str(hypertas, "hcall-splpar"); 7963f5dabceSDavid Gibson add_str(hypertas, "hcall-bulk"); 7973f5dabceSDavid Gibson add_str(hypertas, "hcall-set-mode"); 7983f5dabceSDavid Gibson add_str(hypertas, "hcall-sprg0"); 7993f5dabceSDavid Gibson add_str(hypertas, "hcall-copy"); 8003f5dabceSDavid Gibson add_str(hypertas, "hcall-debug"); 8013f5dabceSDavid Gibson add_str(qemu_hypertas, "hcall-memop1"); 8023f5dabceSDavid Gibson 8033f5dabceSDavid Gibson if (!kvm_enabled() || kvmppc_spapr_use_multitce()) { 8043f5dabceSDavid Gibson add_str(hypertas, "hcall-multi-tce"); 8053f5dabceSDavid Gibson } 8063f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,hypertas-functions", 8073f5dabceSDavid Gibson hypertas->str, hypertas->len)); 8083f5dabceSDavid Gibson g_string_free(hypertas, TRUE); 8093f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "qemu,hypertas-functions", 8103f5dabceSDavid Gibson qemu_hypertas->str, qemu_hypertas->len)); 8113f5dabceSDavid Gibson g_string_free(qemu_hypertas, TRUE); 8123f5dabceSDavid Gibson 8133f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,associativity-reference-points", 8143f5dabceSDavid Gibson refpoints, sizeof(refpoints))); 8153f5dabceSDavid Gibson 8163f5dabceSDavid Gibson _FDT(fdt_setprop_cell(fdt, rtas, "rtas-error-log-max", 8173f5dabceSDavid Gibson RTAS_ERROR_LOG_MAX)); 8183f5dabceSDavid Gibson _FDT(fdt_setprop_cell(fdt, rtas, "rtas-event-scan-rate", 8193f5dabceSDavid Gibson RTAS_EVENT_SCAN_RATE)); 8203f5dabceSDavid Gibson 8213f5dabceSDavid Gibson if (msi_nonbroken) { 8223f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,change-msix-capable", NULL, 0)); 8233f5dabceSDavid Gibson } 8243f5dabceSDavid Gibson 8253f5dabceSDavid Gibson /* 8263f5dabceSDavid Gibson * According to PAPR, rtas ibm,os-term does not guarantee a return 8273f5dabceSDavid Gibson * back to the guest cpu. 8283f5dabceSDavid Gibson * 8293f5dabceSDavid Gibson * While an additional ibm,extended-os-term property indicates 8303f5dabceSDavid Gibson * that rtas call return will always occur. Set this property. 8313f5dabceSDavid Gibson */ 8323f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,extended-os-term", NULL, 0)); 8333f5dabceSDavid Gibson 8343f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,lrdr-capacity", 8353f5dabceSDavid Gibson lrdr_capacity, sizeof(lrdr_capacity))); 8363f5dabceSDavid Gibson 8373f5dabceSDavid Gibson spapr_dt_rtas_tokens(fdt, rtas); 8383f5dabceSDavid Gibson } 8393f5dabceSDavid Gibson 8407c866c6aSDavid Gibson static void spapr_dt_chosen(sPAPRMachineState *spapr, void *fdt) 8417c866c6aSDavid Gibson { 8427c866c6aSDavid Gibson MachineState *machine = MACHINE(spapr); 8437c866c6aSDavid Gibson int chosen; 8447c866c6aSDavid Gibson const char *boot_device = machine->boot_order; 8457c866c6aSDavid Gibson char *stdout_path = spapr_vio_stdout_path(spapr->vio_bus); 8467c866c6aSDavid Gibson size_t cb = 0; 8477c866c6aSDavid Gibson char *bootlist = get_boot_devices_list(&cb, true); 8487c866c6aSDavid Gibson 8497c866c6aSDavid Gibson _FDT(chosen = fdt_add_subnode(fdt, 0, "chosen")); 8507c866c6aSDavid Gibson 8517c866c6aSDavid Gibson _FDT(fdt_setprop_string(fdt, chosen, "bootargs", machine->kernel_cmdline)); 8527c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "linux,initrd-start", 8537c866c6aSDavid Gibson spapr->initrd_base)); 8547c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "linux,initrd-end", 8557c866c6aSDavid Gibson spapr->initrd_base + spapr->initrd_size)); 8567c866c6aSDavid Gibson 8577c866c6aSDavid Gibson if (spapr->kernel_size) { 8587c866c6aSDavid Gibson uint64_t kprop[2] = { cpu_to_be64(KERNEL_LOAD_ADDR), 8597c866c6aSDavid Gibson cpu_to_be64(spapr->kernel_size) }; 8607c866c6aSDavid Gibson 8617c866c6aSDavid Gibson _FDT(fdt_setprop(fdt, chosen, "qemu,boot-kernel", 8627c866c6aSDavid Gibson &kprop, sizeof(kprop))); 8637c866c6aSDavid Gibson if (spapr->kernel_le) { 8647c866c6aSDavid Gibson _FDT(fdt_setprop(fdt, chosen, "qemu,boot-kernel-le", NULL, 0)); 8657c866c6aSDavid Gibson } 8667c866c6aSDavid Gibson } 8677c866c6aSDavid Gibson if (boot_menu) { 8687c866c6aSDavid Gibson _FDT((fdt_setprop_cell(fdt, chosen, "qemu,boot-menu", boot_menu))); 8697c866c6aSDavid Gibson } 8707c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "qemu,graphic-width", graphic_width)); 8717c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "qemu,graphic-height", graphic_height)); 8727c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "qemu,graphic-depth", graphic_depth)); 8737c866c6aSDavid Gibson 8747c866c6aSDavid Gibson if (cb && bootlist) { 8757c866c6aSDavid Gibson int i; 8767c866c6aSDavid Gibson 8777c866c6aSDavid Gibson for (i = 0; i < cb; i++) { 8787c866c6aSDavid Gibson if (bootlist[i] == '\n') { 8797c866c6aSDavid Gibson bootlist[i] = ' '; 8807c866c6aSDavid Gibson } 8817c866c6aSDavid Gibson } 8827c866c6aSDavid Gibson _FDT(fdt_setprop_string(fdt, chosen, "qemu,boot-list", bootlist)); 8837c866c6aSDavid Gibson } 8847c866c6aSDavid Gibson 8857c866c6aSDavid Gibson if (boot_device && strlen(boot_device)) { 8867c866c6aSDavid Gibson _FDT(fdt_setprop_string(fdt, chosen, "qemu,boot-device", boot_device)); 8877c866c6aSDavid Gibson } 8887c866c6aSDavid Gibson 8897c866c6aSDavid Gibson if (!spapr->has_graphics && stdout_path) { 8907c866c6aSDavid Gibson _FDT(fdt_setprop_string(fdt, chosen, "linux,stdout-path", stdout_path)); 8917c866c6aSDavid Gibson } 8927c866c6aSDavid Gibson 8937c866c6aSDavid Gibson g_free(stdout_path); 8947c866c6aSDavid Gibson g_free(bootlist); 8957c866c6aSDavid Gibson } 8967c866c6aSDavid Gibson 897fca5f2dcSDavid Gibson static void spapr_dt_hypervisor(sPAPRMachineState *spapr, void *fdt) 898fca5f2dcSDavid Gibson { 899fca5f2dcSDavid Gibson /* The /hypervisor node isn't in PAPR - this is a hack to allow PR 900fca5f2dcSDavid Gibson * KVM to work under pHyp with some guest co-operation */ 901fca5f2dcSDavid Gibson int hypervisor; 902fca5f2dcSDavid Gibson uint8_t hypercall[16]; 903fca5f2dcSDavid Gibson 904fca5f2dcSDavid Gibson _FDT(hypervisor = fdt_add_subnode(fdt, 0, "hypervisor")); 905fca5f2dcSDavid Gibson /* indicate KVM hypercall interface */ 906fca5f2dcSDavid Gibson _FDT(fdt_setprop_string(fdt, hypervisor, "compatible", "linux,kvm")); 907fca5f2dcSDavid Gibson if (kvmppc_has_cap_fixup_hcalls()) { 908fca5f2dcSDavid Gibson /* 909fca5f2dcSDavid Gibson * Older KVM versions with older guest kernels were broken 910fca5f2dcSDavid Gibson * with the magic page, don't allow the guest to map it. 911fca5f2dcSDavid Gibson */ 912fca5f2dcSDavid Gibson if (!kvmppc_get_hypercall(first_cpu->env_ptr, hypercall, 913fca5f2dcSDavid Gibson sizeof(hypercall))) { 914fca5f2dcSDavid Gibson _FDT(fdt_setprop(fdt, hypervisor, "hcall-instructions", 915fca5f2dcSDavid Gibson hypercall, sizeof(hypercall))); 916fca5f2dcSDavid Gibson } 917fca5f2dcSDavid Gibson } 918fca5f2dcSDavid Gibson } 919fca5f2dcSDavid Gibson 920997b6cfcSDavid Gibson static void *spapr_build_fdt(sPAPRMachineState *spapr, 92153018216SPaolo Bonzini hwaddr rtas_addr, 92253018216SPaolo Bonzini hwaddr rtas_size) 92353018216SPaolo Bonzini { 9245b2128d2SAlexander Graf MachineState *machine = MACHINE(qdev_get_machine()); 9253c0c47e3SDavid Gibson MachineClass *mc = MACHINE_GET_CLASS(machine); 926c20d332aSBharata B Rao sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(machine); 9277c866c6aSDavid Gibson int ret; 92853018216SPaolo Bonzini void *fdt; 92953018216SPaolo Bonzini sPAPRPHBState *phb; 930398a0bd5SDavid Gibson char *buf; 93153018216SPaolo Bonzini 932398a0bd5SDavid Gibson fdt = g_malloc0(FDT_MAX_SIZE); 933398a0bd5SDavid Gibson _FDT((fdt_create_empty_tree(fdt, FDT_MAX_SIZE))); 93453018216SPaolo Bonzini 935398a0bd5SDavid Gibson /* Root node */ 936398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "device_type", "chrp")); 937398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "model", "IBM pSeries (emulated by qemu)")); 938398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "compatible", "qemu,pseries")); 939398a0bd5SDavid Gibson 940398a0bd5SDavid Gibson /* 941398a0bd5SDavid Gibson * Add info to guest to indentify which host is it being run on 942398a0bd5SDavid Gibson * and what is the uuid of the guest 943398a0bd5SDavid Gibson */ 944398a0bd5SDavid Gibson if (kvmppc_get_host_model(&buf)) { 945398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "host-model", buf)); 946398a0bd5SDavid Gibson g_free(buf); 947398a0bd5SDavid Gibson } 948398a0bd5SDavid Gibson if (kvmppc_get_host_serial(&buf)) { 949398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "host-serial", buf)); 950398a0bd5SDavid Gibson g_free(buf); 951398a0bd5SDavid Gibson } 952398a0bd5SDavid Gibson 953398a0bd5SDavid Gibson buf = qemu_uuid_unparse_strdup(&qemu_uuid); 954398a0bd5SDavid Gibson 955398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "vm,uuid", buf)); 956398a0bd5SDavid Gibson if (qemu_uuid_set) { 957398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "system-id", buf)); 958398a0bd5SDavid Gibson } 959398a0bd5SDavid Gibson g_free(buf); 960398a0bd5SDavid Gibson 961398a0bd5SDavid Gibson if (qemu_get_vm_name()) { 962398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "ibm,partition-name", 963398a0bd5SDavid Gibson qemu_get_vm_name())); 964398a0bd5SDavid Gibson } 965398a0bd5SDavid Gibson 966398a0bd5SDavid Gibson _FDT(fdt_setprop_cell(fdt, 0, "#address-cells", 2)); 967398a0bd5SDavid Gibson _FDT(fdt_setprop_cell(fdt, 0, "#size-cells", 2)); 96853018216SPaolo Bonzini 9699b9a1908SDavid Gibson /* /interrupt controller */ 9709b9a1908SDavid Gibson spapr_dt_xics(spapr->xics, fdt, PHANDLE_XICP); 9719b9a1908SDavid Gibson 972e8f986fcSBharata B Rao ret = spapr_populate_memory(spapr, fdt); 973e8f986fcSBharata B Rao if (ret < 0) { 974ce9863b7SCédric Le Goater error_report("couldn't setup memory nodes in fdt"); 975e8f986fcSBharata B Rao exit(1); 97653018216SPaolo Bonzini } 97753018216SPaolo Bonzini 978bf5a6696SDavid Gibson /* /vdevice */ 979bf5a6696SDavid Gibson spapr_dt_vdevice(spapr->vio_bus, fdt); 98053018216SPaolo Bonzini 9814d9392beSThomas Huth if (object_resolve_path_type("", TYPE_SPAPR_RNG, NULL)) { 9824d9392beSThomas Huth ret = spapr_rng_populate_dt(fdt); 9834d9392beSThomas Huth if (ret < 0) { 984ce9863b7SCédric Le Goater error_report("could not set up rng device in the fdt"); 9854d9392beSThomas Huth exit(1); 9864d9392beSThomas Huth } 9874d9392beSThomas Huth } 9884d9392beSThomas Huth 98953018216SPaolo Bonzini QLIST_FOREACH(phb, &spapr->phbs, list) { 99053018216SPaolo Bonzini ret = spapr_populate_pci_dt(phb, PHANDLE_XICP, fdt); 99153018216SPaolo Bonzini if (ret < 0) { 992da34fed7SThomas Huth error_report("couldn't setup PCI devices in fdt"); 99353018216SPaolo Bonzini exit(1); 99453018216SPaolo Bonzini } 995da34fed7SThomas Huth } 99653018216SPaolo Bonzini 9970da6f3feSBharata B Rao /* cpus */ 9980da6f3feSBharata B Rao spapr_populate_cpus_dt_node(fdt, spapr); 99953018216SPaolo Bonzini 1000c20d332aSBharata B Rao if (smc->dr_lmb_enabled) { 1001c20d332aSBharata B Rao _FDT(spapr_drc_populate_dt(fdt, 0, NULL, SPAPR_DR_CONNECTOR_TYPE_LMB)); 1002c20d332aSBharata B Rao } 1003c20d332aSBharata B Rao 1004c5514d0eSIgor Mammedov if (mc->has_hotpluggable_cpus) { 1005af81cf32SBharata B Rao int offset = fdt_path_offset(fdt, "/cpus"); 1006af81cf32SBharata B Rao ret = spapr_drc_populate_dt(fdt, offset, NULL, 1007af81cf32SBharata B Rao SPAPR_DR_CONNECTOR_TYPE_CPU); 1008af81cf32SBharata B Rao if (ret < 0) { 1009af81cf32SBharata B Rao error_report("Couldn't set up CPU DR device tree properties"); 1010af81cf32SBharata B Rao exit(1); 1011af81cf32SBharata B Rao } 1012af81cf32SBharata B Rao } 1013af81cf32SBharata B Rao 1014ffb1e275SDavid Gibson /* /event-sources */ 1015ffbb1705SMichael Roth spapr_dt_events(spapr, fdt); 1016ffb1e275SDavid Gibson 10173f5dabceSDavid Gibson /* /rtas */ 10183f5dabceSDavid Gibson spapr_dt_rtas(spapr, fdt); 10193f5dabceSDavid Gibson 10207c866c6aSDavid Gibson /* /chosen */ 10217c866c6aSDavid Gibson spapr_dt_chosen(spapr, fdt); 1022cf6e5223SDavid Gibson 1023fca5f2dcSDavid Gibson /* /hypervisor */ 1024fca5f2dcSDavid Gibson if (kvm_enabled()) { 1025fca5f2dcSDavid Gibson spapr_dt_hypervisor(spapr, fdt); 1026fca5f2dcSDavid Gibson } 1027fca5f2dcSDavid Gibson 1028cf6e5223SDavid Gibson /* Build memory reserve map */ 1029cf6e5223SDavid Gibson if (spapr->kernel_size) { 1030cf6e5223SDavid Gibson _FDT((fdt_add_mem_rsv(fdt, KERNEL_LOAD_ADDR, spapr->kernel_size))); 1031cf6e5223SDavid Gibson } 1032cf6e5223SDavid Gibson if (spapr->initrd_size) { 1033cf6e5223SDavid Gibson _FDT((fdt_add_mem_rsv(fdt, spapr->initrd_base, spapr->initrd_size))); 1034cf6e5223SDavid Gibson } 1035cf6e5223SDavid Gibson 10366787d27bSMichael Roth /* ibm,client-architecture-support updates */ 10376787d27bSMichael Roth ret = spapr_dt_cas_updates(spapr, fdt, spapr->ov5_cas); 10386787d27bSMichael Roth if (ret < 0) { 10396787d27bSMichael Roth error_report("couldn't setup CAS properties fdt"); 10406787d27bSMichael Roth exit(1); 10416787d27bSMichael Roth } 10426787d27bSMichael Roth 1043997b6cfcSDavid Gibson return fdt; 104453018216SPaolo Bonzini } 104553018216SPaolo Bonzini 104653018216SPaolo Bonzini static uint64_t translate_kernel_address(void *opaque, uint64_t addr) 104753018216SPaolo Bonzini { 104853018216SPaolo Bonzini return (addr & 0x0fffffff) + KERNEL_LOAD_ADDR; 104953018216SPaolo Bonzini } 105053018216SPaolo Bonzini 10511d1be34dSDavid Gibson static void emulate_spapr_hypercall(PPCVirtualHypervisor *vhyp, 10521d1be34dSDavid Gibson PowerPCCPU *cpu) 105353018216SPaolo Bonzini { 105453018216SPaolo Bonzini CPUPPCState *env = &cpu->env; 105553018216SPaolo Bonzini 10568d04fb55SJan Kiszka /* The TCG path should also be holding the BQL at this point */ 10578d04fb55SJan Kiszka g_assert(qemu_mutex_iothread_locked()); 10588d04fb55SJan Kiszka 105953018216SPaolo Bonzini if (msr_pr) { 106053018216SPaolo Bonzini hcall_dprintf("Hypercall made with MSR[PR]=1\n"); 106153018216SPaolo Bonzini env->gpr[3] = H_PRIVILEGE; 106253018216SPaolo Bonzini } else { 106353018216SPaolo Bonzini env->gpr[3] = spapr_hypercall(cpu, env->gpr[3], &env->gpr[4]); 106453018216SPaolo Bonzini } 106553018216SPaolo Bonzini } 106653018216SPaolo Bonzini 1067e6b8fd24SSamuel Mendoza-Jonas #define HPTE(_table, _i) (void *)(((uint64_t *)(_table)) + ((_i) * 2)) 1068e6b8fd24SSamuel Mendoza-Jonas #define HPTE_VALID(_hpte) (tswap64(*((uint64_t *)(_hpte))) & HPTE64_V_VALID) 1069e6b8fd24SSamuel Mendoza-Jonas #define HPTE_DIRTY(_hpte) (tswap64(*((uint64_t *)(_hpte))) & HPTE64_V_HPTE_DIRTY) 1070e6b8fd24SSamuel Mendoza-Jonas #define CLEAN_HPTE(_hpte) ((*(uint64_t *)(_hpte)) &= tswap64(~HPTE64_V_HPTE_DIRTY)) 1071e6b8fd24SSamuel Mendoza-Jonas #define DIRTY_HPTE(_hpte) ((*(uint64_t *)(_hpte)) |= tswap64(HPTE64_V_HPTE_DIRTY)) 1072e6b8fd24SSamuel Mendoza-Jonas 1073715c5407SDavid Gibson /* 1074715c5407SDavid Gibson * Get the fd to access the kernel htab, re-opening it if necessary 1075715c5407SDavid Gibson */ 1076715c5407SDavid Gibson static int get_htab_fd(sPAPRMachineState *spapr) 1077715c5407SDavid Gibson { 1078715c5407SDavid Gibson if (spapr->htab_fd >= 0) { 1079715c5407SDavid Gibson return spapr->htab_fd; 1080715c5407SDavid Gibson } 1081715c5407SDavid Gibson 1082715c5407SDavid Gibson spapr->htab_fd = kvmppc_get_htab_fd(false); 1083715c5407SDavid Gibson if (spapr->htab_fd < 0) { 1084715c5407SDavid Gibson error_report("Unable to open fd for reading hash table from KVM: %s", 1085715c5407SDavid Gibson strerror(errno)); 1086715c5407SDavid Gibson } 1087715c5407SDavid Gibson 1088715c5407SDavid Gibson return spapr->htab_fd; 1089715c5407SDavid Gibson } 1090715c5407SDavid Gibson 1091715c5407SDavid Gibson static void close_htab_fd(sPAPRMachineState *spapr) 1092715c5407SDavid Gibson { 1093715c5407SDavid Gibson if (spapr->htab_fd >= 0) { 1094715c5407SDavid Gibson close(spapr->htab_fd); 1095715c5407SDavid Gibson } 1096715c5407SDavid Gibson spapr->htab_fd = -1; 1097715c5407SDavid Gibson } 1098715c5407SDavid Gibson 1099e57ca75cSDavid Gibson static hwaddr spapr_hpt_mask(PPCVirtualHypervisor *vhyp) 1100e57ca75cSDavid Gibson { 1101e57ca75cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 1102e57ca75cSDavid Gibson 1103e57ca75cSDavid Gibson return HTAB_SIZE(spapr) / HASH_PTEG_SIZE_64 - 1; 1104e57ca75cSDavid Gibson } 1105e57ca75cSDavid Gibson 1106e57ca75cSDavid Gibson static const ppc_hash_pte64_t *spapr_map_hptes(PPCVirtualHypervisor *vhyp, 1107e57ca75cSDavid Gibson hwaddr ptex, int n) 1108e57ca75cSDavid Gibson { 1109e57ca75cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 1110e57ca75cSDavid Gibson hwaddr pte_offset = ptex * HASH_PTE_SIZE_64; 1111e57ca75cSDavid Gibson 1112e57ca75cSDavid Gibson if (!spapr->htab) { 1113e57ca75cSDavid Gibson /* 1114e57ca75cSDavid Gibson * HTAB is controlled by KVM. Fetch into temporary buffer 1115e57ca75cSDavid Gibson */ 1116e57ca75cSDavid Gibson ppc_hash_pte64_t *hptes = g_malloc(n * HASH_PTE_SIZE_64); 1117e57ca75cSDavid Gibson kvmppc_read_hptes(hptes, ptex, n); 1118e57ca75cSDavid Gibson return hptes; 1119e57ca75cSDavid Gibson } 1120e57ca75cSDavid Gibson 1121e57ca75cSDavid Gibson /* 1122e57ca75cSDavid Gibson * HTAB is controlled by QEMU. Just point to the internally 1123e57ca75cSDavid Gibson * accessible PTEG. 1124e57ca75cSDavid Gibson */ 1125e57ca75cSDavid Gibson return (const ppc_hash_pte64_t *)(spapr->htab + pte_offset); 1126e57ca75cSDavid Gibson } 1127e57ca75cSDavid Gibson 1128e57ca75cSDavid Gibson static void spapr_unmap_hptes(PPCVirtualHypervisor *vhyp, 1129e57ca75cSDavid Gibson const ppc_hash_pte64_t *hptes, 1130e57ca75cSDavid Gibson hwaddr ptex, int n) 1131e57ca75cSDavid Gibson { 1132e57ca75cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 1133e57ca75cSDavid Gibson 1134e57ca75cSDavid Gibson if (!spapr->htab) { 1135e57ca75cSDavid Gibson g_free((void *)hptes); 1136e57ca75cSDavid Gibson } 1137e57ca75cSDavid Gibson 1138e57ca75cSDavid Gibson /* Nothing to do for qemu managed HPT */ 1139e57ca75cSDavid Gibson } 1140e57ca75cSDavid Gibson 1141e57ca75cSDavid Gibson static void spapr_store_hpte(PPCVirtualHypervisor *vhyp, hwaddr ptex, 1142e57ca75cSDavid Gibson uint64_t pte0, uint64_t pte1) 1143e57ca75cSDavid Gibson { 1144e57ca75cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 1145e57ca75cSDavid Gibson hwaddr offset = ptex * HASH_PTE_SIZE_64; 1146e57ca75cSDavid Gibson 1147e57ca75cSDavid Gibson if (!spapr->htab) { 1148e57ca75cSDavid Gibson kvmppc_write_hpte(ptex, pte0, pte1); 1149e57ca75cSDavid Gibson } else { 1150e57ca75cSDavid Gibson stq_p(spapr->htab + offset, pte0); 1151e57ca75cSDavid Gibson stq_p(spapr->htab + offset + HASH_PTE_SIZE_64 / 2, pte1); 1152e57ca75cSDavid Gibson } 1153e57ca75cSDavid Gibson } 1154e57ca75cSDavid Gibson 11558dfe8e7fSDavid Gibson static int spapr_hpt_shift_for_ramsize(uint64_t ramsize) 11568dfe8e7fSDavid Gibson { 11578dfe8e7fSDavid Gibson int shift; 11588dfe8e7fSDavid Gibson 11598dfe8e7fSDavid Gibson /* We aim for a hash table of size 1/128 the size of RAM (rounded 11608dfe8e7fSDavid Gibson * up). The PAPR recommendation is actually 1/64 of RAM size, but 11618dfe8e7fSDavid Gibson * that's much more than is needed for Linux guests */ 11628dfe8e7fSDavid Gibson shift = ctz64(pow2ceil(ramsize)) - 7; 11638dfe8e7fSDavid Gibson shift = MAX(shift, 18); /* Minimum architected size */ 11648dfe8e7fSDavid Gibson shift = MIN(shift, 46); /* Maximum architected size */ 11658dfe8e7fSDavid Gibson return shift; 11668dfe8e7fSDavid Gibson } 11678dfe8e7fSDavid Gibson 1168c5f54f3eSDavid Gibson static void spapr_reallocate_hpt(sPAPRMachineState *spapr, int shift, 1169c5f54f3eSDavid Gibson Error **errp) 117053018216SPaolo Bonzini { 1171c5f54f3eSDavid Gibson long rc; 117253018216SPaolo Bonzini 1173c5f54f3eSDavid Gibson /* Clean up any HPT info from a previous boot */ 1174c5f54f3eSDavid Gibson g_free(spapr->htab); 1175c5f54f3eSDavid Gibson spapr->htab = NULL; 1176c5f54f3eSDavid Gibson spapr->htab_shift = 0; 1177c5f54f3eSDavid Gibson close_htab_fd(spapr); 117853018216SPaolo Bonzini 1179c5f54f3eSDavid Gibson rc = kvmppc_reset_htab(shift); 1180c5f54f3eSDavid Gibson if (rc < 0) { 1181c5f54f3eSDavid Gibson /* kernel-side HPT needed, but couldn't allocate one */ 1182c5f54f3eSDavid Gibson error_setg_errno(errp, errno, 1183c5f54f3eSDavid Gibson "Failed to allocate KVM HPT of order %d (try smaller maxmem?)", 1184c5f54f3eSDavid Gibson shift); 1185c5f54f3eSDavid Gibson /* This is almost certainly fatal, but if the caller really 1186c5f54f3eSDavid Gibson * wants to carry on with shift == 0, it's welcome to try */ 1187c5f54f3eSDavid Gibson } else if (rc > 0) { 1188c5f54f3eSDavid Gibson /* kernel-side HPT allocated */ 1189c5f54f3eSDavid Gibson if (rc != shift) { 1190c5f54f3eSDavid Gibson error_setg(errp, 1191c5f54f3eSDavid Gibson "Requested order %d HPT, but kernel allocated order %ld (try smaller maxmem?)", 1192c5f54f3eSDavid Gibson shift, rc); 11937735fedaSBharata B Rao } 11947735fedaSBharata B Rao 119553018216SPaolo Bonzini spapr->htab_shift = shift; 1196c18ad9a5SDavid Gibson spapr->htab = NULL; 1197b817772aSBharata B Rao } else { 1198c5f54f3eSDavid Gibson /* kernel-side HPT not needed, allocate in userspace instead */ 1199c5f54f3eSDavid Gibson size_t size = 1ULL << shift; 1200c5f54f3eSDavid Gibson int i; 120101a57972SSamuel Mendoza-Jonas 1202c5f54f3eSDavid Gibson spapr->htab = qemu_memalign(size, size); 1203c5f54f3eSDavid Gibson if (!spapr->htab) { 1204c5f54f3eSDavid Gibson error_setg_errno(errp, errno, 1205c5f54f3eSDavid Gibson "Could not allocate HPT of order %d", shift); 1206c5f54f3eSDavid Gibson return; 1207b817772aSBharata B Rao } 1208b817772aSBharata B Rao 1209c5f54f3eSDavid Gibson memset(spapr->htab, 0, size); 1210c5f54f3eSDavid Gibson spapr->htab_shift = shift; 1211b817772aSBharata B Rao 1212c5f54f3eSDavid Gibson for (i = 0; i < size / HASH_PTE_SIZE_64; i++) { 1213c5f54f3eSDavid Gibson DIRTY_HPTE(HPTE(spapr->htab, i)); 12147735fedaSBharata B Rao } 121553018216SPaolo Bonzini } 121653018216SPaolo Bonzini } 121753018216SPaolo Bonzini 12184f01a637SDavid Gibson static void find_unknown_sysbus_device(SysBusDevice *sbdev, void *opaque) 12199e3f9733SAlexander Graf { 12209e3f9733SAlexander Graf bool matched = false; 12219e3f9733SAlexander Graf 12229e3f9733SAlexander Graf if (object_dynamic_cast(OBJECT(sbdev), TYPE_SPAPR_PCI_HOST_BRIDGE)) { 12239e3f9733SAlexander Graf matched = true; 12249e3f9733SAlexander Graf } 12259e3f9733SAlexander Graf 12269e3f9733SAlexander Graf if (!matched) { 12279e3f9733SAlexander Graf error_report("Device %s is not supported by this machine yet.", 12289e3f9733SAlexander Graf qdev_fw_name(DEVICE(sbdev))); 12299e3f9733SAlexander Graf exit(1); 12309e3f9733SAlexander Graf } 12319e3f9733SAlexander Graf } 12329e3f9733SAlexander Graf 123353018216SPaolo Bonzini static void ppc_spapr_reset(void) 123453018216SPaolo Bonzini { 1235c5f54f3eSDavid Gibson MachineState *machine = MACHINE(qdev_get_machine()); 1236c5f54f3eSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(machine); 1237182735efSAndreas Färber PowerPCCPU *first_ppc_cpu; 1238b7d1f77aSBenjamin Herrenschmidt uint32_t rtas_limit; 1239cae172abSDavid Gibson hwaddr rtas_addr, fdt_addr; 1240997b6cfcSDavid Gibson void *fdt; 1241997b6cfcSDavid Gibson int rc; 1242259186a7SAndreas Färber 12439e3f9733SAlexander Graf /* Check for unknown sysbus devices */ 12449e3f9733SAlexander Graf foreach_dynamic_sysbus_device(find_unknown_sysbus_device, NULL); 12459e3f9733SAlexander Graf 1246c5f54f3eSDavid Gibson /* Allocate and/or reset the hash page table */ 1247c5f54f3eSDavid Gibson spapr_reallocate_hpt(spapr, 1248c5f54f3eSDavid Gibson spapr_hpt_shift_for_ramsize(machine->maxram_size), 1249c5f54f3eSDavid Gibson &error_fatal); 1250c5f54f3eSDavid Gibson 1251c5f54f3eSDavid Gibson /* Update the RMA size if necessary */ 1252c5f54f3eSDavid Gibson if (spapr->vrma_adjust) { 1253c5f54f3eSDavid Gibson spapr->rma_size = kvmppc_rma_size(spapr_node0_size(), 1254c5f54f3eSDavid Gibson spapr->htab_shift); 1255c5f54f3eSDavid Gibson } 125653018216SPaolo Bonzini 125753018216SPaolo Bonzini qemu_devices_reset(); 125853018216SPaolo Bonzini 1259b7d1f77aSBenjamin Herrenschmidt /* 1260b7d1f77aSBenjamin Herrenschmidt * We place the device tree and RTAS just below either the top of the RMA, 1261b7d1f77aSBenjamin Herrenschmidt * or just below 2GB, whichever is lowere, so that it can be 1262b7d1f77aSBenjamin Herrenschmidt * processed with 32-bit real mode code if necessary 1263b7d1f77aSBenjamin Herrenschmidt */ 1264b7d1f77aSBenjamin Herrenschmidt rtas_limit = MIN(spapr->rma_size, RTAS_MAX_ADDR); 1265cae172abSDavid Gibson rtas_addr = rtas_limit - RTAS_MAX_SIZE; 1266cae172abSDavid Gibson fdt_addr = rtas_addr - FDT_MAX_SIZE; 1267b7d1f77aSBenjamin Herrenschmidt 12686787d27bSMichael Roth /* if this reset wasn't generated by CAS, we should reset our 12696787d27bSMichael Roth * negotiated options and start from scratch */ 12706787d27bSMichael Roth if (!spapr->cas_reboot) { 12716787d27bSMichael Roth spapr_ovec_cleanup(spapr->ov5_cas); 12726787d27bSMichael Roth spapr->ov5_cas = spapr_ovec_new(); 12736787d27bSMichael Roth } 12746787d27bSMichael Roth 1275cae172abSDavid Gibson fdt = spapr_build_fdt(spapr, rtas_addr, spapr->rtas_size); 127653018216SPaolo Bonzini 12772cac78c1SDavid Gibson spapr_load_rtas(spapr, fdt, rtas_addr); 1278b7d1f77aSBenjamin Herrenschmidt 1279997b6cfcSDavid Gibson rc = fdt_pack(fdt); 1280997b6cfcSDavid Gibson 1281997b6cfcSDavid Gibson /* Should only fail if we've built a corrupted tree */ 1282997b6cfcSDavid Gibson assert(rc == 0); 1283997b6cfcSDavid Gibson 1284997b6cfcSDavid Gibson if (fdt_totalsize(fdt) > FDT_MAX_SIZE) { 1285997b6cfcSDavid Gibson error_report("FDT too big ! 0x%x bytes (max is 0x%x)", 1286997b6cfcSDavid Gibson fdt_totalsize(fdt), FDT_MAX_SIZE); 1287997b6cfcSDavid Gibson exit(1); 1288997b6cfcSDavid Gibson } 1289997b6cfcSDavid Gibson 1290997b6cfcSDavid Gibson /* Load the fdt */ 1291997b6cfcSDavid Gibson qemu_fdt_dumpdtb(fdt, fdt_totalsize(fdt)); 1292cae172abSDavid Gibson cpu_physical_memory_write(fdt_addr, fdt, fdt_totalsize(fdt)); 1293997b6cfcSDavid Gibson g_free(fdt); 1294997b6cfcSDavid Gibson 129553018216SPaolo Bonzini /* Set up the entry state */ 1296182735efSAndreas Färber first_ppc_cpu = POWERPC_CPU(first_cpu); 1297cae172abSDavid Gibson first_ppc_cpu->env.gpr[3] = fdt_addr; 1298182735efSAndreas Färber first_ppc_cpu->env.gpr[5] = 0; 1299182735efSAndreas Färber first_cpu->halted = 0; 13001b718907SDavid Gibson first_ppc_cpu->env.nip = SPAPR_ENTRY_POINT; 130153018216SPaolo Bonzini 13026787d27bSMichael Roth spapr->cas_reboot = false; 130353018216SPaolo Bonzini } 130453018216SPaolo Bonzini 130528e02042SDavid Gibson static void spapr_create_nvram(sPAPRMachineState *spapr) 130653018216SPaolo Bonzini { 13072ff3de68SMarkus Armbruster DeviceState *dev = qdev_create(&spapr->vio_bus->bus, "spapr-nvram"); 13083978b863SPaolo Bonzini DriveInfo *dinfo = drive_get(IF_PFLASH, 0, 0); 130953018216SPaolo Bonzini 13103978b863SPaolo Bonzini if (dinfo) { 13116231a6daSMarkus Armbruster qdev_prop_set_drive(dev, "drive", blk_by_legacy_dinfo(dinfo), 13126231a6daSMarkus Armbruster &error_fatal); 131353018216SPaolo Bonzini } 131453018216SPaolo Bonzini 131553018216SPaolo Bonzini qdev_init_nofail(dev); 131653018216SPaolo Bonzini 131753018216SPaolo Bonzini spapr->nvram = (struct sPAPRNVRAM *)dev; 131853018216SPaolo Bonzini } 131953018216SPaolo Bonzini 132028e02042SDavid Gibson static void spapr_rtc_create(sPAPRMachineState *spapr) 132128df36a1SDavid Gibson { 132228df36a1SDavid Gibson DeviceState *dev = qdev_create(NULL, TYPE_SPAPR_RTC); 132328df36a1SDavid Gibson 132428df36a1SDavid Gibson qdev_init_nofail(dev); 132528df36a1SDavid Gibson spapr->rtc = dev; 132674e5ae28SDavid Gibson 132774e5ae28SDavid Gibson object_property_add_alias(qdev_get_machine(), "rtc-time", 132874e5ae28SDavid Gibson OBJECT(spapr->rtc), "date", NULL); 132928df36a1SDavid Gibson } 133028df36a1SDavid Gibson 133153018216SPaolo Bonzini /* Returns whether we want to use VGA or not */ 133214c6a894SDavid Gibson static bool spapr_vga_init(PCIBus *pci_bus, Error **errp) 133353018216SPaolo Bonzini { 133453018216SPaolo Bonzini switch (vga_interface_type) { 133553018216SPaolo Bonzini case VGA_NONE: 13367effdaa3SMark Wu return false; 13377effdaa3SMark Wu case VGA_DEVICE: 13387effdaa3SMark Wu return true; 133953018216SPaolo Bonzini case VGA_STD: 1340b798c190SBenjamin Herrenschmidt case VGA_VIRTIO: 134153018216SPaolo Bonzini return pci_vga_init(pci_bus) != NULL; 134253018216SPaolo Bonzini default: 134314c6a894SDavid Gibson error_setg(errp, 134414c6a894SDavid Gibson "Unsupported VGA mode, only -vga std or -vga virtio is supported"); 134514c6a894SDavid Gibson return false; 134653018216SPaolo Bonzini } 134753018216SPaolo Bonzini } 134853018216SPaolo Bonzini 1349880ae7deSDavid Gibson static int spapr_post_load(void *opaque, int version_id) 1350880ae7deSDavid Gibson { 135128e02042SDavid Gibson sPAPRMachineState *spapr = (sPAPRMachineState *)opaque; 1352880ae7deSDavid Gibson int err = 0; 1353880ae7deSDavid Gibson 1354631b22eaSStefan Weil /* In earlier versions, there was no separate qdev for the PAPR 1355880ae7deSDavid Gibson * RTC, so the RTC offset was stored directly in sPAPREnvironment. 1356880ae7deSDavid Gibson * So when migrating from those versions, poke the incoming offset 1357880ae7deSDavid Gibson * value into the RTC device */ 1358880ae7deSDavid Gibson if (version_id < 3) { 1359880ae7deSDavid Gibson err = spapr_rtc_import_offset(spapr->rtc, spapr->rtc_offset); 1360880ae7deSDavid Gibson } 1361880ae7deSDavid Gibson 1362880ae7deSDavid Gibson return err; 1363880ae7deSDavid Gibson } 1364880ae7deSDavid Gibson 1365880ae7deSDavid Gibson static bool version_before_3(void *opaque, int version_id) 1366880ae7deSDavid Gibson { 1367880ae7deSDavid Gibson return version_id < 3; 1368880ae7deSDavid Gibson } 1369880ae7deSDavid Gibson 137062ef3760SMichael Roth static bool spapr_ov5_cas_needed(void *opaque) 137162ef3760SMichael Roth { 137262ef3760SMichael Roth sPAPRMachineState *spapr = opaque; 137362ef3760SMichael Roth sPAPROptionVector *ov5_mask = spapr_ovec_new(); 137462ef3760SMichael Roth sPAPROptionVector *ov5_legacy = spapr_ovec_new(); 137562ef3760SMichael Roth sPAPROptionVector *ov5_removed = spapr_ovec_new(); 137662ef3760SMichael Roth bool cas_needed; 137762ef3760SMichael Roth 137862ef3760SMichael Roth /* Prior to the introduction of sPAPROptionVector, we had two option 137962ef3760SMichael Roth * vectors we dealt with: OV5_FORM1_AFFINITY, and OV5_DRCONF_MEMORY. 138062ef3760SMichael Roth * Both of these options encode machine topology into the device-tree 138162ef3760SMichael Roth * in such a way that the now-booted OS should still be able to interact 138262ef3760SMichael Roth * appropriately with QEMU regardless of what options were actually 138362ef3760SMichael Roth * negotiatied on the source side. 138462ef3760SMichael Roth * 138562ef3760SMichael Roth * As such, we can avoid migrating the CAS-negotiated options if these 138662ef3760SMichael Roth * are the only options available on the current machine/platform. 138762ef3760SMichael Roth * Since these are the only options available for pseries-2.7 and 138862ef3760SMichael Roth * earlier, this allows us to maintain old->new/new->old migration 138962ef3760SMichael Roth * compatibility. 139062ef3760SMichael Roth * 139162ef3760SMichael Roth * For QEMU 2.8+, there are additional CAS-negotiatable options available 139262ef3760SMichael Roth * via default pseries-2.8 machines and explicit command-line parameters. 139362ef3760SMichael Roth * Some of these options, like OV5_HP_EVT, *do* require QEMU to be aware 139462ef3760SMichael Roth * of the actual CAS-negotiated values to continue working properly. For 139562ef3760SMichael Roth * example, availability of memory unplug depends on knowing whether 139662ef3760SMichael Roth * OV5_HP_EVT was negotiated via CAS. 139762ef3760SMichael Roth * 139862ef3760SMichael Roth * Thus, for any cases where the set of available CAS-negotiatable 139962ef3760SMichael Roth * options extends beyond OV5_FORM1_AFFINITY and OV5_DRCONF_MEMORY, we 140062ef3760SMichael Roth * include the CAS-negotiated options in the migration stream. 140162ef3760SMichael Roth */ 140262ef3760SMichael Roth spapr_ovec_set(ov5_mask, OV5_FORM1_AFFINITY); 140362ef3760SMichael Roth spapr_ovec_set(ov5_mask, OV5_DRCONF_MEMORY); 140462ef3760SMichael Roth 140562ef3760SMichael Roth /* spapr_ovec_diff returns true if bits were removed. we avoid using 140662ef3760SMichael Roth * the mask itself since in the future it's possible "legacy" bits may be 140762ef3760SMichael Roth * removed via machine options, which could generate a false positive 140862ef3760SMichael Roth * that breaks migration. 140962ef3760SMichael Roth */ 141062ef3760SMichael Roth spapr_ovec_intersect(ov5_legacy, spapr->ov5, ov5_mask); 141162ef3760SMichael Roth cas_needed = spapr_ovec_diff(ov5_removed, spapr->ov5, ov5_legacy); 141262ef3760SMichael Roth 141362ef3760SMichael Roth spapr_ovec_cleanup(ov5_mask); 141462ef3760SMichael Roth spapr_ovec_cleanup(ov5_legacy); 141562ef3760SMichael Roth spapr_ovec_cleanup(ov5_removed); 141662ef3760SMichael Roth 141762ef3760SMichael Roth return cas_needed; 141862ef3760SMichael Roth } 141962ef3760SMichael Roth 142062ef3760SMichael Roth static const VMStateDescription vmstate_spapr_ov5_cas = { 142162ef3760SMichael Roth .name = "spapr_option_vector_ov5_cas", 142262ef3760SMichael Roth .version_id = 1, 142362ef3760SMichael Roth .minimum_version_id = 1, 142462ef3760SMichael Roth .needed = spapr_ov5_cas_needed, 142562ef3760SMichael Roth .fields = (VMStateField[]) { 142662ef3760SMichael Roth VMSTATE_STRUCT_POINTER_V(ov5_cas, sPAPRMachineState, 1, 142762ef3760SMichael Roth vmstate_spapr_ovec, sPAPROptionVector), 142862ef3760SMichael Roth VMSTATE_END_OF_LIST() 142962ef3760SMichael Roth }, 143062ef3760SMichael Roth }; 143162ef3760SMichael Roth 14324be21d56SDavid Gibson static const VMStateDescription vmstate_spapr = { 14334be21d56SDavid Gibson .name = "spapr", 1434880ae7deSDavid Gibson .version_id = 3, 14354be21d56SDavid Gibson .minimum_version_id = 1, 1436880ae7deSDavid Gibson .post_load = spapr_post_load, 14374be21d56SDavid Gibson .fields = (VMStateField[]) { 1438880ae7deSDavid Gibson /* used to be @next_irq */ 1439880ae7deSDavid Gibson VMSTATE_UNUSED_BUFFER(version_before_3, 0, 4), 14404be21d56SDavid Gibson 14414be21d56SDavid Gibson /* RTC offset */ 144228e02042SDavid Gibson VMSTATE_UINT64_TEST(rtc_offset, sPAPRMachineState, version_before_3), 1443880ae7deSDavid Gibson 144428e02042SDavid Gibson VMSTATE_PPC_TIMEBASE_V(tb, sPAPRMachineState, 2), 14454be21d56SDavid Gibson VMSTATE_END_OF_LIST() 14464be21d56SDavid Gibson }, 144762ef3760SMichael Roth .subsections = (const VMStateDescription*[]) { 144862ef3760SMichael Roth &vmstate_spapr_ov5_cas, 144962ef3760SMichael Roth NULL 145062ef3760SMichael Roth } 14514be21d56SDavid Gibson }; 14524be21d56SDavid Gibson 14534be21d56SDavid Gibson static int htab_save_setup(QEMUFile *f, void *opaque) 14544be21d56SDavid Gibson { 145528e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 14564be21d56SDavid Gibson 14574be21d56SDavid Gibson /* "Iteration" header */ 14584be21d56SDavid Gibson qemu_put_be32(f, spapr->htab_shift); 14594be21d56SDavid Gibson 1460e68cb8b4SAlexey Kardashevskiy if (spapr->htab) { 1461e68cb8b4SAlexey Kardashevskiy spapr->htab_save_index = 0; 1462e68cb8b4SAlexey Kardashevskiy spapr->htab_first_pass = true; 1463e68cb8b4SAlexey Kardashevskiy } else { 1464e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 14654be21d56SDavid Gibson } 14664be21d56SDavid Gibson 1467e68cb8b4SAlexey Kardashevskiy 1468e68cb8b4SAlexey Kardashevskiy return 0; 1469e68cb8b4SAlexey Kardashevskiy } 14704be21d56SDavid Gibson 147128e02042SDavid Gibson static void htab_save_first_pass(QEMUFile *f, sPAPRMachineState *spapr, 14724be21d56SDavid Gibson int64_t max_ns) 14734be21d56SDavid Gibson { 1474378bc217SDavid Gibson bool has_timeout = max_ns != -1; 14754be21d56SDavid Gibson int htabslots = HTAB_SIZE(spapr) / HASH_PTE_SIZE_64; 14764be21d56SDavid Gibson int index = spapr->htab_save_index; 1477bc72ad67SAlex Bligh int64_t starttime = qemu_clock_get_ns(QEMU_CLOCK_REALTIME); 14784be21d56SDavid Gibson 14794be21d56SDavid Gibson assert(spapr->htab_first_pass); 14804be21d56SDavid Gibson 14814be21d56SDavid Gibson do { 14824be21d56SDavid Gibson int chunkstart; 14834be21d56SDavid Gibson 14844be21d56SDavid Gibson /* Consume invalid HPTEs */ 14854be21d56SDavid Gibson while ((index < htabslots) 14864be21d56SDavid Gibson && !HPTE_VALID(HPTE(spapr->htab, index))) { 14874be21d56SDavid Gibson index++; 14884be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 14894be21d56SDavid Gibson } 14904be21d56SDavid Gibson 14914be21d56SDavid Gibson /* Consume valid HPTEs */ 14924be21d56SDavid Gibson chunkstart = index; 1493338c25b6SSamuel Mendoza-Jonas while ((index < htabslots) && (index - chunkstart < USHRT_MAX) 14944be21d56SDavid Gibson && HPTE_VALID(HPTE(spapr->htab, index))) { 14954be21d56SDavid Gibson index++; 14964be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 14974be21d56SDavid Gibson } 14984be21d56SDavid Gibson 14994be21d56SDavid Gibson if (index > chunkstart) { 15004be21d56SDavid Gibson int n_valid = index - chunkstart; 15014be21d56SDavid Gibson 15024be21d56SDavid Gibson qemu_put_be32(f, chunkstart); 15034be21d56SDavid Gibson qemu_put_be16(f, n_valid); 15044be21d56SDavid Gibson qemu_put_be16(f, 0); 15054be21d56SDavid Gibson qemu_put_buffer(f, HPTE(spapr->htab, chunkstart), 15064be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_valid); 15074be21d56SDavid Gibson 1508378bc217SDavid Gibson if (has_timeout && 1509378bc217SDavid Gibson (qemu_clock_get_ns(QEMU_CLOCK_REALTIME) - starttime) > max_ns) { 15104be21d56SDavid Gibson break; 15114be21d56SDavid Gibson } 15124be21d56SDavid Gibson } 15134be21d56SDavid Gibson } while ((index < htabslots) && !qemu_file_rate_limit(f)); 15144be21d56SDavid Gibson 15154be21d56SDavid Gibson if (index >= htabslots) { 15164be21d56SDavid Gibson assert(index == htabslots); 15174be21d56SDavid Gibson index = 0; 15184be21d56SDavid Gibson spapr->htab_first_pass = false; 15194be21d56SDavid Gibson } 15204be21d56SDavid Gibson spapr->htab_save_index = index; 15214be21d56SDavid Gibson } 15224be21d56SDavid Gibson 152328e02042SDavid Gibson static int htab_save_later_pass(QEMUFile *f, sPAPRMachineState *spapr, 15244be21d56SDavid Gibson int64_t max_ns) 15254be21d56SDavid Gibson { 15264be21d56SDavid Gibson bool final = max_ns < 0; 15274be21d56SDavid Gibson int htabslots = HTAB_SIZE(spapr) / HASH_PTE_SIZE_64; 15284be21d56SDavid Gibson int examined = 0, sent = 0; 15294be21d56SDavid Gibson int index = spapr->htab_save_index; 1530bc72ad67SAlex Bligh int64_t starttime = qemu_clock_get_ns(QEMU_CLOCK_REALTIME); 15314be21d56SDavid Gibson 15324be21d56SDavid Gibson assert(!spapr->htab_first_pass); 15334be21d56SDavid Gibson 15344be21d56SDavid Gibson do { 15354be21d56SDavid Gibson int chunkstart, invalidstart; 15364be21d56SDavid Gibson 15374be21d56SDavid Gibson /* Consume non-dirty HPTEs */ 15384be21d56SDavid Gibson while ((index < htabslots) 15394be21d56SDavid Gibson && !HPTE_DIRTY(HPTE(spapr->htab, index))) { 15404be21d56SDavid Gibson index++; 15414be21d56SDavid Gibson examined++; 15424be21d56SDavid Gibson } 15434be21d56SDavid Gibson 15444be21d56SDavid Gibson chunkstart = index; 15454be21d56SDavid Gibson /* Consume valid dirty HPTEs */ 1546338c25b6SSamuel Mendoza-Jonas while ((index < htabslots) && (index - chunkstart < USHRT_MAX) 15474be21d56SDavid Gibson && HPTE_DIRTY(HPTE(spapr->htab, index)) 15484be21d56SDavid Gibson && HPTE_VALID(HPTE(spapr->htab, index))) { 15494be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 15504be21d56SDavid Gibson index++; 15514be21d56SDavid Gibson examined++; 15524be21d56SDavid Gibson } 15534be21d56SDavid Gibson 15544be21d56SDavid Gibson invalidstart = index; 15554be21d56SDavid Gibson /* Consume invalid dirty HPTEs */ 1556338c25b6SSamuel Mendoza-Jonas while ((index < htabslots) && (index - invalidstart < USHRT_MAX) 15574be21d56SDavid Gibson && HPTE_DIRTY(HPTE(spapr->htab, index)) 15584be21d56SDavid Gibson && !HPTE_VALID(HPTE(spapr->htab, index))) { 15594be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 15604be21d56SDavid Gibson index++; 15614be21d56SDavid Gibson examined++; 15624be21d56SDavid Gibson } 15634be21d56SDavid Gibson 15644be21d56SDavid Gibson if (index > chunkstart) { 15654be21d56SDavid Gibson int n_valid = invalidstart - chunkstart; 15664be21d56SDavid Gibson int n_invalid = index - invalidstart; 15674be21d56SDavid Gibson 15684be21d56SDavid Gibson qemu_put_be32(f, chunkstart); 15694be21d56SDavid Gibson qemu_put_be16(f, n_valid); 15704be21d56SDavid Gibson qemu_put_be16(f, n_invalid); 15714be21d56SDavid Gibson qemu_put_buffer(f, HPTE(spapr->htab, chunkstart), 15724be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_valid); 15734be21d56SDavid Gibson sent += index - chunkstart; 15744be21d56SDavid Gibson 1575bc72ad67SAlex Bligh if (!final && (qemu_clock_get_ns(QEMU_CLOCK_REALTIME) - starttime) > max_ns) { 15764be21d56SDavid Gibson break; 15774be21d56SDavid Gibson } 15784be21d56SDavid Gibson } 15794be21d56SDavid Gibson 15804be21d56SDavid Gibson if (examined >= htabslots) { 15814be21d56SDavid Gibson break; 15824be21d56SDavid Gibson } 15834be21d56SDavid Gibson 15844be21d56SDavid Gibson if (index >= htabslots) { 15854be21d56SDavid Gibson assert(index == htabslots); 15864be21d56SDavid Gibson index = 0; 15874be21d56SDavid Gibson } 15884be21d56SDavid Gibson } while ((examined < htabslots) && (!qemu_file_rate_limit(f) || final)); 15894be21d56SDavid Gibson 15904be21d56SDavid Gibson if (index >= htabslots) { 15914be21d56SDavid Gibson assert(index == htabslots); 15924be21d56SDavid Gibson index = 0; 15934be21d56SDavid Gibson } 15944be21d56SDavid Gibson 15954be21d56SDavid Gibson spapr->htab_save_index = index; 15964be21d56SDavid Gibson 1597e68cb8b4SAlexey Kardashevskiy return (examined >= htabslots) && (sent == 0) ? 1 : 0; 15984be21d56SDavid Gibson } 15994be21d56SDavid Gibson 1600e68cb8b4SAlexey Kardashevskiy #define MAX_ITERATION_NS 5000000 /* 5 ms */ 1601e68cb8b4SAlexey Kardashevskiy #define MAX_KVM_BUF_SIZE 2048 1602e68cb8b4SAlexey Kardashevskiy 16034be21d56SDavid Gibson static int htab_save_iterate(QEMUFile *f, void *opaque) 16044be21d56SDavid Gibson { 160528e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 1606715c5407SDavid Gibson int fd; 1607e68cb8b4SAlexey Kardashevskiy int rc = 0; 16084be21d56SDavid Gibson 16094be21d56SDavid Gibson /* Iteration header */ 16104be21d56SDavid Gibson qemu_put_be32(f, 0); 16114be21d56SDavid Gibson 1612e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1613e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 1614e68cb8b4SAlexey Kardashevskiy 1615715c5407SDavid Gibson fd = get_htab_fd(spapr); 1616715c5407SDavid Gibson if (fd < 0) { 1617715c5407SDavid Gibson return fd; 161801a57972SSamuel Mendoza-Jonas } 161901a57972SSamuel Mendoza-Jonas 1620715c5407SDavid Gibson rc = kvmppc_save_htab(f, fd, MAX_KVM_BUF_SIZE, MAX_ITERATION_NS); 1621e68cb8b4SAlexey Kardashevskiy if (rc < 0) { 1622e68cb8b4SAlexey Kardashevskiy return rc; 1623e68cb8b4SAlexey Kardashevskiy } 1624e68cb8b4SAlexey Kardashevskiy } else if (spapr->htab_first_pass) { 16254be21d56SDavid Gibson htab_save_first_pass(f, spapr, MAX_ITERATION_NS); 16264be21d56SDavid Gibson } else { 1627e68cb8b4SAlexey Kardashevskiy rc = htab_save_later_pass(f, spapr, MAX_ITERATION_NS); 16284be21d56SDavid Gibson } 16294be21d56SDavid Gibson 16304be21d56SDavid Gibson /* End marker */ 16314be21d56SDavid Gibson qemu_put_be32(f, 0); 16324be21d56SDavid Gibson qemu_put_be16(f, 0); 16334be21d56SDavid Gibson qemu_put_be16(f, 0); 16344be21d56SDavid Gibson 1635e68cb8b4SAlexey Kardashevskiy return rc; 16364be21d56SDavid Gibson } 16374be21d56SDavid Gibson 16384be21d56SDavid Gibson static int htab_save_complete(QEMUFile *f, void *opaque) 16394be21d56SDavid Gibson { 164028e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 1641715c5407SDavid Gibson int fd; 16424be21d56SDavid Gibson 16434be21d56SDavid Gibson /* Iteration header */ 16444be21d56SDavid Gibson qemu_put_be32(f, 0); 16454be21d56SDavid Gibson 1646e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1647e68cb8b4SAlexey Kardashevskiy int rc; 1648e68cb8b4SAlexey Kardashevskiy 1649e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 1650e68cb8b4SAlexey Kardashevskiy 1651715c5407SDavid Gibson fd = get_htab_fd(spapr); 1652715c5407SDavid Gibson if (fd < 0) { 1653715c5407SDavid Gibson return fd; 165401a57972SSamuel Mendoza-Jonas } 165501a57972SSamuel Mendoza-Jonas 1656715c5407SDavid Gibson rc = kvmppc_save_htab(f, fd, MAX_KVM_BUF_SIZE, -1); 1657e68cb8b4SAlexey Kardashevskiy if (rc < 0) { 1658e68cb8b4SAlexey Kardashevskiy return rc; 1659e68cb8b4SAlexey Kardashevskiy } 1660e68cb8b4SAlexey Kardashevskiy } else { 1661378bc217SDavid Gibson if (spapr->htab_first_pass) { 1662378bc217SDavid Gibson htab_save_first_pass(f, spapr, -1); 1663378bc217SDavid Gibson } 16644be21d56SDavid Gibson htab_save_later_pass(f, spapr, -1); 1665e68cb8b4SAlexey Kardashevskiy } 16664be21d56SDavid Gibson 16674be21d56SDavid Gibson /* End marker */ 16684be21d56SDavid Gibson qemu_put_be32(f, 0); 16694be21d56SDavid Gibson qemu_put_be16(f, 0); 16704be21d56SDavid Gibson qemu_put_be16(f, 0); 16714be21d56SDavid Gibson 16724be21d56SDavid Gibson return 0; 16734be21d56SDavid Gibson } 16744be21d56SDavid Gibson 16754be21d56SDavid Gibson static int htab_load(QEMUFile *f, void *opaque, int version_id) 16764be21d56SDavid Gibson { 167728e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 16784be21d56SDavid Gibson uint32_t section_hdr; 1679e68cb8b4SAlexey Kardashevskiy int fd = -1; 16804be21d56SDavid Gibson 16814be21d56SDavid Gibson if (version_id < 1 || version_id > 1) { 168298a5d100SDavid Gibson error_report("htab_load() bad version"); 16834be21d56SDavid Gibson return -EINVAL; 16844be21d56SDavid Gibson } 16854be21d56SDavid Gibson 16864be21d56SDavid Gibson section_hdr = qemu_get_be32(f); 16874be21d56SDavid Gibson 16884be21d56SDavid Gibson if (section_hdr) { 16899897e462SGreg Kurz Error *local_err = NULL; 1690c5f54f3eSDavid Gibson 1691c5f54f3eSDavid Gibson /* First section gives the htab size */ 1692c5f54f3eSDavid Gibson spapr_reallocate_hpt(spapr, section_hdr, &local_err); 1693c5f54f3eSDavid Gibson if (local_err) { 1694c5f54f3eSDavid Gibson error_report_err(local_err); 16954be21d56SDavid Gibson return -EINVAL; 16964be21d56SDavid Gibson } 16974be21d56SDavid Gibson return 0; 16984be21d56SDavid Gibson } 16994be21d56SDavid Gibson 1700e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1701e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 1702e68cb8b4SAlexey Kardashevskiy 1703e68cb8b4SAlexey Kardashevskiy fd = kvmppc_get_htab_fd(true); 1704e68cb8b4SAlexey Kardashevskiy if (fd < 0) { 170598a5d100SDavid Gibson error_report("Unable to open fd to restore KVM hash table: %s", 1706e68cb8b4SAlexey Kardashevskiy strerror(errno)); 1707e68cb8b4SAlexey Kardashevskiy } 1708e68cb8b4SAlexey Kardashevskiy } 1709e68cb8b4SAlexey Kardashevskiy 17104be21d56SDavid Gibson while (true) { 17114be21d56SDavid Gibson uint32_t index; 17124be21d56SDavid Gibson uint16_t n_valid, n_invalid; 17134be21d56SDavid Gibson 17144be21d56SDavid Gibson index = qemu_get_be32(f); 17154be21d56SDavid Gibson n_valid = qemu_get_be16(f); 17164be21d56SDavid Gibson n_invalid = qemu_get_be16(f); 17174be21d56SDavid Gibson 17184be21d56SDavid Gibson if ((index == 0) && (n_valid == 0) && (n_invalid == 0)) { 17194be21d56SDavid Gibson /* End of Stream */ 17204be21d56SDavid Gibson break; 17214be21d56SDavid Gibson } 17224be21d56SDavid Gibson 1723e68cb8b4SAlexey Kardashevskiy if ((index + n_valid + n_invalid) > 17244be21d56SDavid Gibson (HTAB_SIZE(spapr) / HASH_PTE_SIZE_64)) { 17254be21d56SDavid Gibson /* Bad index in stream */ 172698a5d100SDavid Gibson error_report( 172798a5d100SDavid Gibson "htab_load() bad index %d (%hd+%hd entries) in htab stream (htab_shift=%d)", 172898a5d100SDavid Gibson index, n_valid, n_invalid, spapr->htab_shift); 17294be21d56SDavid Gibson return -EINVAL; 17304be21d56SDavid Gibson } 17314be21d56SDavid Gibson 1732e68cb8b4SAlexey Kardashevskiy if (spapr->htab) { 17334be21d56SDavid Gibson if (n_valid) { 17344be21d56SDavid Gibson qemu_get_buffer(f, HPTE(spapr->htab, index), 17354be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_valid); 17364be21d56SDavid Gibson } 17374be21d56SDavid Gibson if (n_invalid) { 17384be21d56SDavid Gibson memset(HPTE(spapr->htab, index + n_valid), 0, 17394be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_invalid); 17404be21d56SDavid Gibson } 1741e68cb8b4SAlexey Kardashevskiy } else { 1742e68cb8b4SAlexey Kardashevskiy int rc; 1743e68cb8b4SAlexey Kardashevskiy 1744e68cb8b4SAlexey Kardashevskiy assert(fd >= 0); 1745e68cb8b4SAlexey Kardashevskiy 1746e68cb8b4SAlexey Kardashevskiy rc = kvmppc_load_htab_chunk(f, fd, index, n_valid, n_invalid); 1747e68cb8b4SAlexey Kardashevskiy if (rc < 0) { 1748e68cb8b4SAlexey Kardashevskiy return rc; 1749e68cb8b4SAlexey Kardashevskiy } 1750e68cb8b4SAlexey Kardashevskiy } 1751e68cb8b4SAlexey Kardashevskiy } 1752e68cb8b4SAlexey Kardashevskiy 1753e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1754e68cb8b4SAlexey Kardashevskiy assert(fd >= 0); 1755e68cb8b4SAlexey Kardashevskiy close(fd); 17564be21d56SDavid Gibson } 17574be21d56SDavid Gibson 17584be21d56SDavid Gibson return 0; 17594be21d56SDavid Gibson } 17604be21d56SDavid Gibson 1761c573fc03SThomas Huth static void htab_cleanup(void *opaque) 1762c573fc03SThomas Huth { 1763c573fc03SThomas Huth sPAPRMachineState *spapr = opaque; 1764c573fc03SThomas Huth 1765c573fc03SThomas Huth close_htab_fd(spapr); 1766c573fc03SThomas Huth } 1767c573fc03SThomas Huth 17684be21d56SDavid Gibson static SaveVMHandlers savevm_htab_handlers = { 17694be21d56SDavid Gibson .save_live_setup = htab_save_setup, 17704be21d56SDavid Gibson .save_live_iterate = htab_save_iterate, 1771a3e06c3dSDr. David Alan Gilbert .save_live_complete_precopy = htab_save_complete, 1772c573fc03SThomas Huth .cleanup = htab_cleanup, 17734be21d56SDavid Gibson .load_state = htab_load, 17744be21d56SDavid Gibson }; 17754be21d56SDavid Gibson 17765b2128d2SAlexander Graf static void spapr_boot_set(void *opaque, const char *boot_device, 17775b2128d2SAlexander Graf Error **errp) 17785b2128d2SAlexander Graf { 17795b2128d2SAlexander Graf MachineState *machine = MACHINE(qdev_get_machine()); 17805b2128d2SAlexander Graf machine->boot_order = g_strdup(boot_device); 17815b2128d2SAlexander Graf } 17825b2128d2SAlexander Graf 1783224245bfSDavid Gibson /* 1784224245bfSDavid Gibson * Reset routine for LMB DR devices. 1785224245bfSDavid Gibson * 1786224245bfSDavid Gibson * Unlike PCI DR devices, LMB DR devices explicitly register this reset 1787224245bfSDavid Gibson * routine. Reset for PCI DR devices will be handled by PHB reset routine 1788224245bfSDavid Gibson * when it walks all its children devices. LMB devices reset occurs 1789224245bfSDavid Gibson * as part of spapr_ppc_reset(). 1790224245bfSDavid Gibson */ 1791224245bfSDavid Gibson static void spapr_drc_reset(void *opaque) 1792224245bfSDavid Gibson { 1793224245bfSDavid Gibson sPAPRDRConnector *drc = opaque; 1794224245bfSDavid Gibson DeviceState *d = DEVICE(drc); 1795224245bfSDavid Gibson 1796224245bfSDavid Gibson if (d) { 1797224245bfSDavid Gibson device_reset(d); 1798224245bfSDavid Gibson } 1799224245bfSDavid Gibson } 1800224245bfSDavid Gibson 1801224245bfSDavid Gibson static void spapr_create_lmb_dr_connectors(sPAPRMachineState *spapr) 1802224245bfSDavid Gibson { 1803224245bfSDavid Gibson MachineState *machine = MACHINE(spapr); 1804224245bfSDavid Gibson uint64_t lmb_size = SPAPR_MEMORY_BLOCK_SIZE; 1805e8f986fcSBharata B Rao uint32_t nr_lmbs = (machine->maxram_size - machine->ram_size)/lmb_size; 1806224245bfSDavid Gibson int i; 1807224245bfSDavid Gibson 1808224245bfSDavid Gibson for (i = 0; i < nr_lmbs; i++) { 1809224245bfSDavid Gibson sPAPRDRConnector *drc; 1810224245bfSDavid Gibson uint64_t addr; 1811224245bfSDavid Gibson 1812e8f986fcSBharata B Rao addr = i * lmb_size + spapr->hotplug_memory.base; 1813224245bfSDavid Gibson drc = spapr_dr_connector_new(OBJECT(spapr), SPAPR_DR_CONNECTOR_TYPE_LMB, 1814224245bfSDavid Gibson addr/lmb_size); 1815224245bfSDavid Gibson qemu_register_reset(spapr_drc_reset, drc); 1816224245bfSDavid Gibson } 1817224245bfSDavid Gibson } 1818224245bfSDavid Gibson 1819224245bfSDavid Gibson /* 1820224245bfSDavid Gibson * If RAM size, maxmem size and individual node mem sizes aren't aligned 1821224245bfSDavid Gibson * to SPAPR_MEMORY_BLOCK_SIZE(256MB), then refuse to start the guest 1822224245bfSDavid Gibson * since we can't support such unaligned sizes with DRCONF_MEMORY. 1823224245bfSDavid Gibson */ 18247c150d6fSDavid Gibson static void spapr_validate_node_memory(MachineState *machine, Error **errp) 1825224245bfSDavid Gibson { 1826224245bfSDavid Gibson int i; 1827224245bfSDavid Gibson 18287c150d6fSDavid Gibson if (machine->ram_size % SPAPR_MEMORY_BLOCK_SIZE) { 18297c150d6fSDavid Gibson error_setg(errp, "Memory size 0x" RAM_ADDR_FMT 18307c150d6fSDavid Gibson " is not aligned to %llu MiB", 18317c150d6fSDavid Gibson machine->ram_size, 1832224245bfSDavid Gibson SPAPR_MEMORY_BLOCK_SIZE / M_BYTE); 18337c150d6fSDavid Gibson return; 18347c150d6fSDavid Gibson } 18357c150d6fSDavid Gibson 18367c150d6fSDavid Gibson if (machine->maxram_size % SPAPR_MEMORY_BLOCK_SIZE) { 18377c150d6fSDavid Gibson error_setg(errp, "Maximum memory size 0x" RAM_ADDR_FMT 18387c150d6fSDavid Gibson " is not aligned to %llu MiB", 18397c150d6fSDavid Gibson machine->ram_size, 18407c150d6fSDavid Gibson SPAPR_MEMORY_BLOCK_SIZE / M_BYTE); 18417c150d6fSDavid Gibson return; 1842224245bfSDavid Gibson } 1843224245bfSDavid Gibson 1844224245bfSDavid Gibson for (i = 0; i < nb_numa_nodes; i++) { 1845224245bfSDavid Gibson if (numa_info[i].node_mem % SPAPR_MEMORY_BLOCK_SIZE) { 18467c150d6fSDavid Gibson error_setg(errp, 18477c150d6fSDavid Gibson "Node %d memory size 0x%" PRIx64 18487c150d6fSDavid Gibson " is not aligned to %llu MiB", 18497c150d6fSDavid Gibson i, numa_info[i].node_mem, 1850224245bfSDavid Gibson SPAPR_MEMORY_BLOCK_SIZE / M_BYTE); 18517c150d6fSDavid Gibson return; 1852224245bfSDavid Gibson } 1853224245bfSDavid Gibson } 1854224245bfSDavid Gibson } 1855224245bfSDavid Gibson 1856535455fdSIgor Mammedov /* find cpu slot in machine->possible_cpus by core_id */ 1857535455fdSIgor Mammedov static CPUArchId *spapr_find_cpu_slot(MachineState *ms, uint32_t id, int *idx) 1858535455fdSIgor Mammedov { 1859535455fdSIgor Mammedov int index = id / smp_threads; 1860535455fdSIgor Mammedov 1861535455fdSIgor Mammedov if (index >= ms->possible_cpus->len) { 1862535455fdSIgor Mammedov return NULL; 1863535455fdSIgor Mammedov } 1864535455fdSIgor Mammedov if (idx) { 1865535455fdSIgor Mammedov *idx = index; 1866535455fdSIgor Mammedov } 1867535455fdSIgor Mammedov return &ms->possible_cpus->cpus[index]; 1868535455fdSIgor Mammedov } 1869535455fdSIgor Mammedov 18700c86d0fdSDavid Gibson static void spapr_init_cpus(sPAPRMachineState *spapr) 18710c86d0fdSDavid Gibson { 18720c86d0fdSDavid Gibson MachineState *machine = MACHINE(spapr); 18730c86d0fdSDavid Gibson MachineClass *mc = MACHINE_GET_CLASS(machine); 18740c86d0fdSDavid Gibson char *type = spapr_get_cpu_core_type(machine->cpu_model); 18750c86d0fdSDavid Gibson int smt = kvmppc_smt_threads(); 1876535455fdSIgor Mammedov const CPUArchIdList *possible_cpus; 1877535455fdSIgor Mammedov int boot_cores_nr = smp_cpus / smp_threads; 18780c86d0fdSDavid Gibson int i; 18790c86d0fdSDavid Gibson 18800c86d0fdSDavid Gibson if (!type) { 18810c86d0fdSDavid Gibson error_report("Unable to find sPAPR CPU Core definition"); 18820c86d0fdSDavid Gibson exit(1); 18830c86d0fdSDavid Gibson } 18840c86d0fdSDavid Gibson 1885535455fdSIgor Mammedov possible_cpus = mc->possible_cpu_arch_ids(machine); 1886c5514d0eSIgor Mammedov if (mc->has_hotpluggable_cpus) { 18870c86d0fdSDavid Gibson if (smp_cpus % smp_threads) { 18880c86d0fdSDavid Gibson error_report("smp_cpus (%u) must be multiple of threads (%u)", 18890c86d0fdSDavid Gibson smp_cpus, smp_threads); 18900c86d0fdSDavid Gibson exit(1); 18910c86d0fdSDavid Gibson } 18920c86d0fdSDavid Gibson if (max_cpus % smp_threads) { 18930c86d0fdSDavid Gibson error_report("max_cpus (%u) must be multiple of threads (%u)", 18940c86d0fdSDavid Gibson max_cpus, smp_threads); 18950c86d0fdSDavid Gibson exit(1); 18960c86d0fdSDavid Gibson } 18970c86d0fdSDavid Gibson } else { 18980c86d0fdSDavid Gibson if (max_cpus != smp_cpus) { 18990c86d0fdSDavid Gibson error_report("This machine version does not support CPU hotplug"); 19000c86d0fdSDavid Gibson exit(1); 19010c86d0fdSDavid Gibson } 1902535455fdSIgor Mammedov boot_cores_nr = possible_cpus->len; 19030c86d0fdSDavid Gibson } 19040c86d0fdSDavid Gibson 1905535455fdSIgor Mammedov for (i = 0; i < possible_cpus->len; i++) { 19060c86d0fdSDavid Gibson int core_id = i * smp_threads; 19070c86d0fdSDavid Gibson 1908c5514d0eSIgor Mammedov if (mc->has_hotpluggable_cpus) { 19090c86d0fdSDavid Gibson sPAPRDRConnector *drc = 19100c86d0fdSDavid Gibson spapr_dr_connector_new(OBJECT(spapr), 19110c86d0fdSDavid Gibson SPAPR_DR_CONNECTOR_TYPE_CPU, 19120c86d0fdSDavid Gibson (core_id / smp_threads) * smt); 19130c86d0fdSDavid Gibson 19140c86d0fdSDavid Gibson qemu_register_reset(spapr_drc_reset, drc); 19150c86d0fdSDavid Gibson } 19160c86d0fdSDavid Gibson 1917535455fdSIgor Mammedov if (i < boot_cores_nr) { 19180c86d0fdSDavid Gibson Object *core = object_new(type); 19190c86d0fdSDavid Gibson int nr_threads = smp_threads; 19200c86d0fdSDavid Gibson 19210c86d0fdSDavid Gibson /* Handle the partially filled core for older machine types */ 19220c86d0fdSDavid Gibson if ((i + 1) * smp_threads >= smp_cpus) { 19230c86d0fdSDavid Gibson nr_threads = smp_cpus - i * smp_threads; 19240c86d0fdSDavid Gibson } 19250c86d0fdSDavid Gibson 19260c86d0fdSDavid Gibson object_property_set_int(core, nr_threads, "nr-threads", 19270c86d0fdSDavid Gibson &error_fatal); 19280c86d0fdSDavid Gibson object_property_set_int(core, core_id, CPU_CORE_PROP_CORE_ID, 19290c86d0fdSDavid Gibson &error_fatal); 19300c86d0fdSDavid Gibson object_property_set_bool(core, true, "realized", &error_fatal); 19310c86d0fdSDavid Gibson } 19320c86d0fdSDavid Gibson } 19330c86d0fdSDavid Gibson g_free(type); 19340c86d0fdSDavid Gibson } 19350c86d0fdSDavid Gibson 193653018216SPaolo Bonzini /* pSeries LPAR / sPAPR hardware init */ 19373ef96221SMarcel Apfelbaum static void ppc_spapr_init(MachineState *machine) 193853018216SPaolo Bonzini { 193928e02042SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(machine); 1940224245bfSDavid Gibson sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(machine); 19413ef96221SMarcel Apfelbaum const char *kernel_filename = machine->kernel_filename; 19423ef96221SMarcel Apfelbaum const char *initrd_filename = machine->initrd_filename; 194353018216SPaolo Bonzini PCIHostState *phb; 194453018216SPaolo Bonzini int i; 194553018216SPaolo Bonzini MemoryRegion *sysmem = get_system_memory(); 194653018216SPaolo Bonzini MemoryRegion *ram = g_new(MemoryRegion, 1); 1947658fa66bSAlexey Kardashevskiy MemoryRegion *rma_region; 1948658fa66bSAlexey Kardashevskiy void *rma = NULL; 194953018216SPaolo Bonzini hwaddr rma_alloc_size; 1950b082d65aSAlexey Kardashevskiy hwaddr node0_size = spapr_node0_size(); 1951b7d1f77aSBenjamin Herrenschmidt long load_limit, fw_size; 195253018216SPaolo Bonzini char *filename; 195394a94e4cSBharata B Rao int smt = kvmppc_smt_threads(); 195453018216SPaolo Bonzini 1955226419d6SMichael S. Tsirkin msi_nonbroken = true; 195653018216SPaolo Bonzini 195753018216SPaolo Bonzini QLIST_INIT(&spapr->phbs); 195853018216SPaolo Bonzini 195953018216SPaolo Bonzini /* Allocate RMA if necessary */ 1960658fa66bSAlexey Kardashevskiy rma_alloc_size = kvmppc_alloc_rma(&rma); 196153018216SPaolo Bonzini 196253018216SPaolo Bonzini if (rma_alloc_size == -1) { 1963730fce59SThomas Huth error_report("Unable to create RMA"); 196453018216SPaolo Bonzini exit(1); 196553018216SPaolo Bonzini } 196653018216SPaolo Bonzini 1967c4177479SAlexey Kardashevskiy if (rma_alloc_size && (rma_alloc_size < node0_size)) { 196853018216SPaolo Bonzini spapr->rma_size = rma_alloc_size; 196953018216SPaolo Bonzini } else { 1970c4177479SAlexey Kardashevskiy spapr->rma_size = node0_size; 197153018216SPaolo Bonzini 197253018216SPaolo Bonzini /* With KVM, we don't actually know whether KVM supports an 197353018216SPaolo Bonzini * unbounded RMA (PR KVM) or is limited by the hash table size 197453018216SPaolo Bonzini * (HV KVM using VRMA), so we always assume the latter 197553018216SPaolo Bonzini * 197653018216SPaolo Bonzini * In that case, we also limit the initial allocations for RTAS 197753018216SPaolo Bonzini * etc... to 256M since we have no way to know what the VRMA size 197853018216SPaolo Bonzini * is going to be as it depends on the size of the hash table 197953018216SPaolo Bonzini * isn't determined yet. 198053018216SPaolo Bonzini */ 198153018216SPaolo Bonzini if (kvm_enabled()) { 198253018216SPaolo Bonzini spapr->vrma_adjust = 1; 198353018216SPaolo Bonzini spapr->rma_size = MIN(spapr->rma_size, 0x10000000); 198453018216SPaolo Bonzini } 1985912acdf4SBenjamin Herrenschmidt 1986912acdf4SBenjamin Herrenschmidt /* Actually we don't support unbounded RMA anymore since we 1987912acdf4SBenjamin Herrenschmidt * added proper emulation of HV mode. The max we can get is 1988912acdf4SBenjamin Herrenschmidt * 16G which also happens to be what we configure for PAPR 1989912acdf4SBenjamin Herrenschmidt * mode so make sure we don't do anything bigger than that 1990912acdf4SBenjamin Herrenschmidt */ 1991912acdf4SBenjamin Herrenschmidt spapr->rma_size = MIN(spapr->rma_size, 0x400000000ull); 199253018216SPaolo Bonzini } 199353018216SPaolo Bonzini 1994c4177479SAlexey Kardashevskiy if (spapr->rma_size > node0_size) { 1995d54e4d76SDavid Gibson error_report("Numa node 0 has to span the RMA (%#08"HWADDR_PRIx")", 1996c4177479SAlexey Kardashevskiy spapr->rma_size); 1997c4177479SAlexey Kardashevskiy exit(1); 1998c4177479SAlexey Kardashevskiy } 1999c4177479SAlexey Kardashevskiy 2000b7d1f77aSBenjamin Herrenschmidt /* Setup a load limit for the ramdisk leaving room for SLOF and FDT */ 2001b7d1f77aSBenjamin Herrenschmidt load_limit = MIN(spapr->rma_size, RTAS_MAX_ADDR) - FW_OVERHEAD; 200253018216SPaolo Bonzini 20037b565160SDavid Gibson /* Set up Interrupt Controller before we create the VCPUs */ 200427f24582SBenjamin Herrenschmidt spapr->xics = xics_system_init(machine, 200594a94e4cSBharata B Rao DIV_ROUND_UP(max_cpus * smt, smp_threads), 2006161deaf2SBenjamin Herrenschmidt XICS_IRQS_SPAPR, &error_fatal); 20077b565160SDavid Gibson 2008facdb8b6SMichael Roth /* Set up containers for ibm,client-set-architecture negotiated options */ 2009facdb8b6SMichael Roth spapr->ov5 = spapr_ovec_new(); 2010facdb8b6SMichael Roth spapr->ov5_cas = spapr_ovec_new(); 2011facdb8b6SMichael Roth 2012224245bfSDavid Gibson if (smc->dr_lmb_enabled) { 2013facdb8b6SMichael Roth spapr_ovec_set(spapr->ov5, OV5_DRCONF_MEMORY); 20147c150d6fSDavid Gibson spapr_validate_node_memory(machine, &error_fatal); 2015224245bfSDavid Gibson } 2016224245bfSDavid Gibson 2017417ece33SMichael Roth spapr_ovec_set(spapr->ov5, OV5_FORM1_AFFINITY); 2018417ece33SMichael Roth 2019ffbb1705SMichael Roth /* advertise support for dedicated HP event source to guests */ 2020ffbb1705SMichael Roth if (spapr->use_hotplug_event_source) { 2021ffbb1705SMichael Roth spapr_ovec_set(spapr->ov5, OV5_HP_EVT); 2022ffbb1705SMichael Roth } 2023ffbb1705SMichael Roth 202453018216SPaolo Bonzini /* init CPUs */ 202519fb2c36SBharata B Rao if (machine->cpu_model == NULL) { 20263daa4a9fSThomas Huth machine->cpu_model = kvm_enabled() ? "host" : smc->tcg_default_cpu; 202753018216SPaolo Bonzini } 202894a94e4cSBharata B Rao 2029e703d2f7SGreg Kurz ppc_cpu_parse_features(machine->cpu_model); 2030e703d2f7SGreg Kurz 20310c86d0fdSDavid Gibson spapr_init_cpus(spapr); 203253018216SPaolo Bonzini 2033026bfd89SDavid Gibson if (kvm_enabled()) { 2034026bfd89SDavid Gibson /* Enable H_LOGICAL_CI_* so SLOF can talk to in-kernel devices */ 2035026bfd89SDavid Gibson kvmppc_enable_logical_ci_hcalls(); 2036ef9971ddSAlexey Kardashevskiy kvmppc_enable_set_mode_hcall(); 20375145ad4fSNathan Whitehorn 20385145ad4fSNathan Whitehorn /* H_CLEAR_MOD/_REF are mandatory in PAPR, but off by default */ 20395145ad4fSNathan Whitehorn kvmppc_enable_clear_ref_mod_hcalls(); 2040026bfd89SDavid Gibson } 2041026bfd89SDavid Gibson 204253018216SPaolo Bonzini /* allocate RAM */ 2043f92f5da1SAlexey Kardashevskiy memory_region_allocate_system_memory(ram, NULL, "ppc_spapr.ram", 2044fb164994SDavid Gibson machine->ram_size); 2045f92f5da1SAlexey Kardashevskiy memory_region_add_subregion(sysmem, 0, ram); 204653018216SPaolo Bonzini 2047658fa66bSAlexey Kardashevskiy if (rma_alloc_size && rma) { 2048658fa66bSAlexey Kardashevskiy rma_region = g_new(MemoryRegion, 1); 2049658fa66bSAlexey Kardashevskiy memory_region_init_ram_ptr(rma_region, NULL, "ppc_spapr.rma", 2050658fa66bSAlexey Kardashevskiy rma_alloc_size, rma); 2051658fa66bSAlexey Kardashevskiy vmstate_register_ram_global(rma_region); 2052658fa66bSAlexey Kardashevskiy memory_region_add_subregion(sysmem, 0, rma_region); 2053658fa66bSAlexey Kardashevskiy } 2054658fa66bSAlexey Kardashevskiy 20554a1c9cf0SBharata B Rao /* initialize hotplug memory address space */ 20564a1c9cf0SBharata B Rao if (machine->ram_size < machine->maxram_size) { 20574a1c9cf0SBharata B Rao ram_addr_t hotplug_mem_size = machine->maxram_size - machine->ram_size; 205871c9a3ddSBharata B Rao /* 205971c9a3ddSBharata B Rao * Limit the number of hotpluggable memory slots to half the number 206071c9a3ddSBharata B Rao * slots that KVM supports, leaving the other half for PCI and other 206171c9a3ddSBharata B Rao * devices. However ensure that number of slots doesn't drop below 32. 206271c9a3ddSBharata B Rao */ 206371c9a3ddSBharata B Rao int max_memslots = kvm_enabled() ? kvm_get_max_memslots() / 2 : 206471c9a3ddSBharata B Rao SPAPR_MAX_RAM_SLOTS; 20654a1c9cf0SBharata B Rao 206671c9a3ddSBharata B Rao if (max_memslots < SPAPR_MAX_RAM_SLOTS) { 206771c9a3ddSBharata B Rao max_memslots = SPAPR_MAX_RAM_SLOTS; 206871c9a3ddSBharata B Rao } 206971c9a3ddSBharata B Rao if (machine->ram_slots > max_memslots) { 2070d54e4d76SDavid Gibson error_report("Specified number of memory slots %" 2071d54e4d76SDavid Gibson PRIu64" exceeds max supported %d", 207271c9a3ddSBharata B Rao machine->ram_slots, max_memslots); 2073d54e4d76SDavid Gibson exit(1); 20744a1c9cf0SBharata B Rao } 20754a1c9cf0SBharata B Rao 20764a1c9cf0SBharata B Rao spapr->hotplug_memory.base = ROUND_UP(machine->ram_size, 20774a1c9cf0SBharata B Rao SPAPR_HOTPLUG_MEM_ALIGN); 20784a1c9cf0SBharata B Rao memory_region_init(&spapr->hotplug_memory.mr, OBJECT(spapr), 20794a1c9cf0SBharata B Rao "hotplug-memory", hotplug_mem_size); 20804a1c9cf0SBharata B Rao memory_region_add_subregion(sysmem, spapr->hotplug_memory.base, 20814a1c9cf0SBharata B Rao &spapr->hotplug_memory.mr); 20824a1c9cf0SBharata B Rao } 20834a1c9cf0SBharata B Rao 2084224245bfSDavid Gibson if (smc->dr_lmb_enabled) { 2085224245bfSDavid Gibson spapr_create_lmb_dr_connectors(spapr); 2086224245bfSDavid Gibson } 2087224245bfSDavid Gibson 208853018216SPaolo Bonzini filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, "spapr-rtas.bin"); 20894c56440dSStefan Weil if (!filename) { 2090730fce59SThomas Huth error_report("Could not find LPAR rtas '%s'", "spapr-rtas.bin"); 20914c56440dSStefan Weil exit(1); 20924c56440dSStefan Weil } 2093b7d1f77aSBenjamin Herrenschmidt spapr->rtas_size = get_image_size(filename); 20948afc22a2SZhou Jie if (spapr->rtas_size < 0) { 20958afc22a2SZhou Jie error_report("Could not get size of LPAR rtas '%s'", filename); 20968afc22a2SZhou Jie exit(1); 20978afc22a2SZhou Jie } 2098b7d1f77aSBenjamin Herrenschmidt spapr->rtas_blob = g_malloc(spapr->rtas_size); 2099b7d1f77aSBenjamin Herrenschmidt if (load_image_size(filename, spapr->rtas_blob, spapr->rtas_size) < 0) { 2100730fce59SThomas Huth error_report("Could not load LPAR rtas '%s'", filename); 210153018216SPaolo Bonzini exit(1); 210253018216SPaolo Bonzini } 210353018216SPaolo Bonzini if (spapr->rtas_size > RTAS_MAX_SIZE) { 2104730fce59SThomas Huth error_report("RTAS too big ! 0x%zx bytes (max is 0x%x)", 21052f285bddSPeter Maydell (size_t)spapr->rtas_size, RTAS_MAX_SIZE); 210653018216SPaolo Bonzini exit(1); 210753018216SPaolo Bonzini } 210853018216SPaolo Bonzini g_free(filename); 210953018216SPaolo Bonzini 2110ffbb1705SMichael Roth /* Set up RTAS event infrastructure */ 211153018216SPaolo Bonzini spapr_events_init(spapr); 211253018216SPaolo Bonzini 211312f42174SDavid Gibson /* Set up the RTC RTAS interfaces */ 211428df36a1SDavid Gibson spapr_rtc_create(spapr); 211512f42174SDavid Gibson 211653018216SPaolo Bonzini /* Set up VIO bus */ 211753018216SPaolo Bonzini spapr->vio_bus = spapr_vio_bus_init(); 211853018216SPaolo Bonzini 211953018216SPaolo Bonzini for (i = 0; i < MAX_SERIAL_PORTS; i++) { 212053018216SPaolo Bonzini if (serial_hds[i]) { 212153018216SPaolo Bonzini spapr_vty_create(spapr->vio_bus, serial_hds[i]); 212253018216SPaolo Bonzini } 212353018216SPaolo Bonzini } 212453018216SPaolo Bonzini 212553018216SPaolo Bonzini /* We always have at least the nvram device on VIO */ 212653018216SPaolo Bonzini spapr_create_nvram(spapr); 212753018216SPaolo Bonzini 212853018216SPaolo Bonzini /* Set up PCI */ 212953018216SPaolo Bonzini spapr_pci_rtas_init(); 213053018216SPaolo Bonzini 213189dfd6e1SDavid Gibson phb = spapr_create_phb(spapr, 0); 213253018216SPaolo Bonzini 213353018216SPaolo Bonzini for (i = 0; i < nb_nics; i++) { 213453018216SPaolo Bonzini NICInfo *nd = &nd_table[i]; 213553018216SPaolo Bonzini 213653018216SPaolo Bonzini if (!nd->model) { 213753018216SPaolo Bonzini nd->model = g_strdup("ibmveth"); 213853018216SPaolo Bonzini } 213953018216SPaolo Bonzini 214053018216SPaolo Bonzini if (strcmp(nd->model, "ibmveth") == 0) { 214153018216SPaolo Bonzini spapr_vlan_create(spapr->vio_bus, nd); 214253018216SPaolo Bonzini } else { 214329b358f9SDavid Gibson pci_nic_init_nofail(&nd_table[i], phb->bus, nd->model, NULL); 214453018216SPaolo Bonzini } 214553018216SPaolo Bonzini } 214653018216SPaolo Bonzini 214753018216SPaolo Bonzini for (i = 0; i <= drive_get_max_bus(IF_SCSI); i++) { 214853018216SPaolo Bonzini spapr_vscsi_create(spapr->vio_bus); 214953018216SPaolo Bonzini } 215053018216SPaolo Bonzini 215153018216SPaolo Bonzini /* Graphics */ 215214c6a894SDavid Gibson if (spapr_vga_init(phb->bus, &error_fatal)) { 215353018216SPaolo Bonzini spapr->has_graphics = true; 2154c6e76503SPaolo Bonzini machine->usb |= defaults_enabled() && !machine->usb_disabled; 215553018216SPaolo Bonzini } 215653018216SPaolo Bonzini 21574ee9ced9SMarcel Apfelbaum if (machine->usb) { 215857040d45SThomas Huth if (smc->use_ohci_by_default) { 215953018216SPaolo Bonzini pci_create_simple(phb->bus, -1, "pci-ohci"); 216057040d45SThomas Huth } else { 216157040d45SThomas Huth pci_create_simple(phb->bus, -1, "nec-usb-xhci"); 216257040d45SThomas Huth } 2163c86580b8SMarkus Armbruster 216453018216SPaolo Bonzini if (spapr->has_graphics) { 2165c86580b8SMarkus Armbruster USBBus *usb_bus = usb_bus_find(-1); 2166c86580b8SMarkus Armbruster 2167c86580b8SMarkus Armbruster usb_create_simple(usb_bus, "usb-kbd"); 2168c86580b8SMarkus Armbruster usb_create_simple(usb_bus, "usb-mouse"); 216953018216SPaolo Bonzini } 217053018216SPaolo Bonzini } 217153018216SPaolo Bonzini 217253018216SPaolo Bonzini if (spapr->rma_size < (MIN_RMA_SLOF << 20)) { 2173d54e4d76SDavid Gibson error_report( 2174d54e4d76SDavid Gibson "pSeries SLOF firmware requires >= %ldM guest RMA (Real Mode Area memory)", 2175d54e4d76SDavid Gibson MIN_RMA_SLOF); 217653018216SPaolo Bonzini exit(1); 217753018216SPaolo Bonzini } 217853018216SPaolo Bonzini 217953018216SPaolo Bonzini if (kernel_filename) { 218053018216SPaolo Bonzini uint64_t lowaddr = 0; 218153018216SPaolo Bonzini 2182a19f7fb0SDavid Gibson spapr->kernel_size = load_elf(kernel_filename, translate_kernel_address, 2183a19f7fb0SDavid Gibson NULL, NULL, &lowaddr, NULL, 1, 2184a19f7fb0SDavid Gibson PPC_ELF_MACHINE, 0, 0); 2185a19f7fb0SDavid Gibson if (spapr->kernel_size == ELF_LOAD_WRONG_ENDIAN) { 2186a19f7fb0SDavid Gibson spapr->kernel_size = load_elf(kernel_filename, 2187a19f7fb0SDavid Gibson translate_kernel_address, NULL, NULL, 2188a19f7fb0SDavid Gibson &lowaddr, NULL, 0, PPC_ELF_MACHINE, 21897ef295eaSPeter Crosthwaite 0, 0); 2190a19f7fb0SDavid Gibson spapr->kernel_le = spapr->kernel_size > 0; 219116457e7fSBenjamin Herrenschmidt } 2192a19f7fb0SDavid Gibson if (spapr->kernel_size < 0) { 2193a19f7fb0SDavid Gibson error_report("error loading %s: %s", kernel_filename, 2194a19f7fb0SDavid Gibson load_elf_strerror(spapr->kernel_size)); 219553018216SPaolo Bonzini exit(1); 219653018216SPaolo Bonzini } 219753018216SPaolo Bonzini 219853018216SPaolo Bonzini /* load initrd */ 219953018216SPaolo Bonzini if (initrd_filename) { 220053018216SPaolo Bonzini /* Try to locate the initrd in the gap between the kernel 220153018216SPaolo Bonzini * and the firmware. Add a bit of space just in case 220253018216SPaolo Bonzini */ 2203a19f7fb0SDavid Gibson spapr->initrd_base = (KERNEL_LOAD_ADDR + spapr->kernel_size 2204a19f7fb0SDavid Gibson + 0x1ffff) & ~0xffff; 2205a19f7fb0SDavid Gibson spapr->initrd_size = load_image_targphys(initrd_filename, 2206a19f7fb0SDavid Gibson spapr->initrd_base, 2207a19f7fb0SDavid Gibson load_limit 2208a19f7fb0SDavid Gibson - spapr->initrd_base); 2209a19f7fb0SDavid Gibson if (spapr->initrd_size < 0) { 2210d54e4d76SDavid Gibson error_report("could not load initial ram disk '%s'", 221153018216SPaolo Bonzini initrd_filename); 221253018216SPaolo Bonzini exit(1); 221353018216SPaolo Bonzini } 221453018216SPaolo Bonzini } 221553018216SPaolo Bonzini } 221653018216SPaolo Bonzini 22178e7ea787SAndreas Färber if (bios_name == NULL) { 22188e7ea787SAndreas Färber bios_name = FW_FILE_NAME; 22198e7ea787SAndreas Färber } 22208e7ea787SAndreas Färber filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name); 22214c56440dSStefan Weil if (!filename) { 222268fea5a0SThomas Huth error_report("Could not find LPAR firmware '%s'", bios_name); 22234c56440dSStefan Weil exit(1); 22244c56440dSStefan Weil } 222553018216SPaolo Bonzini fw_size = load_image_targphys(filename, 0, FW_MAX_SIZE); 222668fea5a0SThomas Huth if (fw_size <= 0) { 222768fea5a0SThomas Huth error_report("Could not load LPAR firmware '%s'", filename); 222853018216SPaolo Bonzini exit(1); 222953018216SPaolo Bonzini } 223053018216SPaolo Bonzini g_free(filename); 223153018216SPaolo Bonzini 223228e02042SDavid Gibson /* FIXME: Should register things through the MachineState's qdev 223328e02042SDavid Gibson * interface, this is a legacy from the sPAPREnvironment structure 223428e02042SDavid Gibson * which predated MachineState but had a similar function */ 22354be21d56SDavid Gibson vmstate_register(NULL, 0, &vmstate_spapr, spapr); 22364be21d56SDavid Gibson register_savevm_live(NULL, "spapr/htab", -1, 1, 22374be21d56SDavid Gibson &savevm_htab_handlers, spapr); 22384be21d56SDavid Gibson 223946503c2bSMichael Roth /* used by RTAS */ 224046503c2bSMichael Roth QTAILQ_INIT(&spapr->ccs_list); 224146503c2bSMichael Roth qemu_register_reset(spapr_ccs_reset_hook, spapr); 224246503c2bSMichael Roth 22435b2128d2SAlexander Graf qemu_register_boot_set(spapr_boot_set, spapr); 224442043e4fSLaurent Vivier 224542043e4fSLaurent Vivier /* to stop and start vmclock */ 224642043e4fSLaurent Vivier if (kvm_enabled()) { 224742043e4fSLaurent Vivier qemu_add_vm_change_state_handler(cpu_ppc_clock_vm_state_change, 224842043e4fSLaurent Vivier &spapr->tb); 224942043e4fSLaurent Vivier } 225053018216SPaolo Bonzini } 225153018216SPaolo Bonzini 2252135a129aSAneesh Kumar K.V static int spapr_kvm_type(const char *vm_type) 2253135a129aSAneesh Kumar K.V { 2254135a129aSAneesh Kumar K.V if (!vm_type) { 2255135a129aSAneesh Kumar K.V return 0; 2256135a129aSAneesh Kumar K.V } 2257135a129aSAneesh Kumar K.V 2258135a129aSAneesh Kumar K.V if (!strcmp(vm_type, "HV")) { 2259135a129aSAneesh Kumar K.V return 1; 2260135a129aSAneesh Kumar K.V } 2261135a129aSAneesh Kumar K.V 2262135a129aSAneesh Kumar K.V if (!strcmp(vm_type, "PR")) { 2263135a129aSAneesh Kumar K.V return 2; 2264135a129aSAneesh Kumar K.V } 2265135a129aSAneesh Kumar K.V 2266135a129aSAneesh Kumar K.V error_report("Unknown kvm-type specified '%s'", vm_type); 2267135a129aSAneesh Kumar K.V exit(1); 2268135a129aSAneesh Kumar K.V } 2269135a129aSAneesh Kumar K.V 227071461b0fSAlexey Kardashevskiy /* 2271627b84f4SGonglei * Implementation of an interface to adjust firmware path 227271461b0fSAlexey Kardashevskiy * for the bootindex property handling. 227371461b0fSAlexey Kardashevskiy */ 227471461b0fSAlexey Kardashevskiy static char *spapr_get_fw_dev_path(FWPathProvider *p, BusState *bus, 227571461b0fSAlexey Kardashevskiy DeviceState *dev) 227671461b0fSAlexey Kardashevskiy { 227771461b0fSAlexey Kardashevskiy #define CAST(type, obj, name) \ 227871461b0fSAlexey Kardashevskiy ((type *)object_dynamic_cast(OBJECT(obj), (name))) 227971461b0fSAlexey Kardashevskiy SCSIDevice *d = CAST(SCSIDevice, dev, TYPE_SCSI_DEVICE); 228071461b0fSAlexey Kardashevskiy sPAPRPHBState *phb = CAST(sPAPRPHBState, dev, TYPE_SPAPR_PCI_HOST_BRIDGE); 228171461b0fSAlexey Kardashevskiy 228271461b0fSAlexey Kardashevskiy if (d) { 228371461b0fSAlexey Kardashevskiy void *spapr = CAST(void, bus->parent, "spapr-vscsi"); 228471461b0fSAlexey Kardashevskiy VirtIOSCSI *virtio = CAST(VirtIOSCSI, bus->parent, TYPE_VIRTIO_SCSI); 228571461b0fSAlexey Kardashevskiy USBDevice *usb = CAST(USBDevice, bus->parent, TYPE_USB_DEVICE); 228671461b0fSAlexey Kardashevskiy 228771461b0fSAlexey Kardashevskiy if (spapr) { 228871461b0fSAlexey Kardashevskiy /* 228971461b0fSAlexey Kardashevskiy * Replace "channel@0/disk@0,0" with "disk@8000000000000000": 229071461b0fSAlexey Kardashevskiy * We use SRP luns of the form 8000 | (bus << 8) | (id << 5) | lun 229171461b0fSAlexey Kardashevskiy * in the top 16 bits of the 64-bit LUN 229271461b0fSAlexey Kardashevskiy */ 229371461b0fSAlexey Kardashevskiy unsigned id = 0x8000 | (d->id << 8) | d->lun; 229471461b0fSAlexey Kardashevskiy return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev), 229571461b0fSAlexey Kardashevskiy (uint64_t)id << 48); 229671461b0fSAlexey Kardashevskiy } else if (virtio) { 229771461b0fSAlexey Kardashevskiy /* 229871461b0fSAlexey Kardashevskiy * We use SRP luns of the form 01000000 | (target << 8) | lun 229971461b0fSAlexey Kardashevskiy * in the top 32 bits of the 64-bit LUN 230071461b0fSAlexey Kardashevskiy * Note: the quote above is from SLOF and it is wrong, 230171461b0fSAlexey Kardashevskiy * the actual binding is: 230271461b0fSAlexey Kardashevskiy * swap 0100 or 10 << or 20 << ( target lun-id -- srplun ) 230371461b0fSAlexey Kardashevskiy */ 230471461b0fSAlexey Kardashevskiy unsigned id = 0x1000000 | (d->id << 16) | d->lun; 230571461b0fSAlexey Kardashevskiy return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev), 230671461b0fSAlexey Kardashevskiy (uint64_t)id << 32); 230771461b0fSAlexey Kardashevskiy } else if (usb) { 230871461b0fSAlexey Kardashevskiy /* 230971461b0fSAlexey Kardashevskiy * We use SRP luns of the form 01000000 | (usb-port << 16) | lun 231071461b0fSAlexey Kardashevskiy * in the top 32 bits of the 64-bit LUN 231171461b0fSAlexey Kardashevskiy */ 231271461b0fSAlexey Kardashevskiy unsigned usb_port = atoi(usb->port->path); 231371461b0fSAlexey Kardashevskiy unsigned id = 0x1000000 | (usb_port << 16) | d->lun; 231471461b0fSAlexey Kardashevskiy return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev), 231571461b0fSAlexey Kardashevskiy (uint64_t)id << 32); 231671461b0fSAlexey Kardashevskiy } 231771461b0fSAlexey Kardashevskiy } 231871461b0fSAlexey Kardashevskiy 2319b99260ebSThomas Huth /* 2320b99260ebSThomas Huth * SLOF probes the USB devices, and if it recognizes that the device is a 2321b99260ebSThomas Huth * storage device, it changes its name to "storage" instead of "usb-host", 2322b99260ebSThomas Huth * and additionally adds a child node for the SCSI LUN, so the correct 2323b99260ebSThomas Huth * boot path in SLOF is something like .../storage@1/disk@xxx" instead. 2324b99260ebSThomas Huth */ 2325b99260ebSThomas Huth if (strcmp("usb-host", qdev_fw_name(dev)) == 0) { 2326b99260ebSThomas Huth USBDevice *usbdev = CAST(USBDevice, dev, TYPE_USB_DEVICE); 2327b99260ebSThomas Huth if (usb_host_dev_is_scsi_storage(usbdev)) { 2328b99260ebSThomas Huth return g_strdup_printf("storage@%s/disk", usbdev->port->path); 2329b99260ebSThomas Huth } 2330b99260ebSThomas Huth } 2331b99260ebSThomas Huth 233271461b0fSAlexey Kardashevskiy if (phb) { 233371461b0fSAlexey Kardashevskiy /* Replace "pci" with "pci@800000020000000" */ 233471461b0fSAlexey Kardashevskiy return g_strdup_printf("pci@%"PRIX64, phb->buid); 233571461b0fSAlexey Kardashevskiy } 233671461b0fSAlexey Kardashevskiy 233771461b0fSAlexey Kardashevskiy return NULL; 233871461b0fSAlexey Kardashevskiy } 233971461b0fSAlexey Kardashevskiy 234023825581SEduardo Habkost static char *spapr_get_kvm_type(Object *obj, Error **errp) 234123825581SEduardo Habkost { 234228e02042SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 234323825581SEduardo Habkost 234428e02042SDavid Gibson return g_strdup(spapr->kvm_type); 234523825581SEduardo Habkost } 234623825581SEduardo Habkost 234723825581SEduardo Habkost static void spapr_set_kvm_type(Object *obj, const char *value, Error **errp) 234823825581SEduardo Habkost { 234928e02042SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 235023825581SEduardo Habkost 235128e02042SDavid Gibson g_free(spapr->kvm_type); 235228e02042SDavid Gibson spapr->kvm_type = g_strdup(value); 235323825581SEduardo Habkost } 235423825581SEduardo Habkost 2355f6229214SMichael Roth static bool spapr_get_modern_hotplug_events(Object *obj, Error **errp) 2356f6229214SMichael Roth { 2357f6229214SMichael Roth sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 2358f6229214SMichael Roth 2359f6229214SMichael Roth return spapr->use_hotplug_event_source; 2360f6229214SMichael Roth } 2361f6229214SMichael Roth 2362f6229214SMichael Roth static void spapr_set_modern_hotplug_events(Object *obj, bool value, 2363f6229214SMichael Roth Error **errp) 2364f6229214SMichael Roth { 2365f6229214SMichael Roth sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 2366f6229214SMichael Roth 2367f6229214SMichael Roth spapr->use_hotplug_event_source = value; 2368f6229214SMichael Roth } 2369f6229214SMichael Roth 237023825581SEduardo Habkost static void spapr_machine_initfn(Object *obj) 237123825581SEduardo Habkost { 2372715c5407SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 2373715c5407SDavid Gibson 2374715c5407SDavid Gibson spapr->htab_fd = -1; 2375f6229214SMichael Roth spapr->use_hotplug_event_source = true; 237623825581SEduardo Habkost object_property_add_str(obj, "kvm-type", 237723825581SEduardo Habkost spapr_get_kvm_type, spapr_set_kvm_type, NULL); 237849d2e648SMarcel Apfelbaum object_property_set_description(obj, "kvm-type", 237949d2e648SMarcel Apfelbaum "Specifies the KVM virtualization mode (HV, PR)", 238049d2e648SMarcel Apfelbaum NULL); 2381f6229214SMichael Roth object_property_add_bool(obj, "modern-hotplug-events", 2382f6229214SMichael Roth spapr_get_modern_hotplug_events, 2383f6229214SMichael Roth spapr_set_modern_hotplug_events, 2384f6229214SMichael Roth NULL); 2385f6229214SMichael Roth object_property_set_description(obj, "modern-hotplug-events", 2386f6229214SMichael Roth "Use dedicated hotplug event mechanism in" 2387f6229214SMichael Roth " place of standard EPOW events when possible" 2388f6229214SMichael Roth " (required for memory hot-unplug support)", 2389f6229214SMichael Roth NULL); 239023825581SEduardo Habkost } 239123825581SEduardo Habkost 239287bbdd9cSDavid Gibson static void spapr_machine_finalizefn(Object *obj) 239387bbdd9cSDavid Gibson { 239487bbdd9cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 239587bbdd9cSDavid Gibson 239687bbdd9cSDavid Gibson g_free(spapr->kvm_type); 239787bbdd9cSDavid Gibson } 239887bbdd9cSDavid Gibson 23991c7ad77eSNicholas Piggin void spapr_do_system_reset_on_cpu(CPUState *cs, run_on_cpu_data arg) 240034316482SAlexey Kardashevskiy { 240134316482SAlexey Kardashevskiy cpu_synchronize_state(cs); 240234316482SAlexey Kardashevskiy ppc_cpu_do_system_reset(cs); 240334316482SAlexey Kardashevskiy } 240434316482SAlexey Kardashevskiy 240534316482SAlexey Kardashevskiy static void spapr_nmi(NMIState *n, int cpu_index, Error **errp) 240634316482SAlexey Kardashevskiy { 240734316482SAlexey Kardashevskiy CPUState *cs; 240834316482SAlexey Kardashevskiy 240934316482SAlexey Kardashevskiy CPU_FOREACH(cs) { 24101c7ad77eSNicholas Piggin async_run_on_cpu(cs, spapr_do_system_reset_on_cpu, RUN_ON_CPU_NULL); 241134316482SAlexey Kardashevskiy } 241234316482SAlexey Kardashevskiy } 241334316482SAlexey Kardashevskiy 241479b78a6bSMichael Roth static void spapr_add_lmbs(DeviceState *dev, uint64_t addr_start, uint64_t size, 241579b78a6bSMichael Roth uint32_t node, bool dedicated_hp_event_source, 241679b78a6bSMichael Roth Error **errp) 2417c20d332aSBharata B Rao { 2418c20d332aSBharata B Rao sPAPRDRConnector *drc; 2419c20d332aSBharata B Rao sPAPRDRConnectorClass *drck; 2420c20d332aSBharata B Rao uint32_t nr_lmbs = size/SPAPR_MEMORY_BLOCK_SIZE; 2421c20d332aSBharata B Rao int i, fdt_offset, fdt_size; 2422c20d332aSBharata B Rao void *fdt; 242379b78a6bSMichael Roth uint64_t addr = addr_start; 2424c20d332aSBharata B Rao 2425c20d332aSBharata B Rao for (i = 0; i < nr_lmbs; i++) { 2426c20d332aSBharata B Rao drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_LMB, 2427c20d332aSBharata B Rao addr/SPAPR_MEMORY_BLOCK_SIZE); 2428c20d332aSBharata B Rao g_assert(drc); 2429c20d332aSBharata B Rao 2430c20d332aSBharata B Rao fdt = create_device_tree(&fdt_size); 2431c20d332aSBharata B Rao fdt_offset = spapr_populate_memory_node(fdt, node, addr, 2432c20d332aSBharata B Rao SPAPR_MEMORY_BLOCK_SIZE); 2433c20d332aSBharata B Rao 2434c20d332aSBharata B Rao drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 2435c20d332aSBharata B Rao drck->attach(drc, dev, fdt, fdt_offset, !dev->hotplugged, errp); 2436c20d332aSBharata B Rao addr += SPAPR_MEMORY_BLOCK_SIZE; 24375c0139a8SMichael Roth if (!dev->hotplugged) { 24385c0139a8SMichael Roth /* guests expect coldplugged LMBs to be pre-allocated */ 24395c0139a8SMichael Roth drck->set_allocation_state(drc, SPAPR_DR_ALLOCATION_STATE_USABLE); 24405c0139a8SMichael Roth drck->set_isolation_state(drc, SPAPR_DR_ISOLATION_STATE_UNISOLATED); 24415c0139a8SMichael Roth } 2442c20d332aSBharata B Rao } 24435dd5238cSJianjun Duan /* send hotplug notification to the 24445dd5238cSJianjun Duan * guest only in case of hotplugged memory 24455dd5238cSJianjun Duan */ 24465dd5238cSJianjun Duan if (dev->hotplugged) { 244779b78a6bSMichael Roth if (dedicated_hp_event_source) { 244879b78a6bSMichael Roth drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_LMB, 244979b78a6bSMichael Roth addr_start / SPAPR_MEMORY_BLOCK_SIZE); 245079b78a6bSMichael Roth drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 245179b78a6bSMichael Roth spapr_hotplug_req_add_by_count_indexed(SPAPR_DR_CONNECTOR_TYPE_LMB, 245279b78a6bSMichael Roth nr_lmbs, 245379b78a6bSMichael Roth drck->get_index(drc)); 245479b78a6bSMichael Roth } else { 245579b78a6bSMichael Roth spapr_hotplug_req_add_by_count(SPAPR_DR_CONNECTOR_TYPE_LMB, 245679b78a6bSMichael Roth nr_lmbs); 245779b78a6bSMichael Roth } 2458c20d332aSBharata B Rao } 24595dd5238cSJianjun Duan } 2460c20d332aSBharata B Rao 2461c20d332aSBharata B Rao static void spapr_memory_plug(HotplugHandler *hotplug_dev, DeviceState *dev, 2462c20d332aSBharata B Rao uint32_t node, Error **errp) 2463c20d332aSBharata B Rao { 2464c20d332aSBharata B Rao Error *local_err = NULL; 2465c20d332aSBharata B Rao sPAPRMachineState *ms = SPAPR_MACHINE(hotplug_dev); 2466c20d332aSBharata B Rao PCDIMMDevice *dimm = PC_DIMM(dev); 2467c20d332aSBharata B Rao PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); 2468c20d332aSBharata B Rao MemoryRegion *mr = ddc->get_memory_region(dimm); 2469c20d332aSBharata B Rao uint64_t align = memory_region_get_alignment(mr); 2470c20d332aSBharata B Rao uint64_t size = memory_region_size(mr); 2471c20d332aSBharata B Rao uint64_t addr; 2472df587133SThomas Huth char *mem_dev; 2473c20d332aSBharata B Rao 2474c20d332aSBharata B Rao if (size % SPAPR_MEMORY_BLOCK_SIZE) { 2475c20d332aSBharata B Rao error_setg(&local_err, "Hotplugged memory size must be a multiple of " 2476c20d332aSBharata B Rao "%lld MB", SPAPR_MEMORY_BLOCK_SIZE/M_BYTE); 2477c20d332aSBharata B Rao goto out; 2478c20d332aSBharata B Rao } 2479c20d332aSBharata B Rao 2480df587133SThomas Huth mem_dev = object_property_get_str(OBJECT(dimm), PC_DIMM_MEMDEV_PROP, NULL); 2481df587133SThomas Huth if (mem_dev && !kvmppc_is_mem_backend_page_size_ok(mem_dev)) { 2482df587133SThomas Huth error_setg(&local_err, "Memory backend has bad page size. " 2483df587133SThomas Huth "Use 'memory-backend-file' with correct mem-path."); 2484df587133SThomas Huth goto out; 2485df587133SThomas Huth } 2486df587133SThomas Huth 2487d6a9b0b8SMichael S. Tsirkin pc_dimm_memory_plug(dev, &ms->hotplug_memory, mr, align, &local_err); 2488c20d332aSBharata B Rao if (local_err) { 2489c20d332aSBharata B Rao goto out; 2490c20d332aSBharata B Rao } 2491c20d332aSBharata B Rao 2492c20d332aSBharata B Rao addr = object_property_get_int(OBJECT(dimm), PC_DIMM_ADDR_PROP, &local_err); 2493c20d332aSBharata B Rao if (local_err) { 2494c20d332aSBharata B Rao pc_dimm_memory_unplug(dev, &ms->hotplug_memory, mr); 2495c20d332aSBharata B Rao goto out; 2496c20d332aSBharata B Rao } 2497c20d332aSBharata B Rao 249879b78a6bSMichael Roth spapr_add_lmbs(dev, addr, size, node, 249979b78a6bSMichael Roth spapr_ovec_test(ms->ov5_cas, OV5_HP_EVT), 250079b78a6bSMichael Roth &error_abort); 2501c20d332aSBharata B Rao 2502c20d332aSBharata B Rao out: 2503c20d332aSBharata B Rao error_propagate(errp, local_err); 2504c20d332aSBharata B Rao } 2505c20d332aSBharata B Rao 2506cf632463SBharata B Rao typedef struct sPAPRDIMMState { 2507cf632463SBharata B Rao uint32_t nr_lmbs; 2508cf632463SBharata B Rao } sPAPRDIMMState; 2509cf632463SBharata B Rao 2510cf632463SBharata B Rao static void spapr_lmb_release(DeviceState *dev, void *opaque) 2511cf632463SBharata B Rao { 2512cf632463SBharata B Rao sPAPRDIMMState *ds = (sPAPRDIMMState *)opaque; 2513cf632463SBharata B Rao HotplugHandler *hotplug_ctrl; 2514cf632463SBharata B Rao 2515cf632463SBharata B Rao if (--ds->nr_lmbs) { 2516cf632463SBharata B Rao return; 2517cf632463SBharata B Rao } 2518cf632463SBharata B Rao 2519cf632463SBharata B Rao g_free(ds); 2520cf632463SBharata B Rao 2521cf632463SBharata B Rao /* 2522cf632463SBharata B Rao * Now that all the LMBs have been removed by the guest, call the 2523cf632463SBharata B Rao * pc-dimm unplug handler to cleanup up the pc-dimm device. 2524cf632463SBharata B Rao */ 2525cf632463SBharata B Rao hotplug_ctrl = qdev_get_hotplug_handler(dev); 2526cf632463SBharata B Rao hotplug_handler_unplug(hotplug_ctrl, dev, &error_abort); 2527cf632463SBharata B Rao } 2528cf632463SBharata B Rao 2529cf632463SBharata B Rao static void spapr_del_lmbs(DeviceState *dev, uint64_t addr_start, uint64_t size, 2530cf632463SBharata B Rao Error **errp) 2531cf632463SBharata B Rao { 2532cf632463SBharata B Rao sPAPRDRConnector *drc; 2533cf632463SBharata B Rao sPAPRDRConnectorClass *drck; 2534cf632463SBharata B Rao uint32_t nr_lmbs = size / SPAPR_MEMORY_BLOCK_SIZE; 2535cf632463SBharata B Rao int i; 2536cf632463SBharata B Rao sPAPRDIMMState *ds = g_malloc0(sizeof(sPAPRDIMMState)); 2537cf632463SBharata B Rao uint64_t addr = addr_start; 2538cf632463SBharata B Rao 2539cf632463SBharata B Rao ds->nr_lmbs = nr_lmbs; 2540cf632463SBharata B Rao for (i = 0; i < nr_lmbs; i++) { 2541cf632463SBharata B Rao drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_LMB, 2542cf632463SBharata B Rao addr / SPAPR_MEMORY_BLOCK_SIZE); 2543cf632463SBharata B Rao g_assert(drc); 2544cf632463SBharata B Rao 2545cf632463SBharata B Rao drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 2546cf632463SBharata B Rao drck->detach(drc, dev, spapr_lmb_release, ds, errp); 2547cf632463SBharata B Rao addr += SPAPR_MEMORY_BLOCK_SIZE; 2548cf632463SBharata B Rao } 2549cf632463SBharata B Rao 2550cf632463SBharata B Rao drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_LMB, 2551cf632463SBharata B Rao addr_start / SPAPR_MEMORY_BLOCK_SIZE); 2552cf632463SBharata B Rao drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 2553cf632463SBharata B Rao spapr_hotplug_req_remove_by_count_indexed(SPAPR_DR_CONNECTOR_TYPE_LMB, 2554cf632463SBharata B Rao nr_lmbs, 2555cf632463SBharata B Rao drck->get_index(drc)); 2556cf632463SBharata B Rao } 2557cf632463SBharata B Rao 2558cf632463SBharata B Rao static void spapr_memory_unplug(HotplugHandler *hotplug_dev, DeviceState *dev, 2559cf632463SBharata B Rao Error **errp) 2560cf632463SBharata B Rao { 2561cf632463SBharata B Rao sPAPRMachineState *ms = SPAPR_MACHINE(hotplug_dev); 2562cf632463SBharata B Rao PCDIMMDevice *dimm = PC_DIMM(dev); 2563cf632463SBharata B Rao PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); 2564cf632463SBharata B Rao MemoryRegion *mr = ddc->get_memory_region(dimm); 2565cf632463SBharata B Rao 2566cf632463SBharata B Rao pc_dimm_memory_unplug(dev, &ms->hotplug_memory, mr); 2567cf632463SBharata B Rao object_unparent(OBJECT(dev)); 2568cf632463SBharata B Rao } 2569cf632463SBharata B Rao 2570cf632463SBharata B Rao static void spapr_memory_unplug_request(HotplugHandler *hotplug_dev, 2571cf632463SBharata B Rao DeviceState *dev, Error **errp) 2572cf632463SBharata B Rao { 2573cf632463SBharata B Rao Error *local_err = NULL; 2574cf632463SBharata B Rao PCDIMMDevice *dimm = PC_DIMM(dev); 2575cf632463SBharata B Rao PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); 2576cf632463SBharata B Rao MemoryRegion *mr = ddc->get_memory_region(dimm); 2577cf632463SBharata B Rao uint64_t size = memory_region_size(mr); 2578cf632463SBharata B Rao uint64_t addr; 2579cf632463SBharata B Rao 2580cf632463SBharata B Rao addr = object_property_get_int(OBJECT(dimm), PC_DIMM_ADDR_PROP, &local_err); 2581cf632463SBharata B Rao if (local_err) { 2582cf632463SBharata B Rao goto out; 2583cf632463SBharata B Rao } 2584cf632463SBharata B Rao 2585cf632463SBharata B Rao spapr_del_lmbs(dev, addr, size, &error_abort); 2586cf632463SBharata B Rao out: 2587cf632463SBharata B Rao error_propagate(errp, local_err); 2588cf632463SBharata B Rao } 2589cf632463SBharata B Rao 2590af81cf32SBharata B Rao void *spapr_populate_hotplug_cpu_dt(CPUState *cs, int *fdt_offset, 2591af81cf32SBharata B Rao sPAPRMachineState *spapr) 2592af81cf32SBharata B Rao { 2593af81cf32SBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(cs); 2594af81cf32SBharata B Rao DeviceClass *dc = DEVICE_GET_CLASS(cs); 2595af81cf32SBharata B Rao int id = ppc_get_vcpu_dt_id(cpu); 2596af81cf32SBharata B Rao void *fdt; 2597af81cf32SBharata B Rao int offset, fdt_size; 2598af81cf32SBharata B Rao char *nodename; 2599af81cf32SBharata B Rao 2600af81cf32SBharata B Rao fdt = create_device_tree(&fdt_size); 2601af81cf32SBharata B Rao nodename = g_strdup_printf("%s@%x", dc->fw_name, id); 2602af81cf32SBharata B Rao offset = fdt_add_subnode(fdt, 0, nodename); 2603af81cf32SBharata B Rao 2604af81cf32SBharata B Rao spapr_populate_cpu_dt(cs, fdt, offset, spapr); 2605af81cf32SBharata B Rao g_free(nodename); 2606af81cf32SBharata B Rao 2607af81cf32SBharata B Rao *fdt_offset = offset; 2608af81cf32SBharata B Rao return fdt; 2609af81cf32SBharata B Rao } 2610af81cf32SBharata B Rao 2611115debf2SIgor Mammedov static void spapr_core_unplug(HotplugHandler *hotplug_dev, DeviceState *dev, 2612115debf2SIgor Mammedov Error **errp) 2613ff9006ddSIgor Mammedov { 2614535455fdSIgor Mammedov MachineState *ms = MACHINE(qdev_get_machine()); 2615ff9006ddSIgor Mammedov CPUCore *cc = CPU_CORE(dev); 2616535455fdSIgor Mammedov CPUArchId *core_slot = spapr_find_cpu_slot(ms, cc->core_id, NULL); 2617ff9006ddSIgor Mammedov 2618535455fdSIgor Mammedov core_slot->cpu = NULL; 2619ff9006ddSIgor Mammedov object_unparent(OBJECT(dev)); 2620ff9006ddSIgor Mammedov } 2621ff9006ddSIgor Mammedov 2622115debf2SIgor Mammedov static void spapr_core_release(DeviceState *dev, void *opaque) 2623115debf2SIgor Mammedov { 2624115debf2SIgor Mammedov HotplugHandler *hotplug_ctrl; 2625115debf2SIgor Mammedov 2626115debf2SIgor Mammedov hotplug_ctrl = qdev_get_hotplug_handler(dev); 2627115debf2SIgor Mammedov hotplug_handler_unplug(hotplug_ctrl, dev, &error_abort); 2628115debf2SIgor Mammedov } 2629115debf2SIgor Mammedov 2630115debf2SIgor Mammedov static 2631115debf2SIgor Mammedov void spapr_core_unplug_request(HotplugHandler *hotplug_dev, DeviceState *dev, 2632ff9006ddSIgor Mammedov Error **errp) 2633ff9006ddSIgor Mammedov { 2634535455fdSIgor Mammedov int index; 2635535455fdSIgor Mammedov sPAPRDRConnector *drc; 2636ff9006ddSIgor Mammedov sPAPRDRConnectorClass *drck; 2637ff9006ddSIgor Mammedov Error *local_err = NULL; 2638535455fdSIgor Mammedov CPUCore *cc = CPU_CORE(dev); 2639535455fdSIgor Mammedov int smt = kvmppc_smt_threads(); 2640ff9006ddSIgor Mammedov 2641535455fdSIgor Mammedov if (!spapr_find_cpu_slot(MACHINE(hotplug_dev), cc->core_id, &index)) { 2642535455fdSIgor Mammedov error_setg(errp, "Unable to find CPU core with core-id: %d", 2643535455fdSIgor Mammedov cc->core_id); 2644535455fdSIgor Mammedov return; 2645535455fdSIgor Mammedov } 2646ff9006ddSIgor Mammedov if (index == 0) { 2647ff9006ddSIgor Mammedov error_setg(errp, "Boot CPU core may not be unplugged"); 2648ff9006ddSIgor Mammedov return; 2649ff9006ddSIgor Mammedov } 2650ff9006ddSIgor Mammedov 2651535455fdSIgor Mammedov drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_CPU, index * smt); 2652ff9006ddSIgor Mammedov g_assert(drc); 2653ff9006ddSIgor Mammedov 2654ff9006ddSIgor Mammedov drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 2655ff9006ddSIgor Mammedov drck->detach(drc, dev, spapr_core_release, NULL, &local_err); 2656ff9006ddSIgor Mammedov if (local_err) { 2657ff9006ddSIgor Mammedov error_propagate(errp, local_err); 2658ff9006ddSIgor Mammedov return; 2659ff9006ddSIgor Mammedov } 2660ff9006ddSIgor Mammedov 2661ff9006ddSIgor Mammedov spapr_hotplug_req_remove_by_index(drc); 2662ff9006ddSIgor Mammedov } 2663ff9006ddSIgor Mammedov 2664ff9006ddSIgor Mammedov static void spapr_core_plug(HotplugHandler *hotplug_dev, DeviceState *dev, 2665ff9006ddSIgor Mammedov Error **errp) 2666ff9006ddSIgor Mammedov { 2667ff9006ddSIgor Mammedov sPAPRMachineState *spapr = SPAPR_MACHINE(OBJECT(hotplug_dev)); 2668ff9006ddSIgor Mammedov MachineClass *mc = MACHINE_GET_CLASS(spapr); 2669ff9006ddSIgor Mammedov sPAPRCPUCore *core = SPAPR_CPU_CORE(OBJECT(dev)); 2670ff9006ddSIgor Mammedov CPUCore *cc = CPU_CORE(dev); 2671ff9006ddSIgor Mammedov CPUState *cs = CPU(core->threads); 2672ff9006ddSIgor Mammedov sPAPRDRConnector *drc; 2673ff9006ddSIgor Mammedov Error *local_err = NULL; 2674ff9006ddSIgor Mammedov void *fdt = NULL; 2675ff9006ddSIgor Mammedov int fdt_offset = 0; 2676ff9006ddSIgor Mammedov int smt = kvmppc_smt_threads(); 2677535455fdSIgor Mammedov CPUArchId *core_slot; 2678535455fdSIgor Mammedov int index; 2679ff9006ddSIgor Mammedov 2680535455fdSIgor Mammedov core_slot = spapr_find_cpu_slot(MACHINE(hotplug_dev), cc->core_id, &index); 2681535455fdSIgor Mammedov if (!core_slot) { 2682535455fdSIgor Mammedov error_setg(errp, "Unable to find CPU core with core-id: %d", 2683535455fdSIgor Mammedov cc->core_id); 2684535455fdSIgor Mammedov return; 2685535455fdSIgor Mammedov } 2686ff9006ddSIgor Mammedov drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_CPU, index * smt); 2687ff9006ddSIgor Mammedov 2688c5514d0eSIgor Mammedov g_assert(drc || !mc->has_hotpluggable_cpus); 2689ff9006ddSIgor Mammedov 2690ff9006ddSIgor Mammedov /* 2691ff9006ddSIgor Mammedov * Setup CPU DT entries only for hotplugged CPUs. For boot time or 2692ff9006ddSIgor Mammedov * coldplugged CPUs DT entries are setup in spapr_build_fdt(). 2693ff9006ddSIgor Mammedov */ 2694ff9006ddSIgor Mammedov if (dev->hotplugged) { 2695ff9006ddSIgor Mammedov fdt = spapr_populate_hotplug_cpu_dt(cs, &fdt_offset, spapr); 2696ff9006ddSIgor Mammedov } 2697ff9006ddSIgor Mammedov 2698ff9006ddSIgor Mammedov if (drc) { 2699ff9006ddSIgor Mammedov sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 2700ff9006ddSIgor Mammedov drck->attach(drc, dev, fdt, fdt_offset, !dev->hotplugged, &local_err); 2701ff9006ddSIgor Mammedov if (local_err) { 2702ff9006ddSIgor Mammedov g_free(fdt); 2703ff9006ddSIgor Mammedov error_propagate(errp, local_err); 2704ff9006ddSIgor Mammedov return; 2705ff9006ddSIgor Mammedov } 2706ff9006ddSIgor Mammedov } 2707ff9006ddSIgor Mammedov 2708ff9006ddSIgor Mammedov if (dev->hotplugged) { 2709ff9006ddSIgor Mammedov /* 2710ff9006ddSIgor Mammedov * Send hotplug notification interrupt to the guest only in case 2711ff9006ddSIgor Mammedov * of hotplugged CPUs. 2712ff9006ddSIgor Mammedov */ 2713ff9006ddSIgor Mammedov spapr_hotplug_req_add_by_index(drc); 2714ff9006ddSIgor Mammedov } else { 2715ff9006ddSIgor Mammedov /* 2716ff9006ddSIgor Mammedov * Set the right DRC states for cold plugged CPU. 2717ff9006ddSIgor Mammedov */ 2718ff9006ddSIgor Mammedov if (drc) { 2719ff9006ddSIgor Mammedov sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 2720ff9006ddSIgor Mammedov drck->set_allocation_state(drc, SPAPR_DR_ALLOCATION_STATE_USABLE); 2721ff9006ddSIgor Mammedov drck->set_isolation_state(drc, SPAPR_DR_ISOLATION_STATE_UNISOLATED); 2722ff9006ddSIgor Mammedov } 2723ff9006ddSIgor Mammedov } 2724535455fdSIgor Mammedov core_slot->cpu = OBJECT(dev); 2725ff9006ddSIgor Mammedov } 2726ff9006ddSIgor Mammedov 2727ff9006ddSIgor Mammedov static void spapr_core_pre_plug(HotplugHandler *hotplug_dev, DeviceState *dev, 2728ff9006ddSIgor Mammedov Error **errp) 2729ff9006ddSIgor Mammedov { 2730ff9006ddSIgor Mammedov MachineState *machine = MACHINE(OBJECT(hotplug_dev)); 2731ff9006ddSIgor Mammedov MachineClass *mc = MACHINE_GET_CLASS(hotplug_dev); 2732ff9006ddSIgor Mammedov Error *local_err = NULL; 2733ff9006ddSIgor Mammedov CPUCore *cc = CPU_CORE(dev); 2734ff9006ddSIgor Mammedov char *base_core_type = spapr_get_cpu_core_type(machine->cpu_model); 2735ff9006ddSIgor Mammedov const char *type = object_get_typename(OBJECT(dev)); 2736535455fdSIgor Mammedov CPUArchId *core_slot; 2737535455fdSIgor Mammedov int index; 2738ff9006ddSIgor Mammedov 2739c5514d0eSIgor Mammedov if (dev->hotplugged && !mc->has_hotpluggable_cpus) { 2740ff9006ddSIgor Mammedov error_setg(&local_err, "CPU hotplug not supported for this machine"); 2741ff9006ddSIgor Mammedov goto out; 2742ff9006ddSIgor Mammedov } 2743ff9006ddSIgor Mammedov 2744ff9006ddSIgor Mammedov if (strcmp(base_core_type, type)) { 2745ff9006ddSIgor Mammedov error_setg(&local_err, "CPU core type should be %s", base_core_type); 2746ff9006ddSIgor Mammedov goto out; 2747ff9006ddSIgor Mammedov } 2748ff9006ddSIgor Mammedov 2749ff9006ddSIgor Mammedov if (cc->core_id % smp_threads) { 2750ff9006ddSIgor Mammedov error_setg(&local_err, "invalid core id %d", cc->core_id); 2751ff9006ddSIgor Mammedov goto out; 2752ff9006ddSIgor Mammedov } 2753ff9006ddSIgor Mammedov 2754535455fdSIgor Mammedov core_slot = spapr_find_cpu_slot(MACHINE(hotplug_dev), cc->core_id, &index); 2755535455fdSIgor Mammedov if (!core_slot) { 2756ff9006ddSIgor Mammedov error_setg(&local_err, "core id %d out of range", cc->core_id); 2757ff9006ddSIgor Mammedov goto out; 2758ff9006ddSIgor Mammedov } 2759ff9006ddSIgor Mammedov 2760535455fdSIgor Mammedov if (core_slot->cpu) { 2761ff9006ddSIgor Mammedov error_setg(&local_err, "core %d already populated", cc->core_id); 2762ff9006ddSIgor Mammedov goto out; 2763ff9006ddSIgor Mammedov } 2764ff9006ddSIgor Mammedov 2765ff9006ddSIgor Mammedov out: 2766ff9006ddSIgor Mammedov g_free(base_core_type); 2767ff9006ddSIgor Mammedov error_propagate(errp, local_err); 2768ff9006ddSIgor Mammedov } 2769ff9006ddSIgor Mammedov 2770c20d332aSBharata B Rao static void spapr_machine_device_plug(HotplugHandler *hotplug_dev, 2771c20d332aSBharata B Rao DeviceState *dev, Error **errp) 2772c20d332aSBharata B Rao { 2773c20d332aSBharata B Rao sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(qdev_get_machine()); 2774c20d332aSBharata B Rao 2775c20d332aSBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { 2776b556854bSBharata B Rao int node; 2777c20d332aSBharata B Rao 2778c20d332aSBharata B Rao if (!smc->dr_lmb_enabled) { 2779c20d332aSBharata B Rao error_setg(errp, "Memory hotplug not supported for this machine"); 2780c20d332aSBharata B Rao return; 2781c20d332aSBharata B Rao } 2782c20d332aSBharata B Rao node = object_property_get_int(OBJECT(dev), PC_DIMM_NODE_PROP, errp); 2783c20d332aSBharata B Rao if (*errp) { 2784c20d332aSBharata B Rao return; 2785c20d332aSBharata B Rao } 27861a5512bbSGonglei if (node < 0 || node >= MAX_NODES) { 27871a5512bbSGonglei error_setg(errp, "Invaild node %d", node); 27881a5512bbSGonglei return; 27891a5512bbSGonglei } 2790c20d332aSBharata B Rao 2791b556854bSBharata B Rao /* 2792b556854bSBharata B Rao * Currently PowerPC kernel doesn't allow hot-adding memory to 2793b556854bSBharata B Rao * memory-less node, but instead will silently add the memory 2794b556854bSBharata B Rao * to the first node that has some memory. This causes two 2795b556854bSBharata B Rao * unexpected behaviours for the user. 2796b556854bSBharata B Rao * 2797b556854bSBharata B Rao * - Memory gets hotplugged to a different node than what the user 2798b556854bSBharata B Rao * specified. 2799b556854bSBharata B Rao * - Since pc-dimm subsystem in QEMU still thinks that memory belongs 2800b556854bSBharata B Rao * to memory-less node, a reboot will set things accordingly 2801b556854bSBharata B Rao * and the previously hotplugged memory now ends in the right node. 2802b556854bSBharata B Rao * This appears as if some memory moved from one node to another. 2803b556854bSBharata B Rao * 2804b556854bSBharata B Rao * So until kernel starts supporting memory hotplug to memory-less 2805b556854bSBharata B Rao * nodes, just prevent such attempts upfront in QEMU. 2806b556854bSBharata B Rao */ 2807b556854bSBharata B Rao if (nb_numa_nodes && !numa_info[node].node_mem) { 2808b556854bSBharata B Rao error_setg(errp, "Can't hotplug memory to memory-less node %d", 2809b556854bSBharata B Rao node); 2810b556854bSBharata B Rao return; 2811b556854bSBharata B Rao } 2812b556854bSBharata B Rao 2813c20d332aSBharata B Rao spapr_memory_plug(hotplug_dev, dev, node, errp); 2814af81cf32SBharata B Rao } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 2815af81cf32SBharata B Rao spapr_core_plug(hotplug_dev, dev, errp); 2816c20d332aSBharata B Rao } 2817c20d332aSBharata B Rao } 2818c20d332aSBharata B Rao 2819c20d332aSBharata B Rao static void spapr_machine_device_unplug(HotplugHandler *hotplug_dev, 2820c20d332aSBharata B Rao DeviceState *dev, Error **errp) 2821c20d332aSBharata B Rao { 2822cf632463SBharata B Rao sPAPRMachineState *sms = SPAPR_MACHINE(qdev_get_machine()); 28233c0c47e3SDavid Gibson MachineClass *mc = MACHINE_GET_CLASS(qdev_get_machine()); 28246f4b5c3eSBharata B Rao 2825c20d332aSBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { 2826cf632463SBharata B Rao if (spapr_ovec_test(sms->ov5_cas, OV5_HP_EVT)) { 2827cf632463SBharata B Rao spapr_memory_unplug(hotplug_dev, dev, errp); 2828cf632463SBharata B Rao } else { 2829cf632463SBharata B Rao error_setg(errp, "Memory hot unplug not supported for this guest"); 2830cf632463SBharata B Rao } 2831cf632463SBharata B Rao } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 2832c5514d0eSIgor Mammedov if (!mc->has_hotpluggable_cpus) { 2833cf632463SBharata B Rao error_setg(errp, "CPU hot unplug not supported on this machine"); 2834cf632463SBharata B Rao return; 2835cf632463SBharata B Rao } 2836cf632463SBharata B Rao spapr_core_unplug(hotplug_dev, dev, errp); 2837cf632463SBharata B Rao } 2838cf632463SBharata B Rao } 2839cf632463SBharata B Rao 2840cf632463SBharata B Rao static void spapr_machine_device_unplug_request(HotplugHandler *hotplug_dev, 2841cf632463SBharata B Rao DeviceState *dev, Error **errp) 2842cf632463SBharata B Rao { 2843cf632463SBharata B Rao sPAPRMachineState *sms = SPAPR_MACHINE(qdev_get_machine()); 2844cf632463SBharata B Rao MachineClass *mc = MACHINE_GET_CLASS(qdev_get_machine()); 2845cf632463SBharata B Rao 2846cf632463SBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { 2847cf632463SBharata B Rao if (spapr_ovec_test(sms->ov5_cas, OV5_HP_EVT)) { 2848cf632463SBharata B Rao spapr_memory_unplug_request(hotplug_dev, dev, errp); 2849cf632463SBharata B Rao } else { 2850cf632463SBharata B Rao /* NOTE: this means there is a window after guest reset, prior to 2851cf632463SBharata B Rao * CAS negotiation, where unplug requests will fail due to the 2852cf632463SBharata B Rao * capability not being detected yet. This is a bit different than 2853cf632463SBharata B Rao * the case with PCI unplug, where the events will be queued and 2854cf632463SBharata B Rao * eventually handled by the guest after boot 2855cf632463SBharata B Rao */ 2856cf632463SBharata B Rao error_setg(errp, "Memory hot unplug not supported for this guest"); 2857cf632463SBharata B Rao } 28586f4b5c3eSBharata B Rao } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 2859c5514d0eSIgor Mammedov if (!mc->has_hotpluggable_cpus) { 28606f4b5c3eSBharata B Rao error_setg(errp, "CPU hot unplug not supported on this machine"); 28616f4b5c3eSBharata B Rao return; 28626f4b5c3eSBharata B Rao } 2863115debf2SIgor Mammedov spapr_core_unplug_request(hotplug_dev, dev, errp); 2864c20d332aSBharata B Rao } 2865c20d332aSBharata B Rao } 2866c20d332aSBharata B Rao 286794a94e4cSBharata B Rao static void spapr_machine_device_pre_plug(HotplugHandler *hotplug_dev, 286894a94e4cSBharata B Rao DeviceState *dev, Error **errp) 286994a94e4cSBharata B Rao { 287094a94e4cSBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 287194a94e4cSBharata B Rao spapr_core_pre_plug(hotplug_dev, dev, errp); 287294a94e4cSBharata B Rao } 287394a94e4cSBharata B Rao } 287494a94e4cSBharata B Rao 28757ebaf795SBharata B Rao static HotplugHandler *spapr_get_hotplug_handler(MachineState *machine, 2876c20d332aSBharata B Rao DeviceState *dev) 2877c20d332aSBharata B Rao { 287894a94e4cSBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM) || 287994a94e4cSBharata B Rao object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 2880c20d332aSBharata B Rao return HOTPLUG_HANDLER(machine); 2881c20d332aSBharata B Rao } 2882c20d332aSBharata B Rao return NULL; 2883c20d332aSBharata B Rao } 2884c20d332aSBharata B Rao 288520bb648dSDavid Gibson static unsigned spapr_cpu_index_to_socket_id(unsigned cpu_index) 288620bb648dSDavid Gibson { 288720bb648dSDavid Gibson /* Allocate to NUMA nodes on a "socket" basis (not that concept of 288820bb648dSDavid Gibson * socket means much for the paravirtualized PAPR platform) */ 288920bb648dSDavid Gibson return cpu_index / smp_threads / smp_cores; 289020bb648dSDavid Gibson } 289120bb648dSDavid Gibson 2892535455fdSIgor Mammedov static const CPUArchIdList *spapr_possible_cpu_arch_ids(MachineState *machine) 2893535455fdSIgor Mammedov { 2894535455fdSIgor Mammedov int i; 2895535455fdSIgor Mammedov int spapr_max_cores = max_cpus / smp_threads; 2896535455fdSIgor Mammedov MachineClass *mc = MACHINE_GET_CLASS(machine); 2897535455fdSIgor Mammedov 2898c5514d0eSIgor Mammedov if (!mc->has_hotpluggable_cpus) { 2899535455fdSIgor Mammedov spapr_max_cores = QEMU_ALIGN_UP(smp_cpus, smp_threads) / smp_threads; 2900535455fdSIgor Mammedov } 2901535455fdSIgor Mammedov if (machine->possible_cpus) { 2902535455fdSIgor Mammedov assert(machine->possible_cpus->len == spapr_max_cores); 2903535455fdSIgor Mammedov return machine->possible_cpus; 2904535455fdSIgor Mammedov } 2905535455fdSIgor Mammedov 2906535455fdSIgor Mammedov machine->possible_cpus = g_malloc0(sizeof(CPUArchIdList) + 2907535455fdSIgor Mammedov sizeof(CPUArchId) * spapr_max_cores); 2908535455fdSIgor Mammedov machine->possible_cpus->len = spapr_max_cores; 2909535455fdSIgor Mammedov for (i = 0; i < machine->possible_cpus->len; i++) { 2910535455fdSIgor Mammedov int core_id = i * smp_threads; 2911535455fdSIgor Mammedov 2912f2d672c2SIgor Mammedov machine->possible_cpus->cpus[i].vcpus_count = smp_threads; 2913535455fdSIgor Mammedov machine->possible_cpus->cpus[i].arch_id = core_id; 2914535455fdSIgor Mammedov machine->possible_cpus->cpus[i].props.has_core_id = true; 2915535455fdSIgor Mammedov machine->possible_cpus->cpus[i].props.core_id = core_id; 2916535455fdSIgor Mammedov /* TODO: add 'has_node/node' here to describe 2917535455fdSIgor Mammedov to which node core belongs */ 2918535455fdSIgor Mammedov } 2919535455fdSIgor Mammedov return machine->possible_cpus; 2920535455fdSIgor Mammedov } 2921535455fdSIgor Mammedov 29226737d9adSDavid Gibson static void spapr_phb_placement(sPAPRMachineState *spapr, uint32_t index, 2923daa23699SDavid Gibson uint64_t *buid, hwaddr *pio, 2924daa23699SDavid Gibson hwaddr *mmio32, hwaddr *mmio64, 29256737d9adSDavid Gibson unsigned n_dma, uint32_t *liobns, Error **errp) 29266737d9adSDavid Gibson { 2927357d1e3bSDavid Gibson /* 2928357d1e3bSDavid Gibson * New-style PHB window placement. 2929357d1e3bSDavid Gibson * 2930357d1e3bSDavid Gibson * Goals: Gives large (1TiB), naturally aligned 64-bit MMIO window 2931357d1e3bSDavid Gibson * for each PHB, in addition to 2GiB 32-bit MMIO and 64kiB PIO 2932357d1e3bSDavid Gibson * windows. 2933357d1e3bSDavid Gibson * 2934357d1e3bSDavid Gibson * Some guest kernels can't work with MMIO windows above 1<<46 2935357d1e3bSDavid Gibson * (64TiB), so we place up to 31 PHBs in the area 32TiB..64TiB 2936357d1e3bSDavid Gibson * 2937357d1e3bSDavid Gibson * 32TiB..(33TiB+1984kiB) contains the 64kiB PIO windows for each 2938357d1e3bSDavid Gibson * PHB stacked together. (32TiB+2GiB)..(32TiB+64GiB) contains the 2939357d1e3bSDavid Gibson * 2GiB 32-bit MMIO windows for each PHB. Then 33..64TiB has the 2940357d1e3bSDavid Gibson * 1TiB 64-bit MMIO windows for each PHB. 2941357d1e3bSDavid Gibson */ 29426737d9adSDavid Gibson const uint64_t base_buid = 0x800000020000000ULL; 294325e6a118SMichael S. Tsirkin #define SPAPR_MAX_PHBS ((SPAPR_PCI_LIMIT - SPAPR_PCI_BASE) / \ 294425e6a118SMichael S. Tsirkin SPAPR_PCI_MEM64_WIN_SIZE - 1) 29456737d9adSDavid Gibson int i; 29466737d9adSDavid Gibson 2947357d1e3bSDavid Gibson /* Sanity check natural alignments */ 2948357d1e3bSDavid Gibson QEMU_BUILD_BUG_ON((SPAPR_PCI_BASE % SPAPR_PCI_MEM64_WIN_SIZE) != 0); 2949357d1e3bSDavid Gibson QEMU_BUILD_BUG_ON((SPAPR_PCI_LIMIT % SPAPR_PCI_MEM64_WIN_SIZE) != 0); 2950357d1e3bSDavid Gibson QEMU_BUILD_BUG_ON((SPAPR_PCI_MEM64_WIN_SIZE % SPAPR_PCI_MEM32_WIN_SIZE) != 0); 2951357d1e3bSDavid Gibson QEMU_BUILD_BUG_ON((SPAPR_PCI_MEM32_WIN_SIZE % SPAPR_PCI_IO_WIN_SIZE) != 0); 2952357d1e3bSDavid Gibson /* Sanity check bounds */ 295325e6a118SMichael S. Tsirkin QEMU_BUILD_BUG_ON((SPAPR_MAX_PHBS * SPAPR_PCI_IO_WIN_SIZE) > 295425e6a118SMichael S. Tsirkin SPAPR_PCI_MEM32_WIN_SIZE); 295525e6a118SMichael S. Tsirkin QEMU_BUILD_BUG_ON((SPAPR_MAX_PHBS * SPAPR_PCI_MEM32_WIN_SIZE) > 295625e6a118SMichael S. Tsirkin SPAPR_PCI_MEM64_WIN_SIZE); 29572efff1c0SDavid Gibson 295825e6a118SMichael S. Tsirkin if (index >= SPAPR_MAX_PHBS) { 295925e6a118SMichael S. Tsirkin error_setg(errp, "\"index\" for PAPR PHB is too large (max %llu)", 296025e6a118SMichael S. Tsirkin SPAPR_MAX_PHBS - 1); 29616737d9adSDavid Gibson return; 29626737d9adSDavid Gibson } 29636737d9adSDavid Gibson 29646737d9adSDavid Gibson *buid = base_buid + index; 29656737d9adSDavid Gibson for (i = 0; i < n_dma; ++i) { 29666737d9adSDavid Gibson liobns[i] = SPAPR_PCI_LIOBN(index, i); 29676737d9adSDavid Gibson } 29686737d9adSDavid Gibson 2969357d1e3bSDavid Gibson *pio = SPAPR_PCI_BASE + index * SPAPR_PCI_IO_WIN_SIZE; 2970357d1e3bSDavid Gibson *mmio32 = SPAPR_PCI_BASE + (index + 1) * SPAPR_PCI_MEM32_WIN_SIZE; 2971357d1e3bSDavid Gibson *mmio64 = SPAPR_PCI_BASE + (index + 1) * SPAPR_PCI_MEM64_WIN_SIZE; 29726737d9adSDavid Gibson } 29736737d9adSDavid Gibson 29747844e12bSCédric Le Goater static ICSState *spapr_ics_get(XICSFabric *dev, int irq) 29757844e12bSCédric Le Goater { 29767844e12bSCédric Le Goater sPAPRMachineState *spapr = SPAPR_MACHINE(dev); 29777844e12bSCédric Le Goater 29787844e12bSCédric Le Goater return ics_valid_irq(spapr->ics, irq) ? spapr->ics : NULL; 29797844e12bSCédric Le Goater } 29807844e12bSCédric Le Goater 29817844e12bSCédric Le Goater static void spapr_ics_resend(XICSFabric *dev) 29827844e12bSCédric Le Goater { 29837844e12bSCédric Le Goater sPAPRMachineState *spapr = SPAPR_MACHINE(dev); 29847844e12bSCédric Le Goater 29857844e12bSCédric Le Goater ics_resend(spapr->ics); 29867844e12bSCédric Le Goater } 29877844e12bSCédric Le Goater 298829ee3247SAlexey Kardashevskiy static void spapr_machine_class_init(ObjectClass *oc, void *data) 298953018216SPaolo Bonzini { 299029ee3247SAlexey Kardashevskiy MachineClass *mc = MACHINE_CLASS(oc); 2991224245bfSDavid Gibson sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(oc); 299271461b0fSAlexey Kardashevskiy FWPathProviderClass *fwc = FW_PATH_PROVIDER_CLASS(oc); 299334316482SAlexey Kardashevskiy NMIClass *nc = NMI_CLASS(oc); 2994c20d332aSBharata B Rao HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(oc); 29951d1be34dSDavid Gibson PPCVirtualHypervisorClass *vhc = PPC_VIRTUAL_HYPERVISOR_CLASS(oc); 29967844e12bSCédric Le Goater XICSFabricClass *xic = XICS_FABRIC_CLASS(oc); 299729ee3247SAlexey Kardashevskiy 29980eb9054cSDavid Gibson mc->desc = "pSeries Logical Partition (PAPR compliant)"; 2999fc9f38c3SDavid Gibson 3000fc9f38c3SDavid Gibson /* 3001fc9f38c3SDavid Gibson * We set up the default / latest behaviour here. The class_init 3002fc9f38c3SDavid Gibson * functions for the specific versioned machine types can override 3003fc9f38c3SDavid Gibson * these details for backwards compatibility 3004fc9f38c3SDavid Gibson */ 3005958db90cSMarcel Apfelbaum mc->init = ppc_spapr_init; 3006958db90cSMarcel Apfelbaum mc->reset = ppc_spapr_reset; 3007958db90cSMarcel Apfelbaum mc->block_default_type = IF_SCSI; 30086244bb7eSGreg Kurz mc->max_cpus = 1024; 3009958db90cSMarcel Apfelbaum mc->no_parallel = 1; 30105b2128d2SAlexander Graf mc->default_boot_order = ""; 3011a34944feSNikunj A Dadhania mc->default_ram_size = 512 * M_BYTE; 3012958db90cSMarcel Apfelbaum mc->kvm_type = spapr_kvm_type; 30139e3f9733SAlexander Graf mc->has_dynamic_sysbus = true; 3014e4024630SLaurent Vivier mc->pci_allow_0_address = true; 30157ebaf795SBharata B Rao mc->get_hotplug_handler = spapr_get_hotplug_handler; 301694a94e4cSBharata B Rao hc->pre_plug = spapr_machine_device_pre_plug; 3017c20d332aSBharata B Rao hc->plug = spapr_machine_device_plug; 3018c20d332aSBharata B Rao hc->unplug = spapr_machine_device_unplug; 301920bb648dSDavid Gibson mc->cpu_index_to_socket_id = spapr_cpu_index_to_socket_id; 3020535455fdSIgor Mammedov mc->possible_cpu_arch_ids = spapr_possible_cpu_arch_ids; 3021cf632463SBharata B Rao hc->unplug_request = spapr_machine_device_unplug_request; 302200b4fbe2SMarcel Apfelbaum 3023fc9f38c3SDavid Gibson smc->dr_lmb_enabled = true; 30243daa4a9fSThomas Huth smc->tcg_default_cpu = "POWER8"; 3025c5514d0eSIgor Mammedov mc->has_hotpluggable_cpus = true; 302671461b0fSAlexey Kardashevskiy fwc->get_dev_path = spapr_get_fw_dev_path; 302734316482SAlexey Kardashevskiy nc->nmi_monitor_handler = spapr_nmi; 30286737d9adSDavid Gibson smc->phb_placement = spapr_phb_placement; 30291d1be34dSDavid Gibson vhc->hypercall = emulate_spapr_hypercall; 3030e57ca75cSDavid Gibson vhc->hpt_mask = spapr_hpt_mask; 3031e57ca75cSDavid Gibson vhc->map_hptes = spapr_map_hptes; 3032e57ca75cSDavid Gibson vhc->unmap_hptes = spapr_unmap_hptes; 3033e57ca75cSDavid Gibson vhc->store_hpte = spapr_store_hpte; 30347844e12bSCédric Le Goater xic->ics_get = spapr_ics_get; 30357844e12bSCédric Le Goater xic->ics_resend = spapr_ics_resend; 303653018216SPaolo Bonzini } 303753018216SPaolo Bonzini 303829ee3247SAlexey Kardashevskiy static const TypeInfo spapr_machine_info = { 303929ee3247SAlexey Kardashevskiy .name = TYPE_SPAPR_MACHINE, 304029ee3247SAlexey Kardashevskiy .parent = TYPE_MACHINE, 30414aee7362SDavid Gibson .abstract = true, 30426ca1502eSAlexey Kardashevskiy .instance_size = sizeof(sPAPRMachineState), 304323825581SEduardo Habkost .instance_init = spapr_machine_initfn, 304487bbdd9cSDavid Gibson .instance_finalize = spapr_machine_finalizefn, 3045183930c0SDavid Gibson .class_size = sizeof(sPAPRMachineClass), 304629ee3247SAlexey Kardashevskiy .class_init = spapr_machine_class_init, 304771461b0fSAlexey Kardashevskiy .interfaces = (InterfaceInfo[]) { 304871461b0fSAlexey Kardashevskiy { TYPE_FW_PATH_PROVIDER }, 304934316482SAlexey Kardashevskiy { TYPE_NMI }, 3050c20d332aSBharata B Rao { TYPE_HOTPLUG_HANDLER }, 30511d1be34dSDavid Gibson { TYPE_PPC_VIRTUAL_HYPERVISOR }, 30527844e12bSCédric Le Goater { TYPE_XICS_FABRIC }, 305371461b0fSAlexey Kardashevskiy { } 305471461b0fSAlexey Kardashevskiy }, 305529ee3247SAlexey Kardashevskiy }; 305629ee3247SAlexey Kardashevskiy 3057fccbc785SDavid Gibson #define DEFINE_SPAPR_MACHINE(suffix, verstr, latest) \ 30585013c547SDavid Gibson static void spapr_machine_##suffix##_class_init(ObjectClass *oc, \ 30595013c547SDavid Gibson void *data) \ 30605013c547SDavid Gibson { \ 30615013c547SDavid Gibson MachineClass *mc = MACHINE_CLASS(oc); \ 30625013c547SDavid Gibson spapr_machine_##suffix##_class_options(mc); \ 3063fccbc785SDavid Gibson if (latest) { \ 3064fccbc785SDavid Gibson mc->alias = "pseries"; \ 3065fccbc785SDavid Gibson mc->is_default = 1; \ 3066fccbc785SDavid Gibson } \ 30675013c547SDavid Gibson } \ 30685013c547SDavid Gibson static void spapr_machine_##suffix##_instance_init(Object *obj) \ 30695013c547SDavid Gibson { \ 30705013c547SDavid Gibson MachineState *machine = MACHINE(obj); \ 30715013c547SDavid Gibson spapr_machine_##suffix##_instance_options(machine); \ 30725013c547SDavid Gibson } \ 30735013c547SDavid Gibson static const TypeInfo spapr_machine_##suffix##_info = { \ 30745013c547SDavid Gibson .name = MACHINE_TYPE_NAME("pseries-" verstr), \ 30755013c547SDavid Gibson .parent = TYPE_SPAPR_MACHINE, \ 30765013c547SDavid Gibson .class_init = spapr_machine_##suffix##_class_init, \ 30775013c547SDavid Gibson .instance_init = spapr_machine_##suffix##_instance_init, \ 30785013c547SDavid Gibson }; \ 30795013c547SDavid Gibson static void spapr_machine_register_##suffix(void) \ 30805013c547SDavid Gibson { \ 30815013c547SDavid Gibson type_register(&spapr_machine_##suffix##_info); \ 30825013c547SDavid Gibson } \ 30830e6aac87SEduardo Habkost type_init(spapr_machine_register_##suffix) 30845013c547SDavid Gibson 30851c5f29bbSDavid Gibson /* 3086fa325e6cSDavid Gibson * pseries-2.9 3087db800b21SDavid Gibson */ 3088fa325e6cSDavid Gibson static void spapr_machine_2_9_instance_options(MachineState *machine) 3089db800b21SDavid Gibson { 3090db800b21SDavid Gibson } 3091db800b21SDavid Gibson 3092fa325e6cSDavid Gibson static void spapr_machine_2_9_class_options(MachineClass *mc) 3093db800b21SDavid Gibson { 3094db800b21SDavid Gibson /* Defaults for the latest behaviour inherited from the base class */ 3095db800b21SDavid Gibson } 3096db800b21SDavid Gibson 3097fa325e6cSDavid Gibson DEFINE_SPAPR_MACHINE(2_9, "2.9", true); 3098fa325e6cSDavid Gibson 3099fa325e6cSDavid Gibson /* 3100fa325e6cSDavid Gibson * pseries-2.8 3101fa325e6cSDavid Gibson */ 3102fa325e6cSDavid Gibson #define SPAPR_COMPAT_2_8 \ 3103fa325e6cSDavid Gibson HW_COMPAT_2_8 3104fa325e6cSDavid Gibson 3105fa325e6cSDavid Gibson static void spapr_machine_2_8_instance_options(MachineState *machine) 3106fa325e6cSDavid Gibson { 3107fa325e6cSDavid Gibson spapr_machine_2_9_instance_options(machine); 3108fa325e6cSDavid Gibson } 3109fa325e6cSDavid Gibson 3110fa325e6cSDavid Gibson static void spapr_machine_2_8_class_options(MachineClass *mc) 3111fa325e6cSDavid Gibson { 3112fa325e6cSDavid Gibson spapr_machine_2_9_class_options(mc); 3113fa325e6cSDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_8); 3114fa325e6cSDavid Gibson } 3115fa325e6cSDavid Gibson 3116fa325e6cSDavid Gibson DEFINE_SPAPR_MACHINE(2_8, "2.8", false); 3117db800b21SDavid Gibson 3118db800b21SDavid Gibson /* 31191ea1eefcSBharata B Rao * pseries-2.7 31201ea1eefcSBharata B Rao */ 3121db800b21SDavid Gibson #define SPAPR_COMPAT_2_7 \ 3122db800b21SDavid Gibson HW_COMPAT_2_7 \ 3123357d1e3bSDavid Gibson { \ 3124357d1e3bSDavid Gibson .driver = TYPE_SPAPR_PCI_HOST_BRIDGE, \ 3125357d1e3bSDavid Gibson .property = "mem_win_size", \ 3126357d1e3bSDavid Gibson .value = stringify(SPAPR_PCI_2_7_MMIO_WIN_SIZE),\ 3127357d1e3bSDavid Gibson }, \ 3128357d1e3bSDavid Gibson { \ 3129357d1e3bSDavid Gibson .driver = TYPE_SPAPR_PCI_HOST_BRIDGE, \ 3130357d1e3bSDavid Gibson .property = "mem64_win_size", \ 3131357d1e3bSDavid Gibson .value = "0", \ 3132146c11f1SDavid Gibson }, \ 3133146c11f1SDavid Gibson { \ 3134146c11f1SDavid Gibson .driver = TYPE_POWERPC_CPU, \ 3135146c11f1SDavid Gibson .property = "pre-2.8-migration", \ 3136146c11f1SDavid Gibson .value = "on", \ 31375c4537bdSDavid Gibson }, \ 31385c4537bdSDavid Gibson { \ 31395c4537bdSDavid Gibson .driver = TYPE_SPAPR_PCI_HOST_BRIDGE, \ 31405c4537bdSDavid Gibson .property = "pre-2.8-migration", \ 31415c4537bdSDavid Gibson .value = "on", \ 3142357d1e3bSDavid Gibson }, 3143357d1e3bSDavid Gibson 3144357d1e3bSDavid Gibson static void phb_placement_2_7(sPAPRMachineState *spapr, uint32_t index, 3145357d1e3bSDavid Gibson uint64_t *buid, hwaddr *pio, 3146357d1e3bSDavid Gibson hwaddr *mmio32, hwaddr *mmio64, 3147357d1e3bSDavid Gibson unsigned n_dma, uint32_t *liobns, Error **errp) 3148357d1e3bSDavid Gibson { 3149357d1e3bSDavid Gibson /* Legacy PHB placement for pseries-2.7 and earlier machine types */ 3150357d1e3bSDavid Gibson const uint64_t base_buid = 0x800000020000000ULL; 3151357d1e3bSDavid Gibson const hwaddr phb_spacing = 0x1000000000ULL; /* 64 GiB */ 3152357d1e3bSDavid Gibson const hwaddr mmio_offset = 0xa0000000; /* 2 GiB + 512 MiB */ 3153357d1e3bSDavid Gibson const hwaddr pio_offset = 0x80000000; /* 2 GiB */ 3154357d1e3bSDavid Gibson const uint32_t max_index = 255; 3155357d1e3bSDavid Gibson const hwaddr phb0_alignment = 0x10000000000ULL; /* 1 TiB */ 3156357d1e3bSDavid Gibson 3157357d1e3bSDavid Gibson uint64_t ram_top = MACHINE(spapr)->ram_size; 3158357d1e3bSDavid Gibson hwaddr phb0_base, phb_base; 3159357d1e3bSDavid Gibson int i; 3160357d1e3bSDavid Gibson 3161357d1e3bSDavid Gibson /* Do we have hotpluggable memory? */ 3162357d1e3bSDavid Gibson if (MACHINE(spapr)->maxram_size > ram_top) { 3163357d1e3bSDavid Gibson /* Can't just use maxram_size, because there may be an 3164357d1e3bSDavid Gibson * alignment gap between normal and hotpluggable memory 3165357d1e3bSDavid Gibson * regions */ 3166357d1e3bSDavid Gibson ram_top = spapr->hotplug_memory.base + 3167357d1e3bSDavid Gibson memory_region_size(&spapr->hotplug_memory.mr); 3168357d1e3bSDavid Gibson } 3169357d1e3bSDavid Gibson 3170357d1e3bSDavid Gibson phb0_base = QEMU_ALIGN_UP(ram_top, phb0_alignment); 3171357d1e3bSDavid Gibson 3172357d1e3bSDavid Gibson if (index > max_index) { 3173357d1e3bSDavid Gibson error_setg(errp, "\"index\" for PAPR PHB is too large (max %u)", 3174357d1e3bSDavid Gibson max_index); 3175357d1e3bSDavid Gibson return; 3176357d1e3bSDavid Gibson } 3177357d1e3bSDavid Gibson 3178357d1e3bSDavid Gibson *buid = base_buid + index; 3179357d1e3bSDavid Gibson for (i = 0; i < n_dma; ++i) { 3180357d1e3bSDavid Gibson liobns[i] = SPAPR_PCI_LIOBN(index, i); 3181357d1e3bSDavid Gibson } 3182357d1e3bSDavid Gibson 3183357d1e3bSDavid Gibson phb_base = phb0_base + index * phb_spacing; 3184357d1e3bSDavid Gibson *pio = phb_base + pio_offset; 3185357d1e3bSDavid Gibson *mmio32 = phb_base + mmio_offset; 3186357d1e3bSDavid Gibson /* 3187357d1e3bSDavid Gibson * We don't set the 64-bit MMIO window, relying on the PHB's 3188357d1e3bSDavid Gibson * fallback behaviour of automatically splitting a large "32-bit" 3189357d1e3bSDavid Gibson * window into contiguous 32-bit and 64-bit windows 3190357d1e3bSDavid Gibson */ 3191357d1e3bSDavid Gibson } 3192db800b21SDavid Gibson 31931ea1eefcSBharata B Rao static void spapr_machine_2_7_instance_options(MachineState *machine) 31941ea1eefcSBharata B Rao { 3195f6229214SMichael Roth sPAPRMachineState *spapr = SPAPR_MACHINE(machine); 3196f6229214SMichael Roth 3197672de881SMichael Roth spapr_machine_2_8_instance_options(machine); 3198f6229214SMichael Roth spapr->use_hotplug_event_source = false; 31991ea1eefcSBharata B Rao } 32001ea1eefcSBharata B Rao 32011ea1eefcSBharata B Rao static void spapr_machine_2_7_class_options(MachineClass *mc) 32021ea1eefcSBharata B Rao { 32033daa4a9fSThomas Huth sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); 32043daa4a9fSThomas Huth 3205db800b21SDavid Gibson spapr_machine_2_8_class_options(mc); 32063daa4a9fSThomas Huth smc->tcg_default_cpu = "POWER7"; 3207db800b21SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_7); 3208357d1e3bSDavid Gibson smc->phb_placement = phb_placement_2_7; 32091ea1eefcSBharata B Rao } 32101ea1eefcSBharata B Rao 3211db800b21SDavid Gibson DEFINE_SPAPR_MACHINE(2_7, "2.7", false); 32121ea1eefcSBharata B Rao 32131ea1eefcSBharata B Rao /* 32144b23699cSDavid Gibson * pseries-2.6 32154b23699cSDavid Gibson */ 32161ea1eefcSBharata B Rao #define SPAPR_COMPAT_2_6 \ 3217ae4de14cSAlexey Kardashevskiy HW_COMPAT_2_6 \ 3218ae4de14cSAlexey Kardashevskiy { \ 3219ae4de14cSAlexey Kardashevskiy .driver = TYPE_SPAPR_PCI_HOST_BRIDGE,\ 3220ae4de14cSAlexey Kardashevskiy .property = "ddw",\ 3221ae4de14cSAlexey Kardashevskiy .value = stringify(off),\ 3222ae4de14cSAlexey Kardashevskiy }, 32231ea1eefcSBharata B Rao 32244b23699cSDavid Gibson static void spapr_machine_2_6_instance_options(MachineState *machine) 32254b23699cSDavid Gibson { 3226672de881SMichael Roth spapr_machine_2_7_instance_options(machine); 32274b23699cSDavid Gibson } 32284b23699cSDavid Gibson 32294b23699cSDavid Gibson static void spapr_machine_2_6_class_options(MachineClass *mc) 32304b23699cSDavid Gibson { 32311ea1eefcSBharata B Rao spapr_machine_2_7_class_options(mc); 3232c5514d0eSIgor Mammedov mc->has_hotpluggable_cpus = false; 32331ea1eefcSBharata B Rao SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_6); 32344b23699cSDavid Gibson } 32354b23699cSDavid Gibson 32361ea1eefcSBharata B Rao DEFINE_SPAPR_MACHINE(2_6, "2.6", false); 32374b23699cSDavid Gibson 32384b23699cSDavid Gibson /* 32391c5f29bbSDavid Gibson * pseries-2.5 32401c5f29bbSDavid Gibson */ 32414b23699cSDavid Gibson #define SPAPR_COMPAT_2_5 \ 324257c522f4SThomas Huth HW_COMPAT_2_5 \ 324357c522f4SThomas Huth { \ 324457c522f4SThomas Huth .driver = "spapr-vlan", \ 324557c522f4SThomas Huth .property = "use-rx-buffer-pools", \ 324657c522f4SThomas Huth .value = "off", \ 324757c522f4SThomas Huth }, 32484b23699cSDavid Gibson 32495013c547SDavid Gibson static void spapr_machine_2_5_instance_options(MachineState *machine) 32501c5f29bbSDavid Gibson { 3251672de881SMichael Roth spapr_machine_2_6_instance_options(machine); 32525013c547SDavid Gibson } 32535013c547SDavid Gibson 32545013c547SDavid Gibson static void spapr_machine_2_5_class_options(MachineClass *mc) 32555013c547SDavid Gibson { 325657040d45SThomas Huth sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); 325757040d45SThomas Huth 32584b23699cSDavid Gibson spapr_machine_2_6_class_options(mc); 325957040d45SThomas Huth smc->use_ohci_by_default = true; 32604b23699cSDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_5); 32611c5f29bbSDavid Gibson } 32621c5f29bbSDavid Gibson 32634b23699cSDavid Gibson DEFINE_SPAPR_MACHINE(2_5, "2.5", false); 32641c5f29bbSDavid Gibson 32651c5f29bbSDavid Gibson /* 32661c5f29bbSDavid Gibson * pseries-2.4 32671c5f29bbSDavid Gibson */ 326880fd50f9SCornelia Huck #define SPAPR_COMPAT_2_4 \ 326980fd50f9SCornelia Huck HW_COMPAT_2_4 327080fd50f9SCornelia Huck 32715013c547SDavid Gibson static void spapr_machine_2_4_instance_options(MachineState *machine) 32721c5f29bbSDavid Gibson { 32735013c547SDavid Gibson spapr_machine_2_5_instance_options(machine); 32745013c547SDavid Gibson } 32751c5f29bbSDavid Gibson 32765013c547SDavid Gibson static void spapr_machine_2_4_class_options(MachineClass *mc) 32775013c547SDavid Gibson { 3278fc9f38c3SDavid Gibson sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); 3279fc9f38c3SDavid Gibson 3280fc9f38c3SDavid Gibson spapr_machine_2_5_class_options(mc); 3281fc9f38c3SDavid Gibson smc->dr_lmb_enabled = false; 3282f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_4); 32831c5f29bbSDavid Gibson } 32841c5f29bbSDavid Gibson 3285fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_4, "2.4", false); 32861c5f29bbSDavid Gibson 32871c5f29bbSDavid Gibson /* 32881c5f29bbSDavid Gibson * pseries-2.3 32891c5f29bbSDavid Gibson */ 329038ff32c6SEduardo Habkost #define SPAPR_COMPAT_2_3 \ 32917619c7b0SMichael Roth HW_COMPAT_2_3 \ 32927619c7b0SMichael Roth {\ 32937619c7b0SMichael Roth .driver = "spapr-pci-host-bridge",\ 32947619c7b0SMichael Roth .property = "dynamic-reconfiguration",\ 32957619c7b0SMichael Roth .value = "off",\ 32967619c7b0SMichael Roth }, 329738ff32c6SEduardo Habkost 32985013c547SDavid Gibson static void spapr_machine_2_3_instance_options(MachineState *machine) 32991c5f29bbSDavid Gibson { 33005013c547SDavid Gibson spapr_machine_2_4_instance_options(machine); 33011c5f29bbSDavid Gibson savevm_skip_section_footers(); 33021c5f29bbSDavid Gibson global_state_set_optional(); 330309b5e30dSGreg Kurz savevm_skip_configuration(); 33041c5f29bbSDavid Gibson } 33051c5f29bbSDavid Gibson 33065013c547SDavid Gibson static void spapr_machine_2_3_class_options(MachineClass *mc) 33071c5f29bbSDavid Gibson { 3308fc9f38c3SDavid Gibson spapr_machine_2_4_class_options(mc); 3309f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_3); 33101c5f29bbSDavid Gibson } 3311fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_3, "2.3", false); 33121c5f29bbSDavid Gibson 33131c5f29bbSDavid Gibson /* 33141c5f29bbSDavid Gibson * pseries-2.2 33151c5f29bbSDavid Gibson */ 33161c5f29bbSDavid Gibson 3317b194df47SAlexey Kardashevskiy #define SPAPR_COMPAT_2_2 \ 33184dfd8eaaSEduardo Habkost HW_COMPAT_2_2 \ 3319b194df47SAlexey Kardashevskiy {\ 3320b194df47SAlexey Kardashevskiy .driver = TYPE_SPAPR_PCI_HOST_BRIDGE,\ 3321b194df47SAlexey Kardashevskiy .property = "mem_win_size",\ 3322b194df47SAlexey Kardashevskiy .value = "0x20000000",\ 3323dd754bafSEduardo Habkost }, 3324b194df47SAlexey Kardashevskiy 33255013c547SDavid Gibson static void spapr_machine_2_2_instance_options(MachineState *machine) 3326b0e966d0SJason Wang { 33275013c547SDavid Gibson spapr_machine_2_3_instance_options(machine); 3328cba0e779SGreg Kurz machine->suppress_vmdesc = true; 3329b0e966d0SJason Wang } 3330b0e966d0SJason Wang 33315013c547SDavid Gibson static void spapr_machine_2_2_class_options(MachineClass *mc) 3332b0e966d0SJason Wang { 3333fc9f38c3SDavid Gibson spapr_machine_2_3_class_options(mc); 3334f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_2); 33351c5f29bbSDavid Gibson } 3336fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_2, "2.2", false); 33371c5f29bbSDavid Gibson 33381c5f29bbSDavid Gibson /* 33391c5f29bbSDavid Gibson * pseries-2.1 33401c5f29bbSDavid Gibson */ 33411c5f29bbSDavid Gibson #define SPAPR_COMPAT_2_1 \ 33421c5f29bbSDavid Gibson HW_COMPAT_2_1 33431c5f29bbSDavid Gibson 33445013c547SDavid Gibson static void spapr_machine_2_1_instance_options(MachineState *machine) 33451c5f29bbSDavid Gibson { 33465013c547SDavid Gibson spapr_machine_2_2_instance_options(machine); 33471c5f29bbSDavid Gibson } 33481c5f29bbSDavid Gibson 33495013c547SDavid Gibson static void spapr_machine_2_1_class_options(MachineClass *mc) 3350b0e966d0SJason Wang { 3351fc9f38c3SDavid Gibson spapr_machine_2_2_class_options(mc); 3352f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_1); 33536026db45SAlexey Kardashevskiy } 3354fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_1, "2.1", false); 33556026db45SAlexey Kardashevskiy 335629ee3247SAlexey Kardashevskiy static void spapr_machine_register_types(void) 335729ee3247SAlexey Kardashevskiy { 335829ee3247SAlexey Kardashevskiy type_register_static(&spapr_machine_info); 335929ee3247SAlexey Kardashevskiy } 336029ee3247SAlexey Kardashevskiy 336129ee3247SAlexey Kardashevskiy type_init(spapr_machine_register_types) 3362