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 98*e6f7e110SCédric Le Goater static int try_create_xics(sPAPRMachineState *spapr, const char *type_ics, 99817bb6a4SCédric Le Goater const char *type_icp, int nr_servers, 100817bb6a4SCédric Le Goater int nr_irqs, Error **errp) 101c04d6cfaSAnthony Liguori { 1022cd908d0SCédric Le Goater XICSFabric *xi = XICS_FABRIC(spapr); 1034e4169f7SCédric Le Goater Error *err = NULL, *local_err = NULL; 1044e4169f7SCédric Le Goater ICSState *ics = NULL; 105817bb6a4SCédric Le Goater int i; 106c04d6cfaSAnthony Liguori 1074e4169f7SCédric Le Goater ics = ICS_SIMPLE(object_new(type_ics)); 108c79b2fddSCédric Le Goater qdev_set_parent_bus(DEVICE(ics), sysbus_get_default()); 109681bfadeSCédric Le Goater object_property_add_child(OBJECT(spapr), "ics", OBJECT(ics), NULL); 1104e4169f7SCédric Le Goater object_property_set_int(OBJECT(ics), nr_irqs, "nr-irqs", &err); 111b4f27d71SCédric Le Goater object_property_add_const_link(OBJECT(ics), "xics", OBJECT(xi), NULL); 1124e4169f7SCédric Le Goater object_property_set_bool(OBJECT(ics), true, "realized", &local_err); 1134e4169f7SCédric Le Goater error_propagate(&err, local_err); 1144e4169f7SCédric Le Goater if (err) { 1154e4169f7SCédric Le Goater goto error; 1164e4169f7SCédric Le Goater } 1174e4169f7SCédric Le Goater 118852ad27eSCédric Le Goater spapr->icps = g_malloc0(nr_servers * sizeof(ICPState)); 119852ad27eSCédric Le Goater spapr->nr_servers = nr_servers; 120817bb6a4SCédric Le Goater 121817bb6a4SCédric Le Goater for (i = 0; i < nr_servers; i++) { 122852ad27eSCédric Le Goater ICPState *icp = &spapr->icps[i]; 123817bb6a4SCédric Le Goater 124817bb6a4SCédric Le Goater object_initialize(icp, sizeof(*icp), type_icp); 12520147f2fSCédric Le Goater qdev_set_parent_bus(DEVICE(icp), sysbus_get_default()); 126852ad27eSCédric Le Goater object_property_add_child(OBJECT(spapr), "icp[*]", OBJECT(icp), NULL); 1272cd908d0SCédric Le Goater object_property_add_const_link(OBJECT(icp), "xics", OBJECT(xi), NULL); 128817bb6a4SCédric Le Goater object_property_set_bool(OBJECT(icp), true, "realized", &err); 129817bb6a4SCédric Le Goater if (err) { 130817bb6a4SCédric Le Goater goto error; 131817bb6a4SCédric Le Goater } 132817bb6a4SCédric Le Goater object_unref(OBJECT(icp)); 133817bb6a4SCédric Le Goater } 134817bb6a4SCédric Le Goater 135681bfadeSCédric Le Goater spapr->ics = ics; 136*e6f7e110SCédric Le Goater return 0; 1374e4169f7SCédric Le Goater 1384e4169f7SCédric Le Goater error: 1394e4169f7SCédric Le Goater error_propagate(errp, err); 1404e4169f7SCédric Le Goater if (ics) { 1414e4169f7SCédric Le Goater object_unparent(OBJECT(ics)); 1424e4169f7SCédric Le Goater } 143*e6f7e110SCédric Le Goater return -1; 144c04d6cfaSAnthony Liguori } 145c04d6cfaSAnthony Liguori 146*e6f7e110SCédric Le Goater static int xics_system_init(MachineState *machine, 1471e49182dSDavid Gibson int nr_servers, int nr_irqs, Error **errp) 148c04d6cfaSAnthony Liguori { 149*e6f7e110SCédric Le Goater int rc = -1; 150c04d6cfaSAnthony Liguori 15111ad93f6SDavid Gibson if (kvm_enabled()) { 15234f2af3dSMarkus Armbruster Error *err = NULL; 15334f2af3dSMarkus Armbruster 1542192a930SCédric Le Goater if (machine_kernel_irqchip_allowed(machine) && 1552192a930SCédric Le Goater !xics_kvm_init(SPAPR_MACHINE(machine), errp)) { 156*e6f7e110SCédric Le Goater rc = try_create_xics(SPAPR_MACHINE(machine), TYPE_ICS_KVM, 157817bb6a4SCédric Le Goater TYPE_KVM_ICP, nr_servers, nr_irqs, &err); 15811ad93f6SDavid Gibson } 159*e6f7e110SCédric Le Goater if (machine_kernel_irqchip_required(machine) && rc < 0) { 160b83baa60SMarkus Armbruster error_reportf_err(err, 161b83baa60SMarkus Armbruster "kernel_irqchip requested but unavailable: "); 162b83baa60SMarkus Armbruster } else { 163903a41d3SStefano Dong (董兴水) error_free(err); 16411ad93f6SDavid Gibson } 165b83baa60SMarkus Armbruster } 16611ad93f6SDavid Gibson 167*e6f7e110SCédric Le Goater if (rc < 0) { 1682192a930SCédric Le Goater xics_spapr_init(SPAPR_MACHINE(machine), errp); 169*e6f7e110SCédric Le Goater rc = try_create_xics(SPAPR_MACHINE(machine), TYPE_ICS_SIMPLE, 170681bfadeSCédric Le Goater TYPE_ICP, nr_servers, nr_irqs, errp); 171c04d6cfaSAnthony Liguori } 172c04d6cfaSAnthony Liguori 173*e6f7e110SCédric Le Goater return rc; 174c04d6cfaSAnthony Liguori } 175c04d6cfaSAnthony Liguori 176833d4668SAlexey Kardashevskiy static int spapr_fixup_cpu_smt_dt(void *fdt, int offset, PowerPCCPU *cpu, 177833d4668SAlexey Kardashevskiy int smt_threads) 178833d4668SAlexey Kardashevskiy { 179833d4668SAlexey Kardashevskiy int i, ret = 0; 180833d4668SAlexey Kardashevskiy uint32_t servers_prop[smt_threads]; 181833d4668SAlexey Kardashevskiy uint32_t gservers_prop[smt_threads * 2]; 182833d4668SAlexey Kardashevskiy int index = ppc_get_vcpu_dt_id(cpu); 183833d4668SAlexey Kardashevskiy 184d6e166c0SDavid Gibson if (cpu->compat_pvr) { 185d6e166c0SDavid Gibson ret = fdt_setprop_cell(fdt, offset, "cpu-version", cpu->compat_pvr); 1866d9412eaSAlexey Kardashevskiy if (ret < 0) { 1876d9412eaSAlexey Kardashevskiy return ret; 1886d9412eaSAlexey Kardashevskiy } 1896d9412eaSAlexey Kardashevskiy } 1906d9412eaSAlexey Kardashevskiy 191833d4668SAlexey Kardashevskiy /* Build interrupt servers and gservers properties */ 192833d4668SAlexey Kardashevskiy for (i = 0; i < smt_threads; i++) { 193833d4668SAlexey Kardashevskiy servers_prop[i] = cpu_to_be32(index + i); 194833d4668SAlexey Kardashevskiy /* Hack, direct the group queues back to cpu 0 */ 195833d4668SAlexey Kardashevskiy gservers_prop[i*2] = cpu_to_be32(index + i); 196833d4668SAlexey Kardashevskiy gservers_prop[i*2 + 1] = 0; 197833d4668SAlexey Kardashevskiy } 198833d4668SAlexey Kardashevskiy ret = fdt_setprop(fdt, offset, "ibm,ppc-interrupt-server#s", 199833d4668SAlexey Kardashevskiy servers_prop, sizeof(servers_prop)); 200833d4668SAlexey Kardashevskiy if (ret < 0) { 201833d4668SAlexey Kardashevskiy return ret; 202833d4668SAlexey Kardashevskiy } 203833d4668SAlexey Kardashevskiy ret = fdt_setprop(fdt, offset, "ibm,ppc-interrupt-gserver#s", 204833d4668SAlexey Kardashevskiy gservers_prop, sizeof(gservers_prop)); 205833d4668SAlexey Kardashevskiy 206833d4668SAlexey Kardashevskiy return ret; 207833d4668SAlexey Kardashevskiy } 208833d4668SAlexey Kardashevskiy 2090da6f3feSBharata B Rao static int spapr_fixup_cpu_numa_dt(void *fdt, int offset, CPUState *cs) 2100da6f3feSBharata B Rao { 2110da6f3feSBharata B Rao int ret = 0; 2120da6f3feSBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(cs); 2130da6f3feSBharata B Rao int index = ppc_get_vcpu_dt_id(cpu); 2140da6f3feSBharata B Rao uint32_t associativity[] = {cpu_to_be32(0x5), 2150da6f3feSBharata B Rao cpu_to_be32(0x0), 2160da6f3feSBharata B Rao cpu_to_be32(0x0), 2170da6f3feSBharata B Rao cpu_to_be32(0x0), 2180da6f3feSBharata B Rao cpu_to_be32(cs->numa_node), 2190da6f3feSBharata B Rao cpu_to_be32(index)}; 2200da6f3feSBharata B Rao 2210da6f3feSBharata B Rao /* Advertise NUMA via ibm,associativity */ 2220da6f3feSBharata B Rao if (nb_numa_nodes > 1) { 2230da6f3feSBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,associativity", associativity, 2240da6f3feSBharata B Rao sizeof(associativity)); 2250da6f3feSBharata B Rao } 2260da6f3feSBharata B Rao 2270da6f3feSBharata B Rao return ret; 2280da6f3feSBharata B Rao } 2290da6f3feSBharata B Rao 23028e02042SDavid Gibson static int spapr_fixup_cpu_dt(void *fdt, sPAPRMachineState *spapr) 23153018216SPaolo Bonzini { 23282677ed2SAlexey Kardashevskiy int ret = 0, offset, cpus_offset; 23382677ed2SAlexey Kardashevskiy CPUState *cs; 23453018216SPaolo Bonzini char cpu_model[32]; 23553018216SPaolo Bonzini int smt = kvmppc_smt_threads(); 23653018216SPaolo Bonzini uint32_t pft_size_prop[] = {0, cpu_to_be32(spapr->htab_shift)}; 23753018216SPaolo Bonzini 23882677ed2SAlexey Kardashevskiy CPU_FOREACH(cs) { 23982677ed2SAlexey Kardashevskiy PowerPCCPU *cpu = POWERPC_CPU(cs); 24082677ed2SAlexey Kardashevskiy DeviceClass *dc = DEVICE_GET_CLASS(cs); 24182677ed2SAlexey Kardashevskiy int index = ppc_get_vcpu_dt_id(cpu); 24212dbeb16SDavid Gibson int compat_smt = MIN(smp_threads, ppc_compat_max_threads(cpu)); 24353018216SPaolo Bonzini 2440f20ba62SAlexey Kardashevskiy if ((index % smt) != 0) { 24553018216SPaolo Bonzini continue; 24653018216SPaolo Bonzini } 24753018216SPaolo Bonzini 24882677ed2SAlexey Kardashevskiy snprintf(cpu_model, 32, "%s@%x", dc->fw_name, index); 24953018216SPaolo Bonzini 25082677ed2SAlexey Kardashevskiy cpus_offset = fdt_path_offset(fdt, "/cpus"); 25182677ed2SAlexey Kardashevskiy if (cpus_offset < 0) { 25282677ed2SAlexey Kardashevskiy cpus_offset = fdt_add_subnode(fdt, fdt_path_offset(fdt, "/"), 25382677ed2SAlexey Kardashevskiy "cpus"); 25482677ed2SAlexey Kardashevskiy if (cpus_offset < 0) { 25582677ed2SAlexey Kardashevskiy return cpus_offset; 25682677ed2SAlexey Kardashevskiy } 25782677ed2SAlexey Kardashevskiy } 25882677ed2SAlexey Kardashevskiy offset = fdt_subnode_offset(fdt, cpus_offset, cpu_model); 25982677ed2SAlexey Kardashevskiy if (offset < 0) { 26082677ed2SAlexey Kardashevskiy offset = fdt_add_subnode(fdt, cpus_offset, cpu_model); 26153018216SPaolo Bonzini if (offset < 0) { 26253018216SPaolo Bonzini return offset; 26353018216SPaolo Bonzini } 26482677ed2SAlexey Kardashevskiy } 26553018216SPaolo Bonzini 2660da6f3feSBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,pft-size", 2670da6f3feSBharata B Rao pft_size_prop, sizeof(pft_size_prop)); 26853018216SPaolo Bonzini if (ret < 0) { 26953018216SPaolo Bonzini return ret; 27053018216SPaolo Bonzini } 27153018216SPaolo Bonzini 2720da6f3feSBharata B Rao ret = spapr_fixup_cpu_numa_dt(fdt, offset, cs); 27353018216SPaolo Bonzini if (ret < 0) { 27453018216SPaolo Bonzini return ret; 27553018216SPaolo Bonzini } 276833d4668SAlexey Kardashevskiy 27712dbeb16SDavid Gibson ret = spapr_fixup_cpu_smt_dt(fdt, offset, cpu, compat_smt); 278833d4668SAlexey Kardashevskiy if (ret < 0) { 279833d4668SAlexey Kardashevskiy return ret; 280833d4668SAlexey Kardashevskiy } 28153018216SPaolo Bonzini } 28253018216SPaolo Bonzini return ret; 28353018216SPaolo Bonzini } 28453018216SPaolo Bonzini 285b082d65aSAlexey Kardashevskiy static hwaddr spapr_node0_size(void) 286b082d65aSAlexey Kardashevskiy { 287fb164994SDavid Gibson MachineState *machine = MACHINE(qdev_get_machine()); 288fb164994SDavid Gibson 289b082d65aSAlexey Kardashevskiy if (nb_numa_nodes) { 290b082d65aSAlexey Kardashevskiy int i; 291b082d65aSAlexey Kardashevskiy for (i = 0; i < nb_numa_nodes; ++i) { 292b082d65aSAlexey Kardashevskiy if (numa_info[i].node_mem) { 293fb164994SDavid Gibson return MIN(pow2floor(numa_info[i].node_mem), 294fb164994SDavid Gibson machine->ram_size); 295b082d65aSAlexey Kardashevskiy } 296b082d65aSAlexey Kardashevskiy } 297b082d65aSAlexey Kardashevskiy } 298fb164994SDavid Gibson return machine->ram_size; 299b082d65aSAlexey Kardashevskiy } 300b082d65aSAlexey Kardashevskiy 301a1d59c0fSAlexey Kardashevskiy static void add_str(GString *s, const gchar *s1) 302a1d59c0fSAlexey Kardashevskiy { 303a1d59c0fSAlexey Kardashevskiy g_string_append_len(s, s1, strlen(s1) + 1); 304a1d59c0fSAlexey Kardashevskiy } 30553018216SPaolo Bonzini 30603d196b7SBharata B Rao static int spapr_populate_memory_node(void *fdt, int nodeid, hwaddr start, 30726a8c353SAlexey Kardashevskiy hwaddr size) 30826a8c353SAlexey Kardashevskiy { 30926a8c353SAlexey Kardashevskiy uint32_t associativity[] = { 31026a8c353SAlexey Kardashevskiy cpu_to_be32(0x4), /* length */ 31126a8c353SAlexey Kardashevskiy cpu_to_be32(0x0), cpu_to_be32(0x0), 312c3b4f589SAlexey Kardashevskiy cpu_to_be32(0x0), cpu_to_be32(nodeid) 31326a8c353SAlexey Kardashevskiy }; 31426a8c353SAlexey Kardashevskiy char mem_name[32]; 31526a8c353SAlexey Kardashevskiy uint64_t mem_reg_property[2]; 31626a8c353SAlexey Kardashevskiy int off; 31726a8c353SAlexey Kardashevskiy 31826a8c353SAlexey Kardashevskiy mem_reg_property[0] = cpu_to_be64(start); 31926a8c353SAlexey Kardashevskiy mem_reg_property[1] = cpu_to_be64(size); 32026a8c353SAlexey Kardashevskiy 32126a8c353SAlexey Kardashevskiy sprintf(mem_name, "memory@" TARGET_FMT_lx, start); 32226a8c353SAlexey Kardashevskiy off = fdt_add_subnode(fdt, 0, mem_name); 32326a8c353SAlexey Kardashevskiy _FDT(off); 32426a8c353SAlexey Kardashevskiy _FDT((fdt_setprop_string(fdt, off, "device_type", "memory"))); 32526a8c353SAlexey Kardashevskiy _FDT((fdt_setprop(fdt, off, "reg", mem_reg_property, 32626a8c353SAlexey Kardashevskiy sizeof(mem_reg_property)))); 32726a8c353SAlexey Kardashevskiy _FDT((fdt_setprop(fdt, off, "ibm,associativity", associativity, 32826a8c353SAlexey Kardashevskiy sizeof(associativity)))); 32903d196b7SBharata B Rao return off; 33026a8c353SAlexey Kardashevskiy } 33126a8c353SAlexey Kardashevskiy 33228e02042SDavid Gibson static int spapr_populate_memory(sPAPRMachineState *spapr, void *fdt) 33353018216SPaolo Bonzini { 334fb164994SDavid Gibson MachineState *machine = MACHINE(spapr); 3357db8a127SAlexey Kardashevskiy hwaddr mem_start, node_size; 3367db8a127SAlexey Kardashevskiy int i, nb_nodes = nb_numa_nodes; 3377db8a127SAlexey Kardashevskiy NodeInfo *nodes = numa_info; 3387db8a127SAlexey Kardashevskiy NodeInfo ramnode; 33953018216SPaolo Bonzini 3407db8a127SAlexey Kardashevskiy /* No NUMA nodes, assume there is just one node with whole RAM */ 3417db8a127SAlexey Kardashevskiy if (!nb_numa_nodes) { 3427db8a127SAlexey Kardashevskiy nb_nodes = 1; 343fb164994SDavid Gibson ramnode.node_mem = machine->ram_size; 3447db8a127SAlexey Kardashevskiy nodes = &ramnode; 3455fe269b1SPaul Mackerras } 34653018216SPaolo Bonzini 3477db8a127SAlexey Kardashevskiy for (i = 0, mem_start = 0; i < nb_nodes; ++i) { 3487db8a127SAlexey Kardashevskiy if (!nodes[i].node_mem) { 3497db8a127SAlexey Kardashevskiy continue; 35053018216SPaolo Bonzini } 351fb164994SDavid Gibson if (mem_start >= machine->ram_size) { 3525fe269b1SPaul Mackerras node_size = 0; 3535fe269b1SPaul Mackerras } else { 3547db8a127SAlexey Kardashevskiy node_size = nodes[i].node_mem; 355fb164994SDavid Gibson if (node_size > machine->ram_size - mem_start) { 356fb164994SDavid Gibson node_size = machine->ram_size - mem_start; 3575fe269b1SPaul Mackerras } 3585fe269b1SPaul Mackerras } 3597db8a127SAlexey Kardashevskiy if (!mem_start) { 3607db8a127SAlexey Kardashevskiy /* ppc_spapr_init() checks for rma_size <= node0_size already */ 361e8f986fcSBharata B Rao spapr_populate_memory_node(fdt, i, 0, spapr->rma_size); 3627db8a127SAlexey Kardashevskiy mem_start += spapr->rma_size; 3637db8a127SAlexey Kardashevskiy node_size -= spapr->rma_size; 3647db8a127SAlexey Kardashevskiy } 3656010818cSAlexey Kardashevskiy for ( ; node_size; ) { 3666010818cSAlexey Kardashevskiy hwaddr sizetmp = pow2floor(node_size); 3676010818cSAlexey Kardashevskiy 3686010818cSAlexey Kardashevskiy /* mem_start != 0 here */ 3696010818cSAlexey Kardashevskiy if (ctzl(mem_start) < ctzl(sizetmp)) { 3706010818cSAlexey Kardashevskiy sizetmp = 1ULL << ctzl(mem_start); 3716010818cSAlexey Kardashevskiy } 3726010818cSAlexey Kardashevskiy 3736010818cSAlexey Kardashevskiy spapr_populate_memory_node(fdt, i, mem_start, sizetmp); 3746010818cSAlexey Kardashevskiy node_size -= sizetmp; 3756010818cSAlexey Kardashevskiy mem_start += sizetmp; 3766010818cSAlexey Kardashevskiy } 37753018216SPaolo Bonzini } 37853018216SPaolo Bonzini 37953018216SPaolo Bonzini return 0; 38053018216SPaolo Bonzini } 38153018216SPaolo Bonzini 382230bf719SThomas Huth /* Populate the "ibm,pa-features" property */ 383230bf719SThomas Huth static void spapr_populate_pa_features(CPUPPCState *env, void *fdt, int offset) 384230bf719SThomas Huth { 385230bf719SThomas Huth uint8_t pa_features_206[] = { 6, 0, 386230bf719SThomas Huth 0xf6, 0x1f, 0xc7, 0x00, 0x80, 0xc0 }; 387230bf719SThomas Huth uint8_t pa_features_207[] = { 24, 0, 388230bf719SThomas Huth 0xf6, 0x1f, 0xc7, 0xc0, 0x80, 0xf0, 389230bf719SThomas Huth 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 390230bf719SThomas Huth 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 391bac3bf28SThomas Huth 0x80, 0x00, 0x80, 0x00, 0x00, 0x00 }; 392230bf719SThomas Huth uint8_t *pa_features; 393230bf719SThomas Huth size_t pa_size; 394230bf719SThomas Huth 3954cbec30dSThomas Huth switch (env->mmu_model) { 3964cbec30dSThomas Huth case POWERPC_MMU_2_06: 3974cbec30dSThomas Huth case POWERPC_MMU_2_06a: 398230bf719SThomas Huth pa_features = pa_features_206; 399230bf719SThomas Huth pa_size = sizeof(pa_features_206); 4004cbec30dSThomas Huth break; 4014cbec30dSThomas Huth case POWERPC_MMU_2_07: 4024cbec30dSThomas Huth case POWERPC_MMU_2_07a: 403230bf719SThomas Huth pa_features = pa_features_207; 404230bf719SThomas Huth pa_size = sizeof(pa_features_207); 4054cbec30dSThomas Huth break; 4064cbec30dSThomas Huth default: 4074cbec30dSThomas Huth return; 408230bf719SThomas Huth } 409230bf719SThomas Huth 410230bf719SThomas Huth if (env->ci_large_pages) { 411230bf719SThomas Huth /* 412230bf719SThomas Huth * Note: we keep CI large pages off by default because a 64K capable 413230bf719SThomas Huth * guest provisioned with large pages might otherwise try to map a qemu 414230bf719SThomas Huth * framebuffer (or other kind of memory mapped PCI BAR) using 64K pages 415230bf719SThomas Huth * even if that qemu runs on a 4k host. 416230bf719SThomas Huth * We dd this bit back here if we are confident this is not an issue 417230bf719SThomas Huth */ 418230bf719SThomas Huth pa_features[3] |= 0x20; 419230bf719SThomas Huth } 420bac3bf28SThomas Huth if (kvmppc_has_cap_htm() && pa_size > 24) { 421bac3bf28SThomas Huth pa_features[24] |= 0x80; /* Transactional memory support */ 422bac3bf28SThomas Huth } 423230bf719SThomas Huth 424230bf719SThomas Huth _FDT((fdt_setprop(fdt, offset, "ibm,pa-features", pa_features, pa_size))); 425230bf719SThomas Huth } 426230bf719SThomas Huth 4270da6f3feSBharata B Rao static void spapr_populate_cpu_dt(CPUState *cs, void *fdt, int offset, 4280da6f3feSBharata B Rao sPAPRMachineState *spapr) 4290da6f3feSBharata B Rao { 4300da6f3feSBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(cs); 4310da6f3feSBharata B Rao CPUPPCState *env = &cpu->env; 4320da6f3feSBharata B Rao PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(cs); 4330da6f3feSBharata B Rao int index = ppc_get_vcpu_dt_id(cpu); 4340da6f3feSBharata B Rao uint32_t segs[] = {cpu_to_be32(28), cpu_to_be32(40), 4350da6f3feSBharata B Rao 0xffffffff, 0xffffffff}; 436afd10a0fSBharata B Rao uint32_t tbfreq = kvm_enabled() ? kvmppc_get_tbfreq() 437afd10a0fSBharata B Rao : SPAPR_TIMEBASE_FREQ; 4380da6f3feSBharata B Rao uint32_t cpufreq = kvm_enabled() ? kvmppc_get_clockfreq() : 1000000000; 4390da6f3feSBharata B Rao uint32_t page_sizes_prop[64]; 4400da6f3feSBharata B Rao size_t page_sizes_prop_size; 44122419c2aSDavid Gibson uint32_t vcpus_per_socket = smp_threads * smp_cores; 4420da6f3feSBharata B Rao uint32_t pft_size_prop[] = {0, cpu_to_be32(spapr->htab_shift)}; 44312dbeb16SDavid Gibson int compat_smt = MIN(smp_threads, ppc_compat_max_threads(cpu)); 444af81cf32SBharata B Rao sPAPRDRConnector *drc; 445af81cf32SBharata B Rao sPAPRDRConnectorClass *drck; 446af81cf32SBharata B Rao int drc_index; 447af81cf32SBharata B Rao 448af81cf32SBharata B Rao drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_CPU, index); 449af81cf32SBharata B Rao if (drc) { 450af81cf32SBharata B Rao drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 451af81cf32SBharata B Rao drc_index = drck->get_index(drc); 452af81cf32SBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,my-drc-index", drc_index))); 453af81cf32SBharata B Rao } 4540da6f3feSBharata B Rao 4550da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "reg", index))); 4560da6f3feSBharata B Rao _FDT((fdt_setprop_string(fdt, offset, "device_type", "cpu"))); 4570da6f3feSBharata B Rao 4580da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "cpu-version", env->spr[SPR_PVR]))); 4590da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "d-cache-block-size", 4600da6f3feSBharata B Rao env->dcache_line_size))); 4610da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "d-cache-line-size", 4620da6f3feSBharata B Rao env->dcache_line_size))); 4630da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "i-cache-block-size", 4640da6f3feSBharata B Rao env->icache_line_size))); 4650da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "i-cache-line-size", 4660da6f3feSBharata B Rao env->icache_line_size))); 4670da6f3feSBharata B Rao 4680da6f3feSBharata B Rao if (pcc->l1_dcache_size) { 4690da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "d-cache-size", 4700da6f3feSBharata B Rao pcc->l1_dcache_size))); 4710da6f3feSBharata B Rao } else { 472ce9863b7SCédric Le Goater error_report("Warning: Unknown L1 dcache size for cpu"); 4730da6f3feSBharata B Rao } 4740da6f3feSBharata B Rao if (pcc->l1_icache_size) { 4750da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "i-cache-size", 4760da6f3feSBharata B Rao pcc->l1_icache_size))); 4770da6f3feSBharata B Rao } else { 478ce9863b7SCédric Le Goater error_report("Warning: Unknown L1 icache size for cpu"); 4790da6f3feSBharata B Rao } 4800da6f3feSBharata B Rao 4810da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "timebase-frequency", tbfreq))); 4820da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "clock-frequency", cpufreq))); 483fd5da5c4SThomas Huth _FDT((fdt_setprop_cell(fdt, offset, "slb-size", env->slb_nr))); 4840da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,slb-size", env->slb_nr))); 4850da6f3feSBharata B Rao _FDT((fdt_setprop_string(fdt, offset, "status", "okay"))); 4860da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "64-bit", NULL, 0))); 4870da6f3feSBharata B Rao 4880da6f3feSBharata B Rao if (env->spr_cb[SPR_PURR].oea_read) { 4890da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,purr", NULL, 0))); 4900da6f3feSBharata B Rao } 4910da6f3feSBharata B Rao 4920da6f3feSBharata B Rao if (env->mmu_model & POWERPC_MMU_1TSEG) { 4930da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,processor-segment-sizes", 4940da6f3feSBharata B Rao segs, sizeof(segs)))); 4950da6f3feSBharata B Rao } 4960da6f3feSBharata B Rao 4970da6f3feSBharata B Rao /* Advertise VMX/VSX (vector extensions) if available 4980da6f3feSBharata B Rao * 0 / no property == no vector extensions 4990da6f3feSBharata B Rao * 1 == VMX / Altivec available 5000da6f3feSBharata B Rao * 2 == VSX available */ 5010da6f3feSBharata B Rao if (env->insns_flags & PPC_ALTIVEC) { 5020da6f3feSBharata B Rao uint32_t vmx = (env->insns_flags2 & PPC2_VSX) ? 2 : 1; 5030da6f3feSBharata B Rao 5040da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,vmx", vmx))); 5050da6f3feSBharata B Rao } 5060da6f3feSBharata B Rao 5070da6f3feSBharata B Rao /* Advertise DFP (Decimal Floating Point) if available 5080da6f3feSBharata B Rao * 0 / no property == no DFP 5090da6f3feSBharata B Rao * 1 == DFP available */ 5100da6f3feSBharata B Rao if (env->insns_flags2 & PPC2_DFP) { 5110da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,dfp", 1))); 5120da6f3feSBharata B Rao } 5130da6f3feSBharata B Rao 5143654fa95SCédric Le Goater page_sizes_prop_size = ppc_create_page_sizes_prop(env, page_sizes_prop, 5150da6f3feSBharata B Rao sizeof(page_sizes_prop)); 5160da6f3feSBharata B Rao if (page_sizes_prop_size) { 5170da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,segment-page-sizes", 5180da6f3feSBharata B Rao page_sizes_prop, page_sizes_prop_size))); 5190da6f3feSBharata B Rao } 5200da6f3feSBharata B Rao 521230bf719SThomas Huth spapr_populate_pa_features(env, fdt, offset); 52290da0d5aSBenjamin Herrenschmidt 5230da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,chip-id", 52422419c2aSDavid Gibson cs->cpu_index / vcpus_per_socket))); 5250da6f3feSBharata B Rao 5260da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,pft-size", 5270da6f3feSBharata B Rao pft_size_prop, sizeof(pft_size_prop)))); 5280da6f3feSBharata B Rao 5290da6f3feSBharata B Rao _FDT(spapr_fixup_cpu_numa_dt(fdt, offset, cs)); 5300da6f3feSBharata B Rao 53112dbeb16SDavid Gibson _FDT(spapr_fixup_cpu_smt_dt(fdt, offset, cpu, compat_smt)); 5320da6f3feSBharata B Rao } 5330da6f3feSBharata B Rao 5340da6f3feSBharata B Rao static void spapr_populate_cpus_dt_node(void *fdt, sPAPRMachineState *spapr) 5350da6f3feSBharata B Rao { 5360da6f3feSBharata B Rao CPUState *cs; 5370da6f3feSBharata B Rao int cpus_offset; 5380da6f3feSBharata B Rao char *nodename; 5390da6f3feSBharata B Rao int smt = kvmppc_smt_threads(); 5400da6f3feSBharata B Rao 5410da6f3feSBharata B Rao cpus_offset = fdt_add_subnode(fdt, 0, "cpus"); 5420da6f3feSBharata B Rao _FDT(cpus_offset); 5430da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, cpus_offset, "#address-cells", 0x1))); 5440da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, cpus_offset, "#size-cells", 0x0))); 5450da6f3feSBharata B Rao 5460da6f3feSBharata B Rao /* 5470da6f3feSBharata B Rao * We walk the CPUs in reverse order to ensure that CPU DT nodes 5480da6f3feSBharata B Rao * created by fdt_add_subnode() end up in the right order in FDT 5490da6f3feSBharata B Rao * for the guest kernel the enumerate the CPUs correctly. 5500da6f3feSBharata B Rao */ 5510da6f3feSBharata B Rao CPU_FOREACH_REVERSE(cs) { 5520da6f3feSBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(cs); 5530da6f3feSBharata B Rao int index = ppc_get_vcpu_dt_id(cpu); 5540da6f3feSBharata B Rao DeviceClass *dc = DEVICE_GET_CLASS(cs); 5550da6f3feSBharata B Rao int offset; 5560da6f3feSBharata B Rao 5570da6f3feSBharata B Rao if ((index % smt) != 0) { 5580da6f3feSBharata B Rao continue; 5590da6f3feSBharata B Rao } 5600da6f3feSBharata B Rao 5610da6f3feSBharata B Rao nodename = g_strdup_printf("%s@%x", dc->fw_name, index); 5620da6f3feSBharata B Rao offset = fdt_add_subnode(fdt, cpus_offset, nodename); 5630da6f3feSBharata B Rao g_free(nodename); 5640da6f3feSBharata B Rao _FDT(offset); 5650da6f3feSBharata B Rao spapr_populate_cpu_dt(cs, fdt, offset, spapr); 5660da6f3feSBharata B Rao } 5670da6f3feSBharata B Rao 5680da6f3feSBharata B Rao } 5690da6f3feSBharata B Rao 57003d196b7SBharata B Rao /* 57103d196b7SBharata B Rao * Adds ibm,dynamic-reconfiguration-memory node. 57203d196b7SBharata B Rao * Refer to docs/specs/ppc-spapr-hotplug.txt for the documentation 57303d196b7SBharata B Rao * of this device tree node. 57403d196b7SBharata B Rao */ 57503d196b7SBharata B Rao static int spapr_populate_drconf_memory(sPAPRMachineState *spapr, void *fdt) 57603d196b7SBharata B Rao { 57703d196b7SBharata B Rao MachineState *machine = MACHINE(spapr); 57803d196b7SBharata B Rao int ret, i, offset; 57903d196b7SBharata B Rao uint64_t lmb_size = SPAPR_MEMORY_BLOCK_SIZE; 58003d196b7SBharata B Rao uint32_t prop_lmb_size[] = {0, cpu_to_be32(lmb_size)}; 581d0e5a8f2SBharata B Rao uint32_t hotplug_lmb_start = spapr->hotplug_memory.base / lmb_size; 582d0e5a8f2SBharata B Rao uint32_t nr_lmbs = (spapr->hotplug_memory.base + 583d0e5a8f2SBharata B Rao memory_region_size(&spapr->hotplug_memory.mr)) / 584d0e5a8f2SBharata B Rao lmb_size; 58503d196b7SBharata B Rao uint32_t *int_buf, *cur_index, buf_len; 5866663864eSBharata B Rao int nr_nodes = nb_numa_nodes ? nb_numa_nodes : 1; 58703d196b7SBharata B Rao 588ef001f06SThomas Huth /* 589d0e5a8f2SBharata B Rao * Don't create the node if there is no hotpluggable memory 59016c25aefSBharata B Rao */ 591d0e5a8f2SBharata B Rao if (machine->ram_size == machine->maxram_size) { 59216c25aefSBharata B Rao return 0; 59316c25aefSBharata B Rao } 59416c25aefSBharata B Rao 59516c25aefSBharata B Rao /* 596ef001f06SThomas Huth * Allocate enough buffer size to fit in ibm,dynamic-memory 597ef001f06SThomas Huth * or ibm,associativity-lookup-arrays 598ef001f06SThomas Huth */ 599ef001f06SThomas Huth buf_len = MAX(nr_lmbs * SPAPR_DR_LMB_LIST_ENTRY_SIZE + 1, nr_nodes * 4 + 2) 600ef001f06SThomas Huth * sizeof(uint32_t); 60103d196b7SBharata B Rao cur_index = int_buf = g_malloc0(buf_len); 60203d196b7SBharata B Rao 60303d196b7SBharata B Rao offset = fdt_add_subnode(fdt, 0, "ibm,dynamic-reconfiguration-memory"); 60403d196b7SBharata B Rao 60503d196b7SBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,lmb-size", prop_lmb_size, 60603d196b7SBharata B Rao sizeof(prop_lmb_size)); 60703d196b7SBharata B Rao if (ret < 0) { 60803d196b7SBharata B Rao goto out; 60903d196b7SBharata B Rao } 61003d196b7SBharata B Rao 61103d196b7SBharata B Rao ret = fdt_setprop_cell(fdt, offset, "ibm,memory-flags-mask", 0xff); 61203d196b7SBharata B Rao if (ret < 0) { 61303d196b7SBharata B Rao goto out; 61403d196b7SBharata B Rao } 61503d196b7SBharata B Rao 61603d196b7SBharata B Rao ret = fdt_setprop_cell(fdt, offset, "ibm,memory-preservation-time", 0x0); 61703d196b7SBharata B Rao if (ret < 0) { 61803d196b7SBharata B Rao goto out; 61903d196b7SBharata B Rao } 62003d196b7SBharata B Rao 62103d196b7SBharata B Rao /* ibm,dynamic-memory */ 62203d196b7SBharata B Rao int_buf[0] = cpu_to_be32(nr_lmbs); 62303d196b7SBharata B Rao cur_index++; 62403d196b7SBharata B Rao for (i = 0; i < nr_lmbs; i++) { 625d0e5a8f2SBharata B Rao uint64_t addr = i * lmb_size; 62603d196b7SBharata B Rao uint32_t *dynamic_memory = cur_index; 62703d196b7SBharata B Rao 628d0e5a8f2SBharata B Rao if (i >= hotplug_lmb_start) { 629d0e5a8f2SBharata B Rao sPAPRDRConnector *drc; 630d0e5a8f2SBharata B Rao sPAPRDRConnectorClass *drck; 631d0e5a8f2SBharata B Rao 632d0e5a8f2SBharata B Rao drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_LMB, i); 63303d196b7SBharata B Rao g_assert(drc); 63403d196b7SBharata B Rao drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 63503d196b7SBharata B Rao 63603d196b7SBharata B Rao dynamic_memory[0] = cpu_to_be32(addr >> 32); 63703d196b7SBharata B Rao dynamic_memory[1] = cpu_to_be32(addr & 0xffffffff); 63803d196b7SBharata B Rao dynamic_memory[2] = cpu_to_be32(drck->get_index(drc)); 63903d196b7SBharata B Rao dynamic_memory[3] = cpu_to_be32(0); /* reserved */ 64003d196b7SBharata B Rao dynamic_memory[4] = cpu_to_be32(numa_get_node(addr, NULL)); 641d0e5a8f2SBharata B Rao if (memory_region_present(get_system_memory(), addr)) { 64203d196b7SBharata B Rao dynamic_memory[5] = cpu_to_be32(SPAPR_LMB_FLAGS_ASSIGNED); 64303d196b7SBharata B Rao } else { 64403d196b7SBharata B Rao dynamic_memory[5] = cpu_to_be32(0); 64503d196b7SBharata B Rao } 646d0e5a8f2SBharata B Rao } else { 647d0e5a8f2SBharata B Rao /* 648d0e5a8f2SBharata B Rao * LMB information for RMA, boot time RAM and gap b/n RAM and 649d0e5a8f2SBharata B Rao * hotplug memory region -- all these are marked as reserved 650d0e5a8f2SBharata B Rao * and as having no valid DRC. 651d0e5a8f2SBharata B Rao */ 652d0e5a8f2SBharata B Rao dynamic_memory[0] = cpu_to_be32(addr >> 32); 653d0e5a8f2SBharata B Rao dynamic_memory[1] = cpu_to_be32(addr & 0xffffffff); 654d0e5a8f2SBharata B Rao dynamic_memory[2] = cpu_to_be32(0); 655d0e5a8f2SBharata B Rao dynamic_memory[3] = cpu_to_be32(0); /* reserved */ 656d0e5a8f2SBharata B Rao dynamic_memory[4] = cpu_to_be32(-1); 657d0e5a8f2SBharata B Rao dynamic_memory[5] = cpu_to_be32(SPAPR_LMB_FLAGS_RESERVED | 658d0e5a8f2SBharata B Rao SPAPR_LMB_FLAGS_DRC_INVALID); 659d0e5a8f2SBharata B Rao } 66003d196b7SBharata B Rao 66103d196b7SBharata B Rao cur_index += SPAPR_DR_LMB_LIST_ENTRY_SIZE; 66203d196b7SBharata B Rao } 66303d196b7SBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,dynamic-memory", int_buf, buf_len); 66403d196b7SBharata B Rao if (ret < 0) { 66503d196b7SBharata B Rao goto out; 66603d196b7SBharata B Rao } 66703d196b7SBharata B Rao 66803d196b7SBharata B Rao /* ibm,associativity-lookup-arrays */ 66903d196b7SBharata B Rao cur_index = int_buf; 6706663864eSBharata B Rao int_buf[0] = cpu_to_be32(nr_nodes); 67103d196b7SBharata B Rao int_buf[1] = cpu_to_be32(4); /* Number of entries per associativity list */ 67203d196b7SBharata B Rao cur_index += 2; 6736663864eSBharata B Rao for (i = 0; i < nr_nodes; i++) { 67403d196b7SBharata B Rao uint32_t associativity[] = { 67503d196b7SBharata B Rao cpu_to_be32(0x0), 67603d196b7SBharata B Rao cpu_to_be32(0x0), 67703d196b7SBharata B Rao cpu_to_be32(0x0), 67803d196b7SBharata B Rao cpu_to_be32(i) 67903d196b7SBharata B Rao }; 68003d196b7SBharata B Rao memcpy(cur_index, associativity, sizeof(associativity)); 68103d196b7SBharata B Rao cur_index += 4; 68203d196b7SBharata B Rao } 68303d196b7SBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,associativity-lookup-arrays", int_buf, 68403d196b7SBharata B Rao (cur_index - int_buf) * sizeof(uint32_t)); 68503d196b7SBharata B Rao out: 68603d196b7SBharata B Rao g_free(int_buf); 68703d196b7SBharata B Rao return ret; 68803d196b7SBharata B Rao } 68903d196b7SBharata B Rao 6906787d27bSMichael Roth static int spapr_dt_cas_updates(sPAPRMachineState *spapr, void *fdt, 6916787d27bSMichael Roth sPAPROptionVector *ov5_updates) 6926787d27bSMichael Roth { 6936787d27bSMichael Roth sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(spapr); 694417ece33SMichael Roth int ret = 0, offset; 6956787d27bSMichael Roth 6966787d27bSMichael Roth /* Generate ibm,dynamic-reconfiguration-memory node if required */ 6976787d27bSMichael Roth if (spapr_ovec_test(ov5_updates, OV5_DRCONF_MEMORY)) { 6986787d27bSMichael Roth g_assert(smc->dr_lmb_enabled); 6996787d27bSMichael Roth ret = spapr_populate_drconf_memory(spapr, fdt); 700417ece33SMichael Roth if (ret) { 701417ece33SMichael Roth goto out; 702417ece33SMichael Roth } 7036787d27bSMichael Roth } 7046787d27bSMichael Roth 705417ece33SMichael Roth offset = fdt_path_offset(fdt, "/chosen"); 706417ece33SMichael Roth if (offset < 0) { 707417ece33SMichael Roth offset = fdt_add_subnode(fdt, 0, "chosen"); 708417ece33SMichael Roth if (offset < 0) { 709417ece33SMichael Roth return offset; 710417ece33SMichael Roth } 711417ece33SMichael Roth } 712417ece33SMichael Roth ret = spapr_ovec_populate_dt(fdt, offset, spapr->ov5_cas, 713417ece33SMichael Roth "ibm,architecture-vec-5"); 714417ece33SMichael Roth 715417ece33SMichael Roth out: 7166787d27bSMichael Roth return ret; 7176787d27bSMichael Roth } 7186787d27bSMichael Roth 71903d196b7SBharata B Rao int spapr_h_cas_compose_response(sPAPRMachineState *spapr, 72003d196b7SBharata B Rao target_ulong addr, target_ulong size, 7216787d27bSMichael Roth sPAPROptionVector *ov5_updates) 72203d196b7SBharata B Rao { 72303d196b7SBharata B Rao void *fdt, *fdt_skel; 72403d196b7SBharata B Rao sPAPRDeviceTreeUpdateHeader hdr = { .version_id = 1 }; 72503d196b7SBharata B Rao 72603d196b7SBharata B Rao size -= sizeof(hdr); 72703d196b7SBharata B Rao 72803d196b7SBharata B Rao /* Create sceleton */ 72903d196b7SBharata B Rao fdt_skel = g_malloc0(size); 73003d196b7SBharata B Rao _FDT((fdt_create(fdt_skel, size))); 73103d196b7SBharata B Rao _FDT((fdt_begin_node(fdt_skel, ""))); 73203d196b7SBharata B Rao _FDT((fdt_end_node(fdt_skel))); 73303d196b7SBharata B Rao _FDT((fdt_finish(fdt_skel))); 73403d196b7SBharata B Rao fdt = g_malloc0(size); 73503d196b7SBharata B Rao _FDT((fdt_open_into(fdt_skel, fdt, size))); 73603d196b7SBharata B Rao g_free(fdt_skel); 73703d196b7SBharata B Rao 73803d196b7SBharata B Rao /* Fixup cpu nodes */ 73903d196b7SBharata B Rao _FDT((spapr_fixup_cpu_dt(fdt, spapr))); 74003d196b7SBharata B Rao 7416787d27bSMichael Roth if (spapr_dt_cas_updates(spapr, fdt, ov5_updates)) { 7426787d27bSMichael Roth return -1; 74303d196b7SBharata B Rao } 74403d196b7SBharata B Rao 74503d196b7SBharata B Rao /* Pack resulting tree */ 74603d196b7SBharata B Rao _FDT((fdt_pack(fdt))); 74703d196b7SBharata B Rao 74803d196b7SBharata B Rao if (fdt_totalsize(fdt) + sizeof(hdr) > size) { 74903d196b7SBharata B Rao trace_spapr_cas_failed(size); 75003d196b7SBharata B Rao return -1; 75103d196b7SBharata B Rao } 75203d196b7SBharata B Rao 75303d196b7SBharata B Rao cpu_physical_memory_write(addr, &hdr, sizeof(hdr)); 75403d196b7SBharata B Rao cpu_physical_memory_write(addr + sizeof(hdr), fdt, fdt_totalsize(fdt)); 75503d196b7SBharata B Rao trace_spapr_cas_continue(fdt_totalsize(fdt) + sizeof(hdr)); 75603d196b7SBharata B Rao g_free(fdt); 75703d196b7SBharata B Rao 75803d196b7SBharata B Rao return 0; 75903d196b7SBharata B Rao } 76003d196b7SBharata B Rao 7613f5dabceSDavid Gibson static void spapr_dt_rtas(sPAPRMachineState *spapr, void *fdt) 7623f5dabceSDavid Gibson { 7633f5dabceSDavid Gibson int rtas; 7643f5dabceSDavid Gibson GString *hypertas = g_string_sized_new(256); 7653f5dabceSDavid Gibson GString *qemu_hypertas = g_string_sized_new(256); 7663f5dabceSDavid Gibson uint32_t refpoints[] = { cpu_to_be32(0x4), cpu_to_be32(0x4) }; 7673f5dabceSDavid Gibson uint64_t max_hotplug_addr = spapr->hotplug_memory.base + 7683f5dabceSDavid Gibson memory_region_size(&spapr->hotplug_memory.mr); 7693f5dabceSDavid Gibson uint32_t lrdr_capacity[] = { 7703f5dabceSDavid Gibson cpu_to_be32(max_hotplug_addr >> 32), 7713f5dabceSDavid Gibson cpu_to_be32(max_hotplug_addr & 0xffffffff), 7723f5dabceSDavid Gibson 0, cpu_to_be32(SPAPR_MEMORY_BLOCK_SIZE), 7733f5dabceSDavid Gibson cpu_to_be32(max_cpus / smp_threads), 7743f5dabceSDavid Gibson }; 7753f5dabceSDavid Gibson 7763f5dabceSDavid Gibson _FDT(rtas = fdt_add_subnode(fdt, 0, "rtas")); 7773f5dabceSDavid Gibson 7783f5dabceSDavid Gibson /* hypertas */ 7793f5dabceSDavid Gibson add_str(hypertas, "hcall-pft"); 7803f5dabceSDavid Gibson add_str(hypertas, "hcall-term"); 7813f5dabceSDavid Gibson add_str(hypertas, "hcall-dabr"); 7823f5dabceSDavid Gibson add_str(hypertas, "hcall-interrupt"); 7833f5dabceSDavid Gibson add_str(hypertas, "hcall-tce"); 7843f5dabceSDavid Gibson add_str(hypertas, "hcall-vio"); 7853f5dabceSDavid Gibson add_str(hypertas, "hcall-splpar"); 7863f5dabceSDavid Gibson add_str(hypertas, "hcall-bulk"); 7873f5dabceSDavid Gibson add_str(hypertas, "hcall-set-mode"); 7883f5dabceSDavid Gibson add_str(hypertas, "hcall-sprg0"); 7893f5dabceSDavid Gibson add_str(hypertas, "hcall-copy"); 7903f5dabceSDavid Gibson add_str(hypertas, "hcall-debug"); 7913f5dabceSDavid Gibson add_str(qemu_hypertas, "hcall-memop1"); 7923f5dabceSDavid Gibson 7933f5dabceSDavid Gibson if (!kvm_enabled() || kvmppc_spapr_use_multitce()) { 7943f5dabceSDavid Gibson add_str(hypertas, "hcall-multi-tce"); 7953f5dabceSDavid Gibson } 7963f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,hypertas-functions", 7973f5dabceSDavid Gibson hypertas->str, hypertas->len)); 7983f5dabceSDavid Gibson g_string_free(hypertas, TRUE); 7993f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "qemu,hypertas-functions", 8003f5dabceSDavid Gibson qemu_hypertas->str, qemu_hypertas->len)); 8013f5dabceSDavid Gibson g_string_free(qemu_hypertas, TRUE); 8023f5dabceSDavid Gibson 8033f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,associativity-reference-points", 8043f5dabceSDavid Gibson refpoints, sizeof(refpoints))); 8053f5dabceSDavid Gibson 8063f5dabceSDavid Gibson _FDT(fdt_setprop_cell(fdt, rtas, "rtas-error-log-max", 8073f5dabceSDavid Gibson RTAS_ERROR_LOG_MAX)); 8083f5dabceSDavid Gibson _FDT(fdt_setprop_cell(fdt, rtas, "rtas-event-scan-rate", 8093f5dabceSDavid Gibson RTAS_EVENT_SCAN_RATE)); 8103f5dabceSDavid Gibson 8113f5dabceSDavid Gibson if (msi_nonbroken) { 8123f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,change-msix-capable", NULL, 0)); 8133f5dabceSDavid Gibson } 8143f5dabceSDavid Gibson 8153f5dabceSDavid Gibson /* 8163f5dabceSDavid Gibson * According to PAPR, rtas ibm,os-term does not guarantee a return 8173f5dabceSDavid Gibson * back to the guest cpu. 8183f5dabceSDavid Gibson * 8193f5dabceSDavid Gibson * While an additional ibm,extended-os-term property indicates 8203f5dabceSDavid Gibson * that rtas call return will always occur. Set this property. 8213f5dabceSDavid Gibson */ 8223f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,extended-os-term", NULL, 0)); 8233f5dabceSDavid Gibson 8243f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,lrdr-capacity", 8253f5dabceSDavid Gibson lrdr_capacity, sizeof(lrdr_capacity))); 8263f5dabceSDavid Gibson 8273f5dabceSDavid Gibson spapr_dt_rtas_tokens(fdt, rtas); 8283f5dabceSDavid Gibson } 8293f5dabceSDavid Gibson 8307c866c6aSDavid Gibson static void spapr_dt_chosen(sPAPRMachineState *spapr, void *fdt) 8317c866c6aSDavid Gibson { 8327c866c6aSDavid Gibson MachineState *machine = MACHINE(spapr); 8337c866c6aSDavid Gibson int chosen; 8347c866c6aSDavid Gibson const char *boot_device = machine->boot_order; 8357c866c6aSDavid Gibson char *stdout_path = spapr_vio_stdout_path(spapr->vio_bus); 8367c866c6aSDavid Gibson size_t cb = 0; 8377c866c6aSDavid Gibson char *bootlist = get_boot_devices_list(&cb, true); 8387c866c6aSDavid Gibson 8397c866c6aSDavid Gibson _FDT(chosen = fdt_add_subnode(fdt, 0, "chosen")); 8407c866c6aSDavid Gibson 8417c866c6aSDavid Gibson _FDT(fdt_setprop_string(fdt, chosen, "bootargs", machine->kernel_cmdline)); 8427c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "linux,initrd-start", 8437c866c6aSDavid Gibson spapr->initrd_base)); 8447c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "linux,initrd-end", 8457c866c6aSDavid Gibson spapr->initrd_base + spapr->initrd_size)); 8467c866c6aSDavid Gibson 8477c866c6aSDavid Gibson if (spapr->kernel_size) { 8487c866c6aSDavid Gibson uint64_t kprop[2] = { cpu_to_be64(KERNEL_LOAD_ADDR), 8497c866c6aSDavid Gibson cpu_to_be64(spapr->kernel_size) }; 8507c866c6aSDavid Gibson 8517c866c6aSDavid Gibson _FDT(fdt_setprop(fdt, chosen, "qemu,boot-kernel", 8527c866c6aSDavid Gibson &kprop, sizeof(kprop))); 8537c866c6aSDavid Gibson if (spapr->kernel_le) { 8547c866c6aSDavid Gibson _FDT(fdt_setprop(fdt, chosen, "qemu,boot-kernel-le", NULL, 0)); 8557c866c6aSDavid Gibson } 8567c866c6aSDavid Gibson } 8577c866c6aSDavid Gibson if (boot_menu) { 8587c866c6aSDavid Gibson _FDT((fdt_setprop_cell(fdt, chosen, "qemu,boot-menu", boot_menu))); 8597c866c6aSDavid Gibson } 8607c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "qemu,graphic-width", graphic_width)); 8617c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "qemu,graphic-height", graphic_height)); 8627c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "qemu,graphic-depth", graphic_depth)); 8637c866c6aSDavid Gibson 8647c866c6aSDavid Gibson if (cb && bootlist) { 8657c866c6aSDavid Gibson int i; 8667c866c6aSDavid Gibson 8677c866c6aSDavid Gibson for (i = 0; i < cb; i++) { 8687c866c6aSDavid Gibson if (bootlist[i] == '\n') { 8697c866c6aSDavid Gibson bootlist[i] = ' '; 8707c866c6aSDavid Gibson } 8717c866c6aSDavid Gibson } 8727c866c6aSDavid Gibson _FDT(fdt_setprop_string(fdt, chosen, "qemu,boot-list", bootlist)); 8737c866c6aSDavid Gibson } 8747c866c6aSDavid Gibson 8757c866c6aSDavid Gibson if (boot_device && strlen(boot_device)) { 8767c866c6aSDavid Gibson _FDT(fdt_setprop_string(fdt, chosen, "qemu,boot-device", boot_device)); 8777c866c6aSDavid Gibson } 8787c866c6aSDavid Gibson 8797c866c6aSDavid Gibson if (!spapr->has_graphics && stdout_path) { 8807c866c6aSDavid Gibson _FDT(fdt_setprop_string(fdt, chosen, "linux,stdout-path", stdout_path)); 8817c866c6aSDavid Gibson } 8827c866c6aSDavid Gibson 8837c866c6aSDavid Gibson g_free(stdout_path); 8847c866c6aSDavid Gibson g_free(bootlist); 8857c866c6aSDavid Gibson } 8867c866c6aSDavid Gibson 887fca5f2dcSDavid Gibson static void spapr_dt_hypervisor(sPAPRMachineState *spapr, void *fdt) 888fca5f2dcSDavid Gibson { 889fca5f2dcSDavid Gibson /* The /hypervisor node isn't in PAPR - this is a hack to allow PR 890fca5f2dcSDavid Gibson * KVM to work under pHyp with some guest co-operation */ 891fca5f2dcSDavid Gibson int hypervisor; 892fca5f2dcSDavid Gibson uint8_t hypercall[16]; 893fca5f2dcSDavid Gibson 894fca5f2dcSDavid Gibson _FDT(hypervisor = fdt_add_subnode(fdt, 0, "hypervisor")); 895fca5f2dcSDavid Gibson /* indicate KVM hypercall interface */ 896fca5f2dcSDavid Gibson _FDT(fdt_setprop_string(fdt, hypervisor, "compatible", "linux,kvm")); 897fca5f2dcSDavid Gibson if (kvmppc_has_cap_fixup_hcalls()) { 898fca5f2dcSDavid Gibson /* 899fca5f2dcSDavid Gibson * Older KVM versions with older guest kernels were broken 900fca5f2dcSDavid Gibson * with the magic page, don't allow the guest to map it. 901fca5f2dcSDavid Gibson */ 902fca5f2dcSDavid Gibson if (!kvmppc_get_hypercall(first_cpu->env_ptr, hypercall, 903fca5f2dcSDavid Gibson sizeof(hypercall))) { 904fca5f2dcSDavid Gibson _FDT(fdt_setprop(fdt, hypervisor, "hcall-instructions", 905fca5f2dcSDavid Gibson hypercall, sizeof(hypercall))); 906fca5f2dcSDavid Gibson } 907fca5f2dcSDavid Gibson } 908fca5f2dcSDavid Gibson } 909fca5f2dcSDavid Gibson 910997b6cfcSDavid Gibson static void *spapr_build_fdt(sPAPRMachineState *spapr, 91153018216SPaolo Bonzini hwaddr rtas_addr, 91253018216SPaolo Bonzini hwaddr rtas_size) 91353018216SPaolo Bonzini { 9145b2128d2SAlexander Graf MachineState *machine = MACHINE(qdev_get_machine()); 9153c0c47e3SDavid Gibson MachineClass *mc = MACHINE_GET_CLASS(machine); 916c20d332aSBharata B Rao sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(machine); 9177c866c6aSDavid Gibson int ret; 91853018216SPaolo Bonzini void *fdt; 91953018216SPaolo Bonzini sPAPRPHBState *phb; 920398a0bd5SDavid Gibson char *buf; 92153018216SPaolo Bonzini 922398a0bd5SDavid Gibson fdt = g_malloc0(FDT_MAX_SIZE); 923398a0bd5SDavid Gibson _FDT((fdt_create_empty_tree(fdt, FDT_MAX_SIZE))); 92453018216SPaolo Bonzini 925398a0bd5SDavid Gibson /* Root node */ 926398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "device_type", "chrp")); 927398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "model", "IBM pSeries (emulated by qemu)")); 928398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "compatible", "qemu,pseries")); 929398a0bd5SDavid Gibson 930398a0bd5SDavid Gibson /* 931398a0bd5SDavid Gibson * Add info to guest to indentify which host is it being run on 932398a0bd5SDavid Gibson * and what is the uuid of the guest 933398a0bd5SDavid Gibson */ 934398a0bd5SDavid Gibson if (kvmppc_get_host_model(&buf)) { 935398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "host-model", buf)); 936398a0bd5SDavid Gibson g_free(buf); 937398a0bd5SDavid Gibson } 938398a0bd5SDavid Gibson if (kvmppc_get_host_serial(&buf)) { 939398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "host-serial", buf)); 940398a0bd5SDavid Gibson g_free(buf); 941398a0bd5SDavid Gibson } 942398a0bd5SDavid Gibson 943398a0bd5SDavid Gibson buf = qemu_uuid_unparse_strdup(&qemu_uuid); 944398a0bd5SDavid Gibson 945398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "vm,uuid", buf)); 946398a0bd5SDavid Gibson if (qemu_uuid_set) { 947398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "system-id", buf)); 948398a0bd5SDavid Gibson } 949398a0bd5SDavid Gibson g_free(buf); 950398a0bd5SDavid Gibson 951398a0bd5SDavid Gibson if (qemu_get_vm_name()) { 952398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "ibm,partition-name", 953398a0bd5SDavid Gibson qemu_get_vm_name())); 954398a0bd5SDavid Gibson } 955398a0bd5SDavid Gibson 956398a0bd5SDavid Gibson _FDT(fdt_setprop_cell(fdt, 0, "#address-cells", 2)); 957398a0bd5SDavid Gibson _FDT(fdt_setprop_cell(fdt, 0, "#size-cells", 2)); 95853018216SPaolo Bonzini 9599b9a1908SDavid Gibson /* /interrupt controller */ 960852ad27eSCédric Le Goater spapr_dt_xics(spapr->nr_servers, fdt, PHANDLE_XICP); 9619b9a1908SDavid Gibson 962e8f986fcSBharata B Rao ret = spapr_populate_memory(spapr, fdt); 963e8f986fcSBharata B Rao if (ret < 0) { 964ce9863b7SCédric Le Goater error_report("couldn't setup memory nodes in fdt"); 965e8f986fcSBharata B Rao exit(1); 96653018216SPaolo Bonzini } 96753018216SPaolo Bonzini 968bf5a6696SDavid Gibson /* /vdevice */ 969bf5a6696SDavid Gibson spapr_dt_vdevice(spapr->vio_bus, fdt); 97053018216SPaolo Bonzini 9714d9392beSThomas Huth if (object_resolve_path_type("", TYPE_SPAPR_RNG, NULL)) { 9724d9392beSThomas Huth ret = spapr_rng_populate_dt(fdt); 9734d9392beSThomas Huth if (ret < 0) { 974ce9863b7SCédric Le Goater error_report("could not set up rng device in the fdt"); 9754d9392beSThomas Huth exit(1); 9764d9392beSThomas Huth } 9774d9392beSThomas Huth } 9784d9392beSThomas Huth 97953018216SPaolo Bonzini QLIST_FOREACH(phb, &spapr->phbs, list) { 98053018216SPaolo Bonzini ret = spapr_populate_pci_dt(phb, PHANDLE_XICP, fdt); 98153018216SPaolo Bonzini if (ret < 0) { 982da34fed7SThomas Huth error_report("couldn't setup PCI devices in fdt"); 98353018216SPaolo Bonzini exit(1); 98453018216SPaolo Bonzini } 985da34fed7SThomas Huth } 98653018216SPaolo Bonzini 9870da6f3feSBharata B Rao /* cpus */ 9880da6f3feSBharata B Rao spapr_populate_cpus_dt_node(fdt, spapr); 98953018216SPaolo Bonzini 990c20d332aSBharata B Rao if (smc->dr_lmb_enabled) { 991c20d332aSBharata B Rao _FDT(spapr_drc_populate_dt(fdt, 0, NULL, SPAPR_DR_CONNECTOR_TYPE_LMB)); 992c20d332aSBharata B Rao } 993c20d332aSBharata B Rao 994c5514d0eSIgor Mammedov if (mc->has_hotpluggable_cpus) { 995af81cf32SBharata B Rao int offset = fdt_path_offset(fdt, "/cpus"); 996af81cf32SBharata B Rao ret = spapr_drc_populate_dt(fdt, offset, NULL, 997af81cf32SBharata B Rao SPAPR_DR_CONNECTOR_TYPE_CPU); 998af81cf32SBharata B Rao if (ret < 0) { 999af81cf32SBharata B Rao error_report("Couldn't set up CPU DR device tree properties"); 1000af81cf32SBharata B Rao exit(1); 1001af81cf32SBharata B Rao } 1002af81cf32SBharata B Rao } 1003af81cf32SBharata B Rao 1004ffb1e275SDavid Gibson /* /event-sources */ 1005ffbb1705SMichael Roth spapr_dt_events(spapr, fdt); 1006ffb1e275SDavid Gibson 10073f5dabceSDavid Gibson /* /rtas */ 10083f5dabceSDavid Gibson spapr_dt_rtas(spapr, fdt); 10093f5dabceSDavid Gibson 10107c866c6aSDavid Gibson /* /chosen */ 10117c866c6aSDavid Gibson spapr_dt_chosen(spapr, fdt); 1012cf6e5223SDavid Gibson 1013fca5f2dcSDavid Gibson /* /hypervisor */ 1014fca5f2dcSDavid Gibson if (kvm_enabled()) { 1015fca5f2dcSDavid Gibson spapr_dt_hypervisor(spapr, fdt); 1016fca5f2dcSDavid Gibson } 1017fca5f2dcSDavid Gibson 1018cf6e5223SDavid Gibson /* Build memory reserve map */ 1019cf6e5223SDavid Gibson if (spapr->kernel_size) { 1020cf6e5223SDavid Gibson _FDT((fdt_add_mem_rsv(fdt, KERNEL_LOAD_ADDR, spapr->kernel_size))); 1021cf6e5223SDavid Gibson } 1022cf6e5223SDavid Gibson if (spapr->initrd_size) { 1023cf6e5223SDavid Gibson _FDT((fdt_add_mem_rsv(fdt, spapr->initrd_base, spapr->initrd_size))); 1024cf6e5223SDavid Gibson } 1025cf6e5223SDavid Gibson 10266787d27bSMichael Roth /* ibm,client-architecture-support updates */ 10276787d27bSMichael Roth ret = spapr_dt_cas_updates(spapr, fdt, spapr->ov5_cas); 10286787d27bSMichael Roth if (ret < 0) { 10296787d27bSMichael Roth error_report("couldn't setup CAS properties fdt"); 10306787d27bSMichael Roth exit(1); 10316787d27bSMichael Roth } 10326787d27bSMichael Roth 1033997b6cfcSDavid Gibson return fdt; 103453018216SPaolo Bonzini } 103553018216SPaolo Bonzini 103653018216SPaolo Bonzini static uint64_t translate_kernel_address(void *opaque, uint64_t addr) 103753018216SPaolo Bonzini { 103853018216SPaolo Bonzini return (addr & 0x0fffffff) + KERNEL_LOAD_ADDR; 103953018216SPaolo Bonzini } 104053018216SPaolo Bonzini 10411d1be34dSDavid Gibson static void emulate_spapr_hypercall(PPCVirtualHypervisor *vhyp, 10421d1be34dSDavid Gibson PowerPCCPU *cpu) 104353018216SPaolo Bonzini { 104453018216SPaolo Bonzini CPUPPCState *env = &cpu->env; 104553018216SPaolo Bonzini 10468d04fb55SJan Kiszka /* The TCG path should also be holding the BQL at this point */ 10478d04fb55SJan Kiszka g_assert(qemu_mutex_iothread_locked()); 10488d04fb55SJan Kiszka 104953018216SPaolo Bonzini if (msr_pr) { 105053018216SPaolo Bonzini hcall_dprintf("Hypercall made with MSR[PR]=1\n"); 105153018216SPaolo Bonzini env->gpr[3] = H_PRIVILEGE; 105253018216SPaolo Bonzini } else { 105353018216SPaolo Bonzini env->gpr[3] = spapr_hypercall(cpu, env->gpr[3], &env->gpr[4]); 105453018216SPaolo Bonzini } 105553018216SPaolo Bonzini } 105653018216SPaolo Bonzini 1057e6b8fd24SSamuel Mendoza-Jonas #define HPTE(_table, _i) (void *)(((uint64_t *)(_table)) + ((_i) * 2)) 1058e6b8fd24SSamuel Mendoza-Jonas #define HPTE_VALID(_hpte) (tswap64(*((uint64_t *)(_hpte))) & HPTE64_V_VALID) 1059e6b8fd24SSamuel Mendoza-Jonas #define HPTE_DIRTY(_hpte) (tswap64(*((uint64_t *)(_hpte))) & HPTE64_V_HPTE_DIRTY) 1060e6b8fd24SSamuel Mendoza-Jonas #define CLEAN_HPTE(_hpte) ((*(uint64_t *)(_hpte)) &= tswap64(~HPTE64_V_HPTE_DIRTY)) 1061e6b8fd24SSamuel Mendoza-Jonas #define DIRTY_HPTE(_hpte) ((*(uint64_t *)(_hpte)) |= tswap64(HPTE64_V_HPTE_DIRTY)) 1062e6b8fd24SSamuel Mendoza-Jonas 1063715c5407SDavid Gibson /* 1064715c5407SDavid Gibson * Get the fd to access the kernel htab, re-opening it if necessary 1065715c5407SDavid Gibson */ 1066715c5407SDavid Gibson static int get_htab_fd(sPAPRMachineState *spapr) 1067715c5407SDavid Gibson { 1068715c5407SDavid Gibson if (spapr->htab_fd >= 0) { 1069715c5407SDavid Gibson return spapr->htab_fd; 1070715c5407SDavid Gibson } 1071715c5407SDavid Gibson 1072715c5407SDavid Gibson spapr->htab_fd = kvmppc_get_htab_fd(false); 1073715c5407SDavid Gibson if (spapr->htab_fd < 0) { 1074715c5407SDavid Gibson error_report("Unable to open fd for reading hash table from KVM: %s", 1075715c5407SDavid Gibson strerror(errno)); 1076715c5407SDavid Gibson } 1077715c5407SDavid Gibson 1078715c5407SDavid Gibson return spapr->htab_fd; 1079715c5407SDavid Gibson } 1080715c5407SDavid Gibson 1081715c5407SDavid Gibson static void close_htab_fd(sPAPRMachineState *spapr) 1082715c5407SDavid Gibson { 1083715c5407SDavid Gibson if (spapr->htab_fd >= 0) { 1084715c5407SDavid Gibson close(spapr->htab_fd); 1085715c5407SDavid Gibson } 1086715c5407SDavid Gibson spapr->htab_fd = -1; 1087715c5407SDavid Gibson } 1088715c5407SDavid Gibson 1089e57ca75cSDavid Gibson static hwaddr spapr_hpt_mask(PPCVirtualHypervisor *vhyp) 1090e57ca75cSDavid Gibson { 1091e57ca75cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 1092e57ca75cSDavid Gibson 1093e57ca75cSDavid Gibson return HTAB_SIZE(spapr) / HASH_PTEG_SIZE_64 - 1; 1094e57ca75cSDavid Gibson } 1095e57ca75cSDavid Gibson 1096e57ca75cSDavid Gibson static const ppc_hash_pte64_t *spapr_map_hptes(PPCVirtualHypervisor *vhyp, 1097e57ca75cSDavid Gibson hwaddr ptex, int n) 1098e57ca75cSDavid Gibson { 1099e57ca75cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 1100e57ca75cSDavid Gibson hwaddr pte_offset = ptex * HASH_PTE_SIZE_64; 1101e57ca75cSDavid Gibson 1102e57ca75cSDavid Gibson if (!spapr->htab) { 1103e57ca75cSDavid Gibson /* 1104e57ca75cSDavid Gibson * HTAB is controlled by KVM. Fetch into temporary buffer 1105e57ca75cSDavid Gibson */ 1106e57ca75cSDavid Gibson ppc_hash_pte64_t *hptes = g_malloc(n * HASH_PTE_SIZE_64); 1107e57ca75cSDavid Gibson kvmppc_read_hptes(hptes, ptex, n); 1108e57ca75cSDavid Gibson return hptes; 1109e57ca75cSDavid Gibson } 1110e57ca75cSDavid Gibson 1111e57ca75cSDavid Gibson /* 1112e57ca75cSDavid Gibson * HTAB is controlled by QEMU. Just point to the internally 1113e57ca75cSDavid Gibson * accessible PTEG. 1114e57ca75cSDavid Gibson */ 1115e57ca75cSDavid Gibson return (const ppc_hash_pte64_t *)(spapr->htab + pte_offset); 1116e57ca75cSDavid Gibson } 1117e57ca75cSDavid Gibson 1118e57ca75cSDavid Gibson static void spapr_unmap_hptes(PPCVirtualHypervisor *vhyp, 1119e57ca75cSDavid Gibson const ppc_hash_pte64_t *hptes, 1120e57ca75cSDavid Gibson hwaddr ptex, int n) 1121e57ca75cSDavid Gibson { 1122e57ca75cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 1123e57ca75cSDavid Gibson 1124e57ca75cSDavid Gibson if (!spapr->htab) { 1125e57ca75cSDavid Gibson g_free((void *)hptes); 1126e57ca75cSDavid Gibson } 1127e57ca75cSDavid Gibson 1128e57ca75cSDavid Gibson /* Nothing to do for qemu managed HPT */ 1129e57ca75cSDavid Gibson } 1130e57ca75cSDavid Gibson 1131e57ca75cSDavid Gibson static void spapr_store_hpte(PPCVirtualHypervisor *vhyp, hwaddr ptex, 1132e57ca75cSDavid Gibson uint64_t pte0, uint64_t pte1) 1133e57ca75cSDavid Gibson { 1134e57ca75cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 1135e57ca75cSDavid Gibson hwaddr offset = ptex * HASH_PTE_SIZE_64; 1136e57ca75cSDavid Gibson 1137e57ca75cSDavid Gibson if (!spapr->htab) { 1138e57ca75cSDavid Gibson kvmppc_write_hpte(ptex, pte0, pte1); 1139e57ca75cSDavid Gibson } else { 1140e57ca75cSDavid Gibson stq_p(spapr->htab + offset, pte0); 1141e57ca75cSDavid Gibson stq_p(spapr->htab + offset + HASH_PTE_SIZE_64 / 2, pte1); 1142e57ca75cSDavid Gibson } 1143e57ca75cSDavid Gibson } 1144e57ca75cSDavid Gibson 11458dfe8e7fSDavid Gibson static int spapr_hpt_shift_for_ramsize(uint64_t ramsize) 11468dfe8e7fSDavid Gibson { 11478dfe8e7fSDavid Gibson int shift; 11488dfe8e7fSDavid Gibson 11498dfe8e7fSDavid Gibson /* We aim for a hash table of size 1/128 the size of RAM (rounded 11508dfe8e7fSDavid Gibson * up). The PAPR recommendation is actually 1/64 of RAM size, but 11518dfe8e7fSDavid Gibson * that's much more than is needed for Linux guests */ 11528dfe8e7fSDavid Gibson shift = ctz64(pow2ceil(ramsize)) - 7; 11538dfe8e7fSDavid Gibson shift = MAX(shift, 18); /* Minimum architected size */ 11548dfe8e7fSDavid Gibson shift = MIN(shift, 46); /* Maximum architected size */ 11558dfe8e7fSDavid Gibson return shift; 11568dfe8e7fSDavid Gibson } 11578dfe8e7fSDavid Gibson 1158c5f54f3eSDavid Gibson static void spapr_reallocate_hpt(sPAPRMachineState *spapr, int shift, 1159c5f54f3eSDavid Gibson Error **errp) 116053018216SPaolo Bonzini { 1161c5f54f3eSDavid Gibson long rc; 116253018216SPaolo Bonzini 1163c5f54f3eSDavid Gibson /* Clean up any HPT info from a previous boot */ 1164c5f54f3eSDavid Gibson g_free(spapr->htab); 1165c5f54f3eSDavid Gibson spapr->htab = NULL; 1166c5f54f3eSDavid Gibson spapr->htab_shift = 0; 1167c5f54f3eSDavid Gibson close_htab_fd(spapr); 116853018216SPaolo Bonzini 1169c5f54f3eSDavid Gibson rc = kvmppc_reset_htab(shift); 1170c5f54f3eSDavid Gibson if (rc < 0) { 1171c5f54f3eSDavid Gibson /* kernel-side HPT needed, but couldn't allocate one */ 1172c5f54f3eSDavid Gibson error_setg_errno(errp, errno, 1173c5f54f3eSDavid Gibson "Failed to allocate KVM HPT of order %d (try smaller maxmem?)", 1174c5f54f3eSDavid Gibson shift); 1175c5f54f3eSDavid Gibson /* This is almost certainly fatal, but if the caller really 1176c5f54f3eSDavid Gibson * wants to carry on with shift == 0, it's welcome to try */ 1177c5f54f3eSDavid Gibson } else if (rc > 0) { 1178c5f54f3eSDavid Gibson /* kernel-side HPT allocated */ 1179c5f54f3eSDavid Gibson if (rc != shift) { 1180c5f54f3eSDavid Gibson error_setg(errp, 1181c5f54f3eSDavid Gibson "Requested order %d HPT, but kernel allocated order %ld (try smaller maxmem?)", 1182c5f54f3eSDavid Gibson shift, rc); 11837735fedaSBharata B Rao } 11847735fedaSBharata B Rao 118553018216SPaolo Bonzini spapr->htab_shift = shift; 1186c18ad9a5SDavid Gibson spapr->htab = NULL; 1187b817772aSBharata B Rao } else { 1188c5f54f3eSDavid Gibson /* kernel-side HPT not needed, allocate in userspace instead */ 1189c5f54f3eSDavid Gibson size_t size = 1ULL << shift; 1190c5f54f3eSDavid Gibson int i; 119101a57972SSamuel Mendoza-Jonas 1192c5f54f3eSDavid Gibson spapr->htab = qemu_memalign(size, size); 1193c5f54f3eSDavid Gibson if (!spapr->htab) { 1194c5f54f3eSDavid Gibson error_setg_errno(errp, errno, 1195c5f54f3eSDavid Gibson "Could not allocate HPT of order %d", shift); 1196c5f54f3eSDavid Gibson return; 1197b817772aSBharata B Rao } 1198b817772aSBharata B Rao 1199c5f54f3eSDavid Gibson memset(spapr->htab, 0, size); 1200c5f54f3eSDavid Gibson spapr->htab_shift = shift; 1201b817772aSBharata B Rao 1202c5f54f3eSDavid Gibson for (i = 0; i < size / HASH_PTE_SIZE_64; i++) { 1203c5f54f3eSDavid Gibson DIRTY_HPTE(HPTE(spapr->htab, i)); 12047735fedaSBharata B Rao } 120553018216SPaolo Bonzini } 120653018216SPaolo Bonzini } 120753018216SPaolo Bonzini 12084f01a637SDavid Gibson static void find_unknown_sysbus_device(SysBusDevice *sbdev, void *opaque) 12099e3f9733SAlexander Graf { 12109e3f9733SAlexander Graf bool matched = false; 12119e3f9733SAlexander Graf 12129e3f9733SAlexander Graf if (object_dynamic_cast(OBJECT(sbdev), TYPE_SPAPR_PCI_HOST_BRIDGE)) { 12139e3f9733SAlexander Graf matched = true; 12149e3f9733SAlexander Graf } 12159e3f9733SAlexander Graf 12169e3f9733SAlexander Graf if (!matched) { 12179e3f9733SAlexander Graf error_report("Device %s is not supported by this machine yet.", 12189e3f9733SAlexander Graf qdev_fw_name(DEVICE(sbdev))); 12199e3f9733SAlexander Graf exit(1); 12209e3f9733SAlexander Graf } 12219e3f9733SAlexander Graf } 12229e3f9733SAlexander Graf 122353018216SPaolo Bonzini static void ppc_spapr_reset(void) 122453018216SPaolo Bonzini { 1225c5f54f3eSDavid Gibson MachineState *machine = MACHINE(qdev_get_machine()); 1226c5f54f3eSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(machine); 1227182735efSAndreas Färber PowerPCCPU *first_ppc_cpu; 1228b7d1f77aSBenjamin Herrenschmidt uint32_t rtas_limit; 1229cae172abSDavid Gibson hwaddr rtas_addr, fdt_addr; 1230997b6cfcSDavid Gibson void *fdt; 1231997b6cfcSDavid Gibson int rc; 1232259186a7SAndreas Färber 12339e3f9733SAlexander Graf /* Check for unknown sysbus devices */ 12349e3f9733SAlexander Graf foreach_dynamic_sysbus_device(find_unknown_sysbus_device, NULL); 12359e3f9733SAlexander Graf 1236c5f54f3eSDavid Gibson /* Allocate and/or reset the hash page table */ 1237c5f54f3eSDavid Gibson spapr_reallocate_hpt(spapr, 1238c5f54f3eSDavid Gibson spapr_hpt_shift_for_ramsize(machine->maxram_size), 1239c5f54f3eSDavid Gibson &error_fatal); 1240c5f54f3eSDavid Gibson 1241c5f54f3eSDavid Gibson /* Update the RMA size if necessary */ 1242c5f54f3eSDavid Gibson if (spapr->vrma_adjust) { 1243c5f54f3eSDavid Gibson spapr->rma_size = kvmppc_rma_size(spapr_node0_size(), 1244c5f54f3eSDavid Gibson spapr->htab_shift); 1245c5f54f3eSDavid Gibson } 124653018216SPaolo Bonzini 124753018216SPaolo Bonzini qemu_devices_reset(); 124853018216SPaolo Bonzini 1249b7d1f77aSBenjamin Herrenschmidt /* 1250b7d1f77aSBenjamin Herrenschmidt * We place the device tree and RTAS just below either the top of the RMA, 1251b7d1f77aSBenjamin Herrenschmidt * or just below 2GB, whichever is lowere, so that it can be 1252b7d1f77aSBenjamin Herrenschmidt * processed with 32-bit real mode code if necessary 1253b7d1f77aSBenjamin Herrenschmidt */ 1254b7d1f77aSBenjamin Herrenschmidt rtas_limit = MIN(spapr->rma_size, RTAS_MAX_ADDR); 1255cae172abSDavid Gibson rtas_addr = rtas_limit - RTAS_MAX_SIZE; 1256cae172abSDavid Gibson fdt_addr = rtas_addr - FDT_MAX_SIZE; 1257b7d1f77aSBenjamin Herrenschmidt 12586787d27bSMichael Roth /* if this reset wasn't generated by CAS, we should reset our 12596787d27bSMichael Roth * negotiated options and start from scratch */ 12606787d27bSMichael Roth if (!spapr->cas_reboot) { 12616787d27bSMichael Roth spapr_ovec_cleanup(spapr->ov5_cas); 12626787d27bSMichael Roth spapr->ov5_cas = spapr_ovec_new(); 12636787d27bSMichael Roth } 12646787d27bSMichael Roth 1265cae172abSDavid Gibson fdt = spapr_build_fdt(spapr, rtas_addr, spapr->rtas_size); 126653018216SPaolo Bonzini 12672cac78c1SDavid Gibson spapr_load_rtas(spapr, fdt, rtas_addr); 1268b7d1f77aSBenjamin Herrenschmidt 1269997b6cfcSDavid Gibson rc = fdt_pack(fdt); 1270997b6cfcSDavid Gibson 1271997b6cfcSDavid Gibson /* Should only fail if we've built a corrupted tree */ 1272997b6cfcSDavid Gibson assert(rc == 0); 1273997b6cfcSDavid Gibson 1274997b6cfcSDavid Gibson if (fdt_totalsize(fdt) > FDT_MAX_SIZE) { 1275997b6cfcSDavid Gibson error_report("FDT too big ! 0x%x bytes (max is 0x%x)", 1276997b6cfcSDavid Gibson fdt_totalsize(fdt), FDT_MAX_SIZE); 1277997b6cfcSDavid Gibson exit(1); 1278997b6cfcSDavid Gibson } 1279997b6cfcSDavid Gibson 1280997b6cfcSDavid Gibson /* Load the fdt */ 1281997b6cfcSDavid Gibson qemu_fdt_dumpdtb(fdt, fdt_totalsize(fdt)); 1282cae172abSDavid Gibson cpu_physical_memory_write(fdt_addr, fdt, fdt_totalsize(fdt)); 1283997b6cfcSDavid Gibson g_free(fdt); 1284997b6cfcSDavid Gibson 128553018216SPaolo Bonzini /* Set up the entry state */ 1286182735efSAndreas Färber first_ppc_cpu = POWERPC_CPU(first_cpu); 1287cae172abSDavid Gibson first_ppc_cpu->env.gpr[3] = fdt_addr; 1288182735efSAndreas Färber first_ppc_cpu->env.gpr[5] = 0; 1289182735efSAndreas Färber first_cpu->halted = 0; 12901b718907SDavid Gibson first_ppc_cpu->env.nip = SPAPR_ENTRY_POINT; 129153018216SPaolo Bonzini 12926787d27bSMichael Roth spapr->cas_reboot = false; 129353018216SPaolo Bonzini } 129453018216SPaolo Bonzini 129528e02042SDavid Gibson static void spapr_create_nvram(sPAPRMachineState *spapr) 129653018216SPaolo Bonzini { 12972ff3de68SMarkus Armbruster DeviceState *dev = qdev_create(&spapr->vio_bus->bus, "spapr-nvram"); 12983978b863SPaolo Bonzini DriveInfo *dinfo = drive_get(IF_PFLASH, 0, 0); 129953018216SPaolo Bonzini 13003978b863SPaolo Bonzini if (dinfo) { 13016231a6daSMarkus Armbruster qdev_prop_set_drive(dev, "drive", blk_by_legacy_dinfo(dinfo), 13026231a6daSMarkus Armbruster &error_fatal); 130353018216SPaolo Bonzini } 130453018216SPaolo Bonzini 130553018216SPaolo Bonzini qdev_init_nofail(dev); 130653018216SPaolo Bonzini 130753018216SPaolo Bonzini spapr->nvram = (struct sPAPRNVRAM *)dev; 130853018216SPaolo Bonzini } 130953018216SPaolo Bonzini 131028e02042SDavid Gibson static void spapr_rtc_create(sPAPRMachineState *spapr) 131128df36a1SDavid Gibson { 131228df36a1SDavid Gibson DeviceState *dev = qdev_create(NULL, TYPE_SPAPR_RTC); 131328df36a1SDavid Gibson 131428df36a1SDavid Gibson qdev_init_nofail(dev); 131528df36a1SDavid Gibson spapr->rtc = dev; 131674e5ae28SDavid Gibson 131774e5ae28SDavid Gibson object_property_add_alias(qdev_get_machine(), "rtc-time", 131874e5ae28SDavid Gibson OBJECT(spapr->rtc), "date", NULL); 131928df36a1SDavid Gibson } 132028df36a1SDavid Gibson 132153018216SPaolo Bonzini /* Returns whether we want to use VGA or not */ 132214c6a894SDavid Gibson static bool spapr_vga_init(PCIBus *pci_bus, Error **errp) 132353018216SPaolo Bonzini { 132453018216SPaolo Bonzini switch (vga_interface_type) { 132553018216SPaolo Bonzini case VGA_NONE: 13267effdaa3SMark Wu return false; 13277effdaa3SMark Wu case VGA_DEVICE: 13287effdaa3SMark Wu return true; 132953018216SPaolo Bonzini case VGA_STD: 1330b798c190SBenjamin Herrenschmidt case VGA_VIRTIO: 133153018216SPaolo Bonzini return pci_vga_init(pci_bus) != NULL; 133253018216SPaolo Bonzini default: 133314c6a894SDavid Gibson error_setg(errp, 133414c6a894SDavid Gibson "Unsupported VGA mode, only -vga std or -vga virtio is supported"); 133514c6a894SDavid Gibson return false; 133653018216SPaolo Bonzini } 133753018216SPaolo Bonzini } 133853018216SPaolo Bonzini 1339880ae7deSDavid Gibson static int spapr_post_load(void *opaque, int version_id) 1340880ae7deSDavid Gibson { 134128e02042SDavid Gibson sPAPRMachineState *spapr = (sPAPRMachineState *)opaque; 1342880ae7deSDavid Gibson int err = 0; 1343880ae7deSDavid Gibson 1344631b22eaSStefan Weil /* In earlier versions, there was no separate qdev for the PAPR 1345880ae7deSDavid Gibson * RTC, so the RTC offset was stored directly in sPAPREnvironment. 1346880ae7deSDavid Gibson * So when migrating from those versions, poke the incoming offset 1347880ae7deSDavid Gibson * value into the RTC device */ 1348880ae7deSDavid Gibson if (version_id < 3) { 1349880ae7deSDavid Gibson err = spapr_rtc_import_offset(spapr->rtc, spapr->rtc_offset); 1350880ae7deSDavid Gibson } 1351880ae7deSDavid Gibson 1352880ae7deSDavid Gibson return err; 1353880ae7deSDavid Gibson } 1354880ae7deSDavid Gibson 1355880ae7deSDavid Gibson static bool version_before_3(void *opaque, int version_id) 1356880ae7deSDavid Gibson { 1357880ae7deSDavid Gibson return version_id < 3; 1358880ae7deSDavid Gibson } 1359880ae7deSDavid Gibson 136062ef3760SMichael Roth static bool spapr_ov5_cas_needed(void *opaque) 136162ef3760SMichael Roth { 136262ef3760SMichael Roth sPAPRMachineState *spapr = opaque; 136362ef3760SMichael Roth sPAPROptionVector *ov5_mask = spapr_ovec_new(); 136462ef3760SMichael Roth sPAPROptionVector *ov5_legacy = spapr_ovec_new(); 136562ef3760SMichael Roth sPAPROptionVector *ov5_removed = spapr_ovec_new(); 136662ef3760SMichael Roth bool cas_needed; 136762ef3760SMichael Roth 136862ef3760SMichael Roth /* Prior to the introduction of sPAPROptionVector, we had two option 136962ef3760SMichael Roth * vectors we dealt with: OV5_FORM1_AFFINITY, and OV5_DRCONF_MEMORY. 137062ef3760SMichael Roth * Both of these options encode machine topology into the device-tree 137162ef3760SMichael Roth * in such a way that the now-booted OS should still be able to interact 137262ef3760SMichael Roth * appropriately with QEMU regardless of what options were actually 137362ef3760SMichael Roth * negotiatied on the source side. 137462ef3760SMichael Roth * 137562ef3760SMichael Roth * As such, we can avoid migrating the CAS-negotiated options if these 137662ef3760SMichael Roth * are the only options available on the current machine/platform. 137762ef3760SMichael Roth * Since these are the only options available for pseries-2.7 and 137862ef3760SMichael Roth * earlier, this allows us to maintain old->new/new->old migration 137962ef3760SMichael Roth * compatibility. 138062ef3760SMichael Roth * 138162ef3760SMichael Roth * For QEMU 2.8+, there are additional CAS-negotiatable options available 138262ef3760SMichael Roth * via default pseries-2.8 machines and explicit command-line parameters. 138362ef3760SMichael Roth * Some of these options, like OV5_HP_EVT, *do* require QEMU to be aware 138462ef3760SMichael Roth * of the actual CAS-negotiated values to continue working properly. For 138562ef3760SMichael Roth * example, availability of memory unplug depends on knowing whether 138662ef3760SMichael Roth * OV5_HP_EVT was negotiated via CAS. 138762ef3760SMichael Roth * 138862ef3760SMichael Roth * Thus, for any cases where the set of available CAS-negotiatable 138962ef3760SMichael Roth * options extends beyond OV5_FORM1_AFFINITY and OV5_DRCONF_MEMORY, we 139062ef3760SMichael Roth * include the CAS-negotiated options in the migration stream. 139162ef3760SMichael Roth */ 139262ef3760SMichael Roth spapr_ovec_set(ov5_mask, OV5_FORM1_AFFINITY); 139362ef3760SMichael Roth spapr_ovec_set(ov5_mask, OV5_DRCONF_MEMORY); 139462ef3760SMichael Roth 139562ef3760SMichael Roth /* spapr_ovec_diff returns true if bits were removed. we avoid using 139662ef3760SMichael Roth * the mask itself since in the future it's possible "legacy" bits may be 139762ef3760SMichael Roth * removed via machine options, which could generate a false positive 139862ef3760SMichael Roth * that breaks migration. 139962ef3760SMichael Roth */ 140062ef3760SMichael Roth spapr_ovec_intersect(ov5_legacy, spapr->ov5, ov5_mask); 140162ef3760SMichael Roth cas_needed = spapr_ovec_diff(ov5_removed, spapr->ov5, ov5_legacy); 140262ef3760SMichael Roth 140362ef3760SMichael Roth spapr_ovec_cleanup(ov5_mask); 140462ef3760SMichael Roth spapr_ovec_cleanup(ov5_legacy); 140562ef3760SMichael Roth spapr_ovec_cleanup(ov5_removed); 140662ef3760SMichael Roth 140762ef3760SMichael Roth return cas_needed; 140862ef3760SMichael Roth } 140962ef3760SMichael Roth 141062ef3760SMichael Roth static const VMStateDescription vmstate_spapr_ov5_cas = { 141162ef3760SMichael Roth .name = "spapr_option_vector_ov5_cas", 141262ef3760SMichael Roth .version_id = 1, 141362ef3760SMichael Roth .minimum_version_id = 1, 141462ef3760SMichael Roth .needed = spapr_ov5_cas_needed, 141562ef3760SMichael Roth .fields = (VMStateField[]) { 141662ef3760SMichael Roth VMSTATE_STRUCT_POINTER_V(ov5_cas, sPAPRMachineState, 1, 141762ef3760SMichael Roth vmstate_spapr_ovec, sPAPROptionVector), 141862ef3760SMichael Roth VMSTATE_END_OF_LIST() 141962ef3760SMichael Roth }, 142062ef3760SMichael Roth }; 142162ef3760SMichael Roth 14224be21d56SDavid Gibson static const VMStateDescription vmstate_spapr = { 14234be21d56SDavid Gibson .name = "spapr", 1424880ae7deSDavid Gibson .version_id = 3, 14254be21d56SDavid Gibson .minimum_version_id = 1, 1426880ae7deSDavid Gibson .post_load = spapr_post_load, 14274be21d56SDavid Gibson .fields = (VMStateField[]) { 1428880ae7deSDavid Gibson /* used to be @next_irq */ 1429880ae7deSDavid Gibson VMSTATE_UNUSED_BUFFER(version_before_3, 0, 4), 14304be21d56SDavid Gibson 14314be21d56SDavid Gibson /* RTC offset */ 143228e02042SDavid Gibson VMSTATE_UINT64_TEST(rtc_offset, sPAPRMachineState, version_before_3), 1433880ae7deSDavid Gibson 143428e02042SDavid Gibson VMSTATE_PPC_TIMEBASE_V(tb, sPAPRMachineState, 2), 14354be21d56SDavid Gibson VMSTATE_END_OF_LIST() 14364be21d56SDavid Gibson }, 143762ef3760SMichael Roth .subsections = (const VMStateDescription*[]) { 143862ef3760SMichael Roth &vmstate_spapr_ov5_cas, 143962ef3760SMichael Roth NULL 144062ef3760SMichael Roth } 14414be21d56SDavid Gibson }; 14424be21d56SDavid Gibson 14434be21d56SDavid Gibson static int htab_save_setup(QEMUFile *f, void *opaque) 14444be21d56SDavid Gibson { 144528e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 14464be21d56SDavid Gibson 14474be21d56SDavid Gibson /* "Iteration" header */ 14484be21d56SDavid Gibson qemu_put_be32(f, spapr->htab_shift); 14494be21d56SDavid Gibson 1450e68cb8b4SAlexey Kardashevskiy if (spapr->htab) { 1451e68cb8b4SAlexey Kardashevskiy spapr->htab_save_index = 0; 1452e68cb8b4SAlexey Kardashevskiy spapr->htab_first_pass = true; 1453e68cb8b4SAlexey Kardashevskiy } else { 1454e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 14554be21d56SDavid Gibson } 14564be21d56SDavid Gibson 1457e68cb8b4SAlexey Kardashevskiy 1458e68cb8b4SAlexey Kardashevskiy return 0; 1459e68cb8b4SAlexey Kardashevskiy } 14604be21d56SDavid Gibson 146128e02042SDavid Gibson static void htab_save_first_pass(QEMUFile *f, sPAPRMachineState *spapr, 14624be21d56SDavid Gibson int64_t max_ns) 14634be21d56SDavid Gibson { 1464378bc217SDavid Gibson bool has_timeout = max_ns != -1; 14654be21d56SDavid Gibson int htabslots = HTAB_SIZE(spapr) / HASH_PTE_SIZE_64; 14664be21d56SDavid Gibson int index = spapr->htab_save_index; 1467bc72ad67SAlex Bligh int64_t starttime = qemu_clock_get_ns(QEMU_CLOCK_REALTIME); 14684be21d56SDavid Gibson 14694be21d56SDavid Gibson assert(spapr->htab_first_pass); 14704be21d56SDavid Gibson 14714be21d56SDavid Gibson do { 14724be21d56SDavid Gibson int chunkstart; 14734be21d56SDavid Gibson 14744be21d56SDavid Gibson /* Consume invalid HPTEs */ 14754be21d56SDavid Gibson while ((index < htabslots) 14764be21d56SDavid Gibson && !HPTE_VALID(HPTE(spapr->htab, index))) { 14774be21d56SDavid Gibson index++; 14784be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 14794be21d56SDavid Gibson } 14804be21d56SDavid Gibson 14814be21d56SDavid Gibson /* Consume valid HPTEs */ 14824be21d56SDavid Gibson chunkstart = index; 1483338c25b6SSamuel Mendoza-Jonas while ((index < htabslots) && (index - chunkstart < USHRT_MAX) 14844be21d56SDavid Gibson && HPTE_VALID(HPTE(spapr->htab, index))) { 14854be21d56SDavid Gibson index++; 14864be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 14874be21d56SDavid Gibson } 14884be21d56SDavid Gibson 14894be21d56SDavid Gibson if (index > chunkstart) { 14904be21d56SDavid Gibson int n_valid = index - chunkstart; 14914be21d56SDavid Gibson 14924be21d56SDavid Gibson qemu_put_be32(f, chunkstart); 14934be21d56SDavid Gibson qemu_put_be16(f, n_valid); 14944be21d56SDavid Gibson qemu_put_be16(f, 0); 14954be21d56SDavid Gibson qemu_put_buffer(f, HPTE(spapr->htab, chunkstart), 14964be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_valid); 14974be21d56SDavid Gibson 1498378bc217SDavid Gibson if (has_timeout && 1499378bc217SDavid Gibson (qemu_clock_get_ns(QEMU_CLOCK_REALTIME) - starttime) > max_ns) { 15004be21d56SDavid Gibson break; 15014be21d56SDavid Gibson } 15024be21d56SDavid Gibson } 15034be21d56SDavid Gibson } while ((index < htabslots) && !qemu_file_rate_limit(f)); 15044be21d56SDavid Gibson 15054be21d56SDavid Gibson if (index >= htabslots) { 15064be21d56SDavid Gibson assert(index == htabslots); 15074be21d56SDavid Gibson index = 0; 15084be21d56SDavid Gibson spapr->htab_first_pass = false; 15094be21d56SDavid Gibson } 15104be21d56SDavid Gibson spapr->htab_save_index = index; 15114be21d56SDavid Gibson } 15124be21d56SDavid Gibson 151328e02042SDavid Gibson static int htab_save_later_pass(QEMUFile *f, sPAPRMachineState *spapr, 15144be21d56SDavid Gibson int64_t max_ns) 15154be21d56SDavid Gibson { 15164be21d56SDavid Gibson bool final = max_ns < 0; 15174be21d56SDavid Gibson int htabslots = HTAB_SIZE(spapr) / HASH_PTE_SIZE_64; 15184be21d56SDavid Gibson int examined = 0, sent = 0; 15194be21d56SDavid Gibson int index = spapr->htab_save_index; 1520bc72ad67SAlex Bligh int64_t starttime = qemu_clock_get_ns(QEMU_CLOCK_REALTIME); 15214be21d56SDavid Gibson 15224be21d56SDavid Gibson assert(!spapr->htab_first_pass); 15234be21d56SDavid Gibson 15244be21d56SDavid Gibson do { 15254be21d56SDavid Gibson int chunkstart, invalidstart; 15264be21d56SDavid Gibson 15274be21d56SDavid Gibson /* Consume non-dirty HPTEs */ 15284be21d56SDavid Gibson while ((index < htabslots) 15294be21d56SDavid Gibson && !HPTE_DIRTY(HPTE(spapr->htab, index))) { 15304be21d56SDavid Gibson index++; 15314be21d56SDavid Gibson examined++; 15324be21d56SDavid Gibson } 15334be21d56SDavid Gibson 15344be21d56SDavid Gibson chunkstart = index; 15354be21d56SDavid Gibson /* Consume valid dirty HPTEs */ 1536338c25b6SSamuel Mendoza-Jonas while ((index < htabslots) && (index - chunkstart < USHRT_MAX) 15374be21d56SDavid Gibson && HPTE_DIRTY(HPTE(spapr->htab, index)) 15384be21d56SDavid Gibson && HPTE_VALID(HPTE(spapr->htab, index))) { 15394be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 15404be21d56SDavid Gibson index++; 15414be21d56SDavid Gibson examined++; 15424be21d56SDavid Gibson } 15434be21d56SDavid Gibson 15444be21d56SDavid Gibson invalidstart = index; 15454be21d56SDavid Gibson /* Consume invalid dirty HPTEs */ 1546338c25b6SSamuel Mendoza-Jonas while ((index < htabslots) && (index - invalidstart < 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 if (index > chunkstart) { 15554be21d56SDavid Gibson int n_valid = invalidstart - chunkstart; 15564be21d56SDavid Gibson int n_invalid = index - invalidstart; 15574be21d56SDavid Gibson 15584be21d56SDavid Gibson qemu_put_be32(f, chunkstart); 15594be21d56SDavid Gibson qemu_put_be16(f, n_valid); 15604be21d56SDavid Gibson qemu_put_be16(f, n_invalid); 15614be21d56SDavid Gibson qemu_put_buffer(f, HPTE(spapr->htab, chunkstart), 15624be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_valid); 15634be21d56SDavid Gibson sent += index - chunkstart; 15644be21d56SDavid Gibson 1565bc72ad67SAlex Bligh if (!final && (qemu_clock_get_ns(QEMU_CLOCK_REALTIME) - starttime) > max_ns) { 15664be21d56SDavid Gibson break; 15674be21d56SDavid Gibson } 15684be21d56SDavid Gibson } 15694be21d56SDavid Gibson 15704be21d56SDavid Gibson if (examined >= htabslots) { 15714be21d56SDavid Gibson break; 15724be21d56SDavid Gibson } 15734be21d56SDavid Gibson 15744be21d56SDavid Gibson if (index >= htabslots) { 15754be21d56SDavid Gibson assert(index == htabslots); 15764be21d56SDavid Gibson index = 0; 15774be21d56SDavid Gibson } 15784be21d56SDavid Gibson } while ((examined < htabslots) && (!qemu_file_rate_limit(f) || final)); 15794be21d56SDavid Gibson 15804be21d56SDavid Gibson if (index >= htabslots) { 15814be21d56SDavid Gibson assert(index == htabslots); 15824be21d56SDavid Gibson index = 0; 15834be21d56SDavid Gibson } 15844be21d56SDavid Gibson 15854be21d56SDavid Gibson spapr->htab_save_index = index; 15864be21d56SDavid Gibson 1587e68cb8b4SAlexey Kardashevskiy return (examined >= htabslots) && (sent == 0) ? 1 : 0; 15884be21d56SDavid Gibson } 15894be21d56SDavid Gibson 1590e68cb8b4SAlexey Kardashevskiy #define MAX_ITERATION_NS 5000000 /* 5 ms */ 1591e68cb8b4SAlexey Kardashevskiy #define MAX_KVM_BUF_SIZE 2048 1592e68cb8b4SAlexey Kardashevskiy 15934be21d56SDavid Gibson static int htab_save_iterate(QEMUFile *f, void *opaque) 15944be21d56SDavid Gibson { 159528e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 1596715c5407SDavid Gibson int fd; 1597e68cb8b4SAlexey Kardashevskiy int rc = 0; 15984be21d56SDavid Gibson 15994be21d56SDavid Gibson /* Iteration header */ 16004be21d56SDavid Gibson qemu_put_be32(f, 0); 16014be21d56SDavid Gibson 1602e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1603e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 1604e68cb8b4SAlexey Kardashevskiy 1605715c5407SDavid Gibson fd = get_htab_fd(spapr); 1606715c5407SDavid Gibson if (fd < 0) { 1607715c5407SDavid Gibson return fd; 160801a57972SSamuel Mendoza-Jonas } 160901a57972SSamuel Mendoza-Jonas 1610715c5407SDavid Gibson rc = kvmppc_save_htab(f, fd, MAX_KVM_BUF_SIZE, MAX_ITERATION_NS); 1611e68cb8b4SAlexey Kardashevskiy if (rc < 0) { 1612e68cb8b4SAlexey Kardashevskiy return rc; 1613e68cb8b4SAlexey Kardashevskiy } 1614e68cb8b4SAlexey Kardashevskiy } else if (spapr->htab_first_pass) { 16154be21d56SDavid Gibson htab_save_first_pass(f, spapr, MAX_ITERATION_NS); 16164be21d56SDavid Gibson } else { 1617e68cb8b4SAlexey Kardashevskiy rc = htab_save_later_pass(f, spapr, MAX_ITERATION_NS); 16184be21d56SDavid Gibson } 16194be21d56SDavid Gibson 16204be21d56SDavid Gibson /* End marker */ 16214be21d56SDavid Gibson qemu_put_be32(f, 0); 16224be21d56SDavid Gibson qemu_put_be16(f, 0); 16234be21d56SDavid Gibson qemu_put_be16(f, 0); 16244be21d56SDavid Gibson 1625e68cb8b4SAlexey Kardashevskiy return rc; 16264be21d56SDavid Gibson } 16274be21d56SDavid Gibson 16284be21d56SDavid Gibson static int htab_save_complete(QEMUFile *f, void *opaque) 16294be21d56SDavid Gibson { 163028e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 1631715c5407SDavid Gibson int fd; 16324be21d56SDavid Gibson 16334be21d56SDavid Gibson /* Iteration header */ 16344be21d56SDavid Gibson qemu_put_be32(f, 0); 16354be21d56SDavid Gibson 1636e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1637e68cb8b4SAlexey Kardashevskiy int rc; 1638e68cb8b4SAlexey Kardashevskiy 1639e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 1640e68cb8b4SAlexey Kardashevskiy 1641715c5407SDavid Gibson fd = get_htab_fd(spapr); 1642715c5407SDavid Gibson if (fd < 0) { 1643715c5407SDavid Gibson return fd; 164401a57972SSamuel Mendoza-Jonas } 164501a57972SSamuel Mendoza-Jonas 1646715c5407SDavid Gibson rc = kvmppc_save_htab(f, fd, MAX_KVM_BUF_SIZE, -1); 1647e68cb8b4SAlexey Kardashevskiy if (rc < 0) { 1648e68cb8b4SAlexey Kardashevskiy return rc; 1649e68cb8b4SAlexey Kardashevskiy } 1650e68cb8b4SAlexey Kardashevskiy } else { 1651378bc217SDavid Gibson if (spapr->htab_first_pass) { 1652378bc217SDavid Gibson htab_save_first_pass(f, spapr, -1); 1653378bc217SDavid Gibson } 16544be21d56SDavid Gibson htab_save_later_pass(f, spapr, -1); 1655e68cb8b4SAlexey Kardashevskiy } 16564be21d56SDavid Gibson 16574be21d56SDavid Gibson /* End marker */ 16584be21d56SDavid Gibson qemu_put_be32(f, 0); 16594be21d56SDavid Gibson qemu_put_be16(f, 0); 16604be21d56SDavid Gibson qemu_put_be16(f, 0); 16614be21d56SDavid Gibson 16624be21d56SDavid Gibson return 0; 16634be21d56SDavid Gibson } 16644be21d56SDavid Gibson 16654be21d56SDavid Gibson static int htab_load(QEMUFile *f, void *opaque, int version_id) 16664be21d56SDavid Gibson { 166728e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 16684be21d56SDavid Gibson uint32_t section_hdr; 1669e68cb8b4SAlexey Kardashevskiy int fd = -1; 16704be21d56SDavid Gibson 16714be21d56SDavid Gibson if (version_id < 1 || version_id > 1) { 167298a5d100SDavid Gibson error_report("htab_load() bad version"); 16734be21d56SDavid Gibson return -EINVAL; 16744be21d56SDavid Gibson } 16754be21d56SDavid Gibson 16764be21d56SDavid Gibson section_hdr = qemu_get_be32(f); 16774be21d56SDavid Gibson 16784be21d56SDavid Gibson if (section_hdr) { 16799897e462SGreg Kurz Error *local_err = NULL; 1680c5f54f3eSDavid Gibson 1681c5f54f3eSDavid Gibson /* First section gives the htab size */ 1682c5f54f3eSDavid Gibson spapr_reallocate_hpt(spapr, section_hdr, &local_err); 1683c5f54f3eSDavid Gibson if (local_err) { 1684c5f54f3eSDavid Gibson error_report_err(local_err); 16854be21d56SDavid Gibson return -EINVAL; 16864be21d56SDavid Gibson } 16874be21d56SDavid Gibson return 0; 16884be21d56SDavid Gibson } 16894be21d56SDavid Gibson 1690e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1691e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 1692e68cb8b4SAlexey Kardashevskiy 1693e68cb8b4SAlexey Kardashevskiy fd = kvmppc_get_htab_fd(true); 1694e68cb8b4SAlexey Kardashevskiy if (fd < 0) { 169598a5d100SDavid Gibson error_report("Unable to open fd to restore KVM hash table: %s", 1696e68cb8b4SAlexey Kardashevskiy strerror(errno)); 1697e68cb8b4SAlexey Kardashevskiy } 1698e68cb8b4SAlexey Kardashevskiy } 1699e68cb8b4SAlexey Kardashevskiy 17004be21d56SDavid Gibson while (true) { 17014be21d56SDavid Gibson uint32_t index; 17024be21d56SDavid Gibson uint16_t n_valid, n_invalid; 17034be21d56SDavid Gibson 17044be21d56SDavid Gibson index = qemu_get_be32(f); 17054be21d56SDavid Gibson n_valid = qemu_get_be16(f); 17064be21d56SDavid Gibson n_invalid = qemu_get_be16(f); 17074be21d56SDavid Gibson 17084be21d56SDavid Gibson if ((index == 0) && (n_valid == 0) && (n_invalid == 0)) { 17094be21d56SDavid Gibson /* End of Stream */ 17104be21d56SDavid Gibson break; 17114be21d56SDavid Gibson } 17124be21d56SDavid Gibson 1713e68cb8b4SAlexey Kardashevskiy if ((index + n_valid + n_invalid) > 17144be21d56SDavid Gibson (HTAB_SIZE(spapr) / HASH_PTE_SIZE_64)) { 17154be21d56SDavid Gibson /* Bad index in stream */ 171698a5d100SDavid Gibson error_report( 171798a5d100SDavid Gibson "htab_load() bad index %d (%hd+%hd entries) in htab stream (htab_shift=%d)", 171898a5d100SDavid Gibson index, n_valid, n_invalid, spapr->htab_shift); 17194be21d56SDavid Gibson return -EINVAL; 17204be21d56SDavid Gibson } 17214be21d56SDavid Gibson 1722e68cb8b4SAlexey Kardashevskiy if (spapr->htab) { 17234be21d56SDavid Gibson if (n_valid) { 17244be21d56SDavid Gibson qemu_get_buffer(f, HPTE(spapr->htab, index), 17254be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_valid); 17264be21d56SDavid Gibson } 17274be21d56SDavid Gibson if (n_invalid) { 17284be21d56SDavid Gibson memset(HPTE(spapr->htab, index + n_valid), 0, 17294be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_invalid); 17304be21d56SDavid Gibson } 1731e68cb8b4SAlexey Kardashevskiy } else { 1732e68cb8b4SAlexey Kardashevskiy int rc; 1733e68cb8b4SAlexey Kardashevskiy 1734e68cb8b4SAlexey Kardashevskiy assert(fd >= 0); 1735e68cb8b4SAlexey Kardashevskiy 1736e68cb8b4SAlexey Kardashevskiy rc = kvmppc_load_htab_chunk(f, fd, index, n_valid, n_invalid); 1737e68cb8b4SAlexey Kardashevskiy if (rc < 0) { 1738e68cb8b4SAlexey Kardashevskiy return rc; 1739e68cb8b4SAlexey Kardashevskiy } 1740e68cb8b4SAlexey Kardashevskiy } 1741e68cb8b4SAlexey Kardashevskiy } 1742e68cb8b4SAlexey Kardashevskiy 1743e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1744e68cb8b4SAlexey Kardashevskiy assert(fd >= 0); 1745e68cb8b4SAlexey Kardashevskiy close(fd); 17464be21d56SDavid Gibson } 17474be21d56SDavid Gibson 17484be21d56SDavid Gibson return 0; 17494be21d56SDavid Gibson } 17504be21d56SDavid Gibson 1751c573fc03SThomas Huth static void htab_cleanup(void *opaque) 1752c573fc03SThomas Huth { 1753c573fc03SThomas Huth sPAPRMachineState *spapr = opaque; 1754c573fc03SThomas Huth 1755c573fc03SThomas Huth close_htab_fd(spapr); 1756c573fc03SThomas Huth } 1757c573fc03SThomas Huth 17584be21d56SDavid Gibson static SaveVMHandlers savevm_htab_handlers = { 17594be21d56SDavid Gibson .save_live_setup = htab_save_setup, 17604be21d56SDavid Gibson .save_live_iterate = htab_save_iterate, 1761a3e06c3dSDr. David Alan Gilbert .save_live_complete_precopy = htab_save_complete, 1762c573fc03SThomas Huth .cleanup = htab_cleanup, 17634be21d56SDavid Gibson .load_state = htab_load, 17644be21d56SDavid Gibson }; 17654be21d56SDavid Gibson 17665b2128d2SAlexander Graf static void spapr_boot_set(void *opaque, const char *boot_device, 17675b2128d2SAlexander Graf Error **errp) 17685b2128d2SAlexander Graf { 17695b2128d2SAlexander Graf MachineState *machine = MACHINE(qdev_get_machine()); 17705b2128d2SAlexander Graf machine->boot_order = g_strdup(boot_device); 17715b2128d2SAlexander Graf } 17725b2128d2SAlexander Graf 1773224245bfSDavid Gibson /* 1774224245bfSDavid Gibson * Reset routine for LMB DR devices. 1775224245bfSDavid Gibson * 1776224245bfSDavid Gibson * Unlike PCI DR devices, LMB DR devices explicitly register this reset 1777224245bfSDavid Gibson * routine. Reset for PCI DR devices will be handled by PHB reset routine 1778224245bfSDavid Gibson * when it walks all its children devices. LMB devices reset occurs 1779224245bfSDavid Gibson * as part of spapr_ppc_reset(). 1780224245bfSDavid Gibson */ 1781224245bfSDavid Gibson static void spapr_drc_reset(void *opaque) 1782224245bfSDavid Gibson { 1783224245bfSDavid Gibson sPAPRDRConnector *drc = opaque; 1784224245bfSDavid Gibson DeviceState *d = DEVICE(drc); 1785224245bfSDavid Gibson 1786224245bfSDavid Gibson if (d) { 1787224245bfSDavid Gibson device_reset(d); 1788224245bfSDavid Gibson } 1789224245bfSDavid Gibson } 1790224245bfSDavid Gibson 1791224245bfSDavid Gibson static void spapr_create_lmb_dr_connectors(sPAPRMachineState *spapr) 1792224245bfSDavid Gibson { 1793224245bfSDavid Gibson MachineState *machine = MACHINE(spapr); 1794224245bfSDavid Gibson uint64_t lmb_size = SPAPR_MEMORY_BLOCK_SIZE; 1795e8f986fcSBharata B Rao uint32_t nr_lmbs = (machine->maxram_size - machine->ram_size)/lmb_size; 1796224245bfSDavid Gibson int i; 1797224245bfSDavid Gibson 1798224245bfSDavid Gibson for (i = 0; i < nr_lmbs; i++) { 1799224245bfSDavid Gibson sPAPRDRConnector *drc; 1800224245bfSDavid Gibson uint64_t addr; 1801224245bfSDavid Gibson 1802e8f986fcSBharata B Rao addr = i * lmb_size + spapr->hotplug_memory.base; 1803224245bfSDavid Gibson drc = spapr_dr_connector_new(OBJECT(spapr), SPAPR_DR_CONNECTOR_TYPE_LMB, 1804224245bfSDavid Gibson addr/lmb_size); 1805224245bfSDavid Gibson qemu_register_reset(spapr_drc_reset, drc); 1806224245bfSDavid Gibson } 1807224245bfSDavid Gibson } 1808224245bfSDavid Gibson 1809224245bfSDavid Gibson /* 1810224245bfSDavid Gibson * If RAM size, maxmem size and individual node mem sizes aren't aligned 1811224245bfSDavid Gibson * to SPAPR_MEMORY_BLOCK_SIZE(256MB), then refuse to start the guest 1812224245bfSDavid Gibson * since we can't support such unaligned sizes with DRCONF_MEMORY. 1813224245bfSDavid Gibson */ 18147c150d6fSDavid Gibson static void spapr_validate_node_memory(MachineState *machine, Error **errp) 1815224245bfSDavid Gibson { 1816224245bfSDavid Gibson int i; 1817224245bfSDavid Gibson 18187c150d6fSDavid Gibson if (machine->ram_size % SPAPR_MEMORY_BLOCK_SIZE) { 18197c150d6fSDavid Gibson error_setg(errp, "Memory size 0x" RAM_ADDR_FMT 18207c150d6fSDavid Gibson " is not aligned to %llu MiB", 18217c150d6fSDavid Gibson machine->ram_size, 1822224245bfSDavid Gibson SPAPR_MEMORY_BLOCK_SIZE / M_BYTE); 18237c150d6fSDavid Gibson return; 18247c150d6fSDavid Gibson } 18257c150d6fSDavid Gibson 18267c150d6fSDavid Gibson if (machine->maxram_size % SPAPR_MEMORY_BLOCK_SIZE) { 18277c150d6fSDavid Gibson error_setg(errp, "Maximum memory size 0x" RAM_ADDR_FMT 18287c150d6fSDavid Gibson " is not aligned to %llu MiB", 18297c150d6fSDavid Gibson machine->ram_size, 18307c150d6fSDavid Gibson SPAPR_MEMORY_BLOCK_SIZE / M_BYTE); 18317c150d6fSDavid Gibson return; 1832224245bfSDavid Gibson } 1833224245bfSDavid Gibson 1834224245bfSDavid Gibson for (i = 0; i < nb_numa_nodes; i++) { 1835224245bfSDavid Gibson if (numa_info[i].node_mem % SPAPR_MEMORY_BLOCK_SIZE) { 18367c150d6fSDavid Gibson error_setg(errp, 18377c150d6fSDavid Gibson "Node %d memory size 0x%" PRIx64 18387c150d6fSDavid Gibson " is not aligned to %llu MiB", 18397c150d6fSDavid Gibson i, numa_info[i].node_mem, 1840224245bfSDavid Gibson SPAPR_MEMORY_BLOCK_SIZE / M_BYTE); 18417c150d6fSDavid Gibson return; 1842224245bfSDavid Gibson } 1843224245bfSDavid Gibson } 1844224245bfSDavid Gibson } 1845224245bfSDavid Gibson 1846535455fdSIgor Mammedov /* find cpu slot in machine->possible_cpus by core_id */ 1847535455fdSIgor Mammedov static CPUArchId *spapr_find_cpu_slot(MachineState *ms, uint32_t id, int *idx) 1848535455fdSIgor Mammedov { 1849535455fdSIgor Mammedov int index = id / smp_threads; 1850535455fdSIgor Mammedov 1851535455fdSIgor Mammedov if (index >= ms->possible_cpus->len) { 1852535455fdSIgor Mammedov return NULL; 1853535455fdSIgor Mammedov } 1854535455fdSIgor Mammedov if (idx) { 1855535455fdSIgor Mammedov *idx = index; 1856535455fdSIgor Mammedov } 1857535455fdSIgor Mammedov return &ms->possible_cpus->cpus[index]; 1858535455fdSIgor Mammedov } 1859535455fdSIgor Mammedov 18600c86d0fdSDavid Gibson static void spapr_init_cpus(sPAPRMachineState *spapr) 18610c86d0fdSDavid Gibson { 18620c86d0fdSDavid Gibson MachineState *machine = MACHINE(spapr); 18630c86d0fdSDavid Gibson MachineClass *mc = MACHINE_GET_CLASS(machine); 18640c86d0fdSDavid Gibson char *type = spapr_get_cpu_core_type(machine->cpu_model); 18650c86d0fdSDavid Gibson int smt = kvmppc_smt_threads(); 1866535455fdSIgor Mammedov const CPUArchIdList *possible_cpus; 1867535455fdSIgor Mammedov int boot_cores_nr = smp_cpus / smp_threads; 18680c86d0fdSDavid Gibson int i; 18690c86d0fdSDavid Gibson 18700c86d0fdSDavid Gibson if (!type) { 18710c86d0fdSDavid Gibson error_report("Unable to find sPAPR CPU Core definition"); 18720c86d0fdSDavid Gibson exit(1); 18730c86d0fdSDavid Gibson } 18740c86d0fdSDavid Gibson 1875535455fdSIgor Mammedov possible_cpus = mc->possible_cpu_arch_ids(machine); 1876c5514d0eSIgor Mammedov if (mc->has_hotpluggable_cpus) { 18770c86d0fdSDavid Gibson if (smp_cpus % smp_threads) { 18780c86d0fdSDavid Gibson error_report("smp_cpus (%u) must be multiple of threads (%u)", 18790c86d0fdSDavid Gibson smp_cpus, smp_threads); 18800c86d0fdSDavid Gibson exit(1); 18810c86d0fdSDavid Gibson } 18820c86d0fdSDavid Gibson if (max_cpus % smp_threads) { 18830c86d0fdSDavid Gibson error_report("max_cpus (%u) must be multiple of threads (%u)", 18840c86d0fdSDavid Gibson max_cpus, smp_threads); 18850c86d0fdSDavid Gibson exit(1); 18860c86d0fdSDavid Gibson } 18870c86d0fdSDavid Gibson } else { 18880c86d0fdSDavid Gibson if (max_cpus != smp_cpus) { 18890c86d0fdSDavid Gibson error_report("This machine version does not support CPU hotplug"); 18900c86d0fdSDavid Gibson exit(1); 18910c86d0fdSDavid Gibson } 1892535455fdSIgor Mammedov boot_cores_nr = possible_cpus->len; 18930c86d0fdSDavid Gibson } 18940c86d0fdSDavid Gibson 1895535455fdSIgor Mammedov for (i = 0; i < possible_cpus->len; i++) { 18960c86d0fdSDavid Gibson int core_id = i * smp_threads; 18970c86d0fdSDavid Gibson 1898c5514d0eSIgor Mammedov if (mc->has_hotpluggable_cpus) { 18990c86d0fdSDavid Gibson sPAPRDRConnector *drc = 19000c86d0fdSDavid Gibson spapr_dr_connector_new(OBJECT(spapr), 19010c86d0fdSDavid Gibson SPAPR_DR_CONNECTOR_TYPE_CPU, 19020c86d0fdSDavid Gibson (core_id / smp_threads) * smt); 19030c86d0fdSDavid Gibson 19040c86d0fdSDavid Gibson qemu_register_reset(spapr_drc_reset, drc); 19050c86d0fdSDavid Gibson } 19060c86d0fdSDavid Gibson 1907535455fdSIgor Mammedov if (i < boot_cores_nr) { 19080c86d0fdSDavid Gibson Object *core = object_new(type); 19090c86d0fdSDavid Gibson int nr_threads = smp_threads; 19100c86d0fdSDavid Gibson 19110c86d0fdSDavid Gibson /* Handle the partially filled core for older machine types */ 19120c86d0fdSDavid Gibson if ((i + 1) * smp_threads >= smp_cpus) { 19130c86d0fdSDavid Gibson nr_threads = smp_cpus - i * smp_threads; 19140c86d0fdSDavid Gibson } 19150c86d0fdSDavid Gibson 19160c86d0fdSDavid Gibson object_property_set_int(core, nr_threads, "nr-threads", 19170c86d0fdSDavid Gibson &error_fatal); 19180c86d0fdSDavid Gibson object_property_set_int(core, core_id, CPU_CORE_PROP_CORE_ID, 19190c86d0fdSDavid Gibson &error_fatal); 19200c86d0fdSDavid Gibson object_property_set_bool(core, true, "realized", &error_fatal); 19210c86d0fdSDavid Gibson } 19220c86d0fdSDavid Gibson } 19230c86d0fdSDavid Gibson g_free(type); 19240c86d0fdSDavid Gibson } 19250c86d0fdSDavid Gibson 192653018216SPaolo Bonzini /* pSeries LPAR / sPAPR hardware init */ 19273ef96221SMarcel Apfelbaum static void ppc_spapr_init(MachineState *machine) 192853018216SPaolo Bonzini { 192928e02042SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(machine); 1930224245bfSDavid Gibson sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(machine); 19313ef96221SMarcel Apfelbaum const char *kernel_filename = machine->kernel_filename; 19323ef96221SMarcel Apfelbaum const char *initrd_filename = machine->initrd_filename; 193353018216SPaolo Bonzini PCIHostState *phb; 193453018216SPaolo Bonzini int i; 193553018216SPaolo Bonzini MemoryRegion *sysmem = get_system_memory(); 193653018216SPaolo Bonzini MemoryRegion *ram = g_new(MemoryRegion, 1); 1937658fa66bSAlexey Kardashevskiy MemoryRegion *rma_region; 1938658fa66bSAlexey Kardashevskiy void *rma = NULL; 193953018216SPaolo Bonzini hwaddr rma_alloc_size; 1940b082d65aSAlexey Kardashevskiy hwaddr node0_size = spapr_node0_size(); 1941b7d1f77aSBenjamin Herrenschmidt long load_limit, fw_size; 194253018216SPaolo Bonzini char *filename; 194394a94e4cSBharata B Rao int smt = kvmppc_smt_threads(); 194453018216SPaolo Bonzini 1945226419d6SMichael S. Tsirkin msi_nonbroken = true; 194653018216SPaolo Bonzini 194753018216SPaolo Bonzini QLIST_INIT(&spapr->phbs); 194853018216SPaolo Bonzini 194953018216SPaolo Bonzini /* Allocate RMA if necessary */ 1950658fa66bSAlexey Kardashevskiy rma_alloc_size = kvmppc_alloc_rma(&rma); 195153018216SPaolo Bonzini 195253018216SPaolo Bonzini if (rma_alloc_size == -1) { 1953730fce59SThomas Huth error_report("Unable to create RMA"); 195453018216SPaolo Bonzini exit(1); 195553018216SPaolo Bonzini } 195653018216SPaolo Bonzini 1957c4177479SAlexey Kardashevskiy if (rma_alloc_size && (rma_alloc_size < node0_size)) { 195853018216SPaolo Bonzini spapr->rma_size = rma_alloc_size; 195953018216SPaolo Bonzini } else { 1960c4177479SAlexey Kardashevskiy spapr->rma_size = node0_size; 196153018216SPaolo Bonzini 196253018216SPaolo Bonzini /* With KVM, we don't actually know whether KVM supports an 196353018216SPaolo Bonzini * unbounded RMA (PR KVM) or is limited by the hash table size 196453018216SPaolo Bonzini * (HV KVM using VRMA), so we always assume the latter 196553018216SPaolo Bonzini * 196653018216SPaolo Bonzini * In that case, we also limit the initial allocations for RTAS 196753018216SPaolo Bonzini * etc... to 256M since we have no way to know what the VRMA size 196853018216SPaolo Bonzini * is going to be as it depends on the size of the hash table 196953018216SPaolo Bonzini * isn't determined yet. 197053018216SPaolo Bonzini */ 197153018216SPaolo Bonzini if (kvm_enabled()) { 197253018216SPaolo Bonzini spapr->vrma_adjust = 1; 197353018216SPaolo Bonzini spapr->rma_size = MIN(spapr->rma_size, 0x10000000); 197453018216SPaolo Bonzini } 1975912acdf4SBenjamin Herrenschmidt 1976912acdf4SBenjamin Herrenschmidt /* Actually we don't support unbounded RMA anymore since we 1977912acdf4SBenjamin Herrenschmidt * added proper emulation of HV mode. The max we can get is 1978912acdf4SBenjamin Herrenschmidt * 16G which also happens to be what we configure for PAPR 1979912acdf4SBenjamin Herrenschmidt * mode so make sure we don't do anything bigger than that 1980912acdf4SBenjamin Herrenschmidt */ 1981912acdf4SBenjamin Herrenschmidt spapr->rma_size = MIN(spapr->rma_size, 0x400000000ull); 198253018216SPaolo Bonzini } 198353018216SPaolo Bonzini 1984c4177479SAlexey Kardashevskiy if (spapr->rma_size > node0_size) { 1985d54e4d76SDavid Gibson error_report("Numa node 0 has to span the RMA (%#08"HWADDR_PRIx")", 1986c4177479SAlexey Kardashevskiy spapr->rma_size); 1987c4177479SAlexey Kardashevskiy exit(1); 1988c4177479SAlexey Kardashevskiy } 1989c4177479SAlexey Kardashevskiy 1990b7d1f77aSBenjamin Herrenschmidt /* Setup a load limit for the ramdisk leaving room for SLOF and FDT */ 1991b7d1f77aSBenjamin Herrenschmidt load_limit = MIN(spapr->rma_size, RTAS_MAX_ADDR) - FW_OVERHEAD; 199253018216SPaolo Bonzini 19937b565160SDavid Gibson /* Set up Interrupt Controller before we create the VCPUs */ 1994*e6f7e110SCédric Le Goater xics_system_init(machine, DIV_ROUND_UP(max_cpus * smt, smp_threads), 1995161deaf2SBenjamin Herrenschmidt XICS_IRQS_SPAPR, &error_fatal); 19967b565160SDavid Gibson 1997facdb8b6SMichael Roth /* Set up containers for ibm,client-set-architecture negotiated options */ 1998facdb8b6SMichael Roth spapr->ov5 = spapr_ovec_new(); 1999facdb8b6SMichael Roth spapr->ov5_cas = spapr_ovec_new(); 2000facdb8b6SMichael Roth 2001224245bfSDavid Gibson if (smc->dr_lmb_enabled) { 2002facdb8b6SMichael Roth spapr_ovec_set(spapr->ov5, OV5_DRCONF_MEMORY); 20037c150d6fSDavid Gibson spapr_validate_node_memory(machine, &error_fatal); 2004224245bfSDavid Gibson } 2005224245bfSDavid Gibson 2006417ece33SMichael Roth spapr_ovec_set(spapr->ov5, OV5_FORM1_AFFINITY); 2007417ece33SMichael Roth 2008ffbb1705SMichael Roth /* advertise support for dedicated HP event source to guests */ 2009ffbb1705SMichael Roth if (spapr->use_hotplug_event_source) { 2010ffbb1705SMichael Roth spapr_ovec_set(spapr->ov5, OV5_HP_EVT); 2011ffbb1705SMichael Roth } 2012ffbb1705SMichael Roth 201353018216SPaolo Bonzini /* init CPUs */ 201419fb2c36SBharata B Rao if (machine->cpu_model == NULL) { 20153daa4a9fSThomas Huth machine->cpu_model = kvm_enabled() ? "host" : smc->tcg_default_cpu; 201653018216SPaolo Bonzini } 201794a94e4cSBharata B Rao 2018e703d2f7SGreg Kurz ppc_cpu_parse_features(machine->cpu_model); 2019e703d2f7SGreg Kurz 20200c86d0fdSDavid Gibson spapr_init_cpus(spapr); 202153018216SPaolo Bonzini 2022026bfd89SDavid Gibson if (kvm_enabled()) { 2023026bfd89SDavid Gibson /* Enable H_LOGICAL_CI_* so SLOF can talk to in-kernel devices */ 2024026bfd89SDavid Gibson kvmppc_enable_logical_ci_hcalls(); 2025ef9971ddSAlexey Kardashevskiy kvmppc_enable_set_mode_hcall(); 20265145ad4fSNathan Whitehorn 20275145ad4fSNathan Whitehorn /* H_CLEAR_MOD/_REF are mandatory in PAPR, but off by default */ 20285145ad4fSNathan Whitehorn kvmppc_enable_clear_ref_mod_hcalls(); 2029026bfd89SDavid Gibson } 2030026bfd89SDavid Gibson 203153018216SPaolo Bonzini /* allocate RAM */ 2032f92f5da1SAlexey Kardashevskiy memory_region_allocate_system_memory(ram, NULL, "ppc_spapr.ram", 2033fb164994SDavid Gibson machine->ram_size); 2034f92f5da1SAlexey Kardashevskiy memory_region_add_subregion(sysmem, 0, ram); 203553018216SPaolo Bonzini 2036658fa66bSAlexey Kardashevskiy if (rma_alloc_size && rma) { 2037658fa66bSAlexey Kardashevskiy rma_region = g_new(MemoryRegion, 1); 2038658fa66bSAlexey Kardashevskiy memory_region_init_ram_ptr(rma_region, NULL, "ppc_spapr.rma", 2039658fa66bSAlexey Kardashevskiy rma_alloc_size, rma); 2040658fa66bSAlexey Kardashevskiy vmstate_register_ram_global(rma_region); 2041658fa66bSAlexey Kardashevskiy memory_region_add_subregion(sysmem, 0, rma_region); 2042658fa66bSAlexey Kardashevskiy } 2043658fa66bSAlexey Kardashevskiy 20444a1c9cf0SBharata B Rao /* initialize hotplug memory address space */ 20454a1c9cf0SBharata B Rao if (machine->ram_size < machine->maxram_size) { 20464a1c9cf0SBharata B Rao ram_addr_t hotplug_mem_size = machine->maxram_size - machine->ram_size; 204771c9a3ddSBharata B Rao /* 204871c9a3ddSBharata B Rao * Limit the number of hotpluggable memory slots to half the number 204971c9a3ddSBharata B Rao * slots that KVM supports, leaving the other half for PCI and other 205071c9a3ddSBharata B Rao * devices. However ensure that number of slots doesn't drop below 32. 205171c9a3ddSBharata B Rao */ 205271c9a3ddSBharata B Rao int max_memslots = kvm_enabled() ? kvm_get_max_memslots() / 2 : 205371c9a3ddSBharata B Rao SPAPR_MAX_RAM_SLOTS; 20544a1c9cf0SBharata B Rao 205571c9a3ddSBharata B Rao if (max_memslots < SPAPR_MAX_RAM_SLOTS) { 205671c9a3ddSBharata B Rao max_memslots = SPAPR_MAX_RAM_SLOTS; 205771c9a3ddSBharata B Rao } 205871c9a3ddSBharata B Rao if (machine->ram_slots > max_memslots) { 2059d54e4d76SDavid Gibson error_report("Specified number of memory slots %" 2060d54e4d76SDavid Gibson PRIu64" exceeds max supported %d", 206171c9a3ddSBharata B Rao machine->ram_slots, max_memslots); 2062d54e4d76SDavid Gibson exit(1); 20634a1c9cf0SBharata B Rao } 20644a1c9cf0SBharata B Rao 20654a1c9cf0SBharata B Rao spapr->hotplug_memory.base = ROUND_UP(machine->ram_size, 20664a1c9cf0SBharata B Rao SPAPR_HOTPLUG_MEM_ALIGN); 20674a1c9cf0SBharata B Rao memory_region_init(&spapr->hotplug_memory.mr, OBJECT(spapr), 20684a1c9cf0SBharata B Rao "hotplug-memory", hotplug_mem_size); 20694a1c9cf0SBharata B Rao memory_region_add_subregion(sysmem, spapr->hotplug_memory.base, 20704a1c9cf0SBharata B Rao &spapr->hotplug_memory.mr); 20714a1c9cf0SBharata B Rao } 20724a1c9cf0SBharata B Rao 2073224245bfSDavid Gibson if (smc->dr_lmb_enabled) { 2074224245bfSDavid Gibson spapr_create_lmb_dr_connectors(spapr); 2075224245bfSDavid Gibson } 2076224245bfSDavid Gibson 207753018216SPaolo Bonzini filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, "spapr-rtas.bin"); 20784c56440dSStefan Weil if (!filename) { 2079730fce59SThomas Huth error_report("Could not find LPAR rtas '%s'", "spapr-rtas.bin"); 20804c56440dSStefan Weil exit(1); 20814c56440dSStefan Weil } 2082b7d1f77aSBenjamin Herrenschmidt spapr->rtas_size = get_image_size(filename); 20838afc22a2SZhou Jie if (spapr->rtas_size < 0) { 20848afc22a2SZhou Jie error_report("Could not get size of LPAR rtas '%s'", filename); 20858afc22a2SZhou Jie exit(1); 20868afc22a2SZhou Jie } 2087b7d1f77aSBenjamin Herrenschmidt spapr->rtas_blob = g_malloc(spapr->rtas_size); 2088b7d1f77aSBenjamin Herrenschmidt if (load_image_size(filename, spapr->rtas_blob, spapr->rtas_size) < 0) { 2089730fce59SThomas Huth error_report("Could not load LPAR rtas '%s'", filename); 209053018216SPaolo Bonzini exit(1); 209153018216SPaolo Bonzini } 209253018216SPaolo Bonzini if (spapr->rtas_size > RTAS_MAX_SIZE) { 2093730fce59SThomas Huth error_report("RTAS too big ! 0x%zx bytes (max is 0x%x)", 20942f285bddSPeter Maydell (size_t)spapr->rtas_size, RTAS_MAX_SIZE); 209553018216SPaolo Bonzini exit(1); 209653018216SPaolo Bonzini } 209753018216SPaolo Bonzini g_free(filename); 209853018216SPaolo Bonzini 2099ffbb1705SMichael Roth /* Set up RTAS event infrastructure */ 210053018216SPaolo Bonzini spapr_events_init(spapr); 210153018216SPaolo Bonzini 210212f42174SDavid Gibson /* Set up the RTC RTAS interfaces */ 210328df36a1SDavid Gibson spapr_rtc_create(spapr); 210412f42174SDavid Gibson 210553018216SPaolo Bonzini /* Set up VIO bus */ 210653018216SPaolo Bonzini spapr->vio_bus = spapr_vio_bus_init(); 210753018216SPaolo Bonzini 210853018216SPaolo Bonzini for (i = 0; i < MAX_SERIAL_PORTS; i++) { 210953018216SPaolo Bonzini if (serial_hds[i]) { 211053018216SPaolo Bonzini spapr_vty_create(spapr->vio_bus, serial_hds[i]); 211153018216SPaolo Bonzini } 211253018216SPaolo Bonzini } 211353018216SPaolo Bonzini 211453018216SPaolo Bonzini /* We always have at least the nvram device on VIO */ 211553018216SPaolo Bonzini spapr_create_nvram(spapr); 211653018216SPaolo Bonzini 211753018216SPaolo Bonzini /* Set up PCI */ 211853018216SPaolo Bonzini spapr_pci_rtas_init(); 211953018216SPaolo Bonzini 212089dfd6e1SDavid Gibson phb = spapr_create_phb(spapr, 0); 212153018216SPaolo Bonzini 212253018216SPaolo Bonzini for (i = 0; i < nb_nics; i++) { 212353018216SPaolo Bonzini NICInfo *nd = &nd_table[i]; 212453018216SPaolo Bonzini 212553018216SPaolo Bonzini if (!nd->model) { 212653018216SPaolo Bonzini nd->model = g_strdup("ibmveth"); 212753018216SPaolo Bonzini } 212853018216SPaolo Bonzini 212953018216SPaolo Bonzini if (strcmp(nd->model, "ibmveth") == 0) { 213053018216SPaolo Bonzini spapr_vlan_create(spapr->vio_bus, nd); 213153018216SPaolo Bonzini } else { 213229b358f9SDavid Gibson pci_nic_init_nofail(&nd_table[i], phb->bus, nd->model, NULL); 213353018216SPaolo Bonzini } 213453018216SPaolo Bonzini } 213553018216SPaolo Bonzini 213653018216SPaolo Bonzini for (i = 0; i <= drive_get_max_bus(IF_SCSI); i++) { 213753018216SPaolo Bonzini spapr_vscsi_create(spapr->vio_bus); 213853018216SPaolo Bonzini } 213953018216SPaolo Bonzini 214053018216SPaolo Bonzini /* Graphics */ 214114c6a894SDavid Gibson if (spapr_vga_init(phb->bus, &error_fatal)) { 214253018216SPaolo Bonzini spapr->has_graphics = true; 2143c6e76503SPaolo Bonzini machine->usb |= defaults_enabled() && !machine->usb_disabled; 214453018216SPaolo Bonzini } 214553018216SPaolo Bonzini 21464ee9ced9SMarcel Apfelbaum if (machine->usb) { 214757040d45SThomas Huth if (smc->use_ohci_by_default) { 214853018216SPaolo Bonzini pci_create_simple(phb->bus, -1, "pci-ohci"); 214957040d45SThomas Huth } else { 215057040d45SThomas Huth pci_create_simple(phb->bus, -1, "nec-usb-xhci"); 215157040d45SThomas Huth } 2152c86580b8SMarkus Armbruster 215353018216SPaolo Bonzini if (spapr->has_graphics) { 2154c86580b8SMarkus Armbruster USBBus *usb_bus = usb_bus_find(-1); 2155c86580b8SMarkus Armbruster 2156c86580b8SMarkus Armbruster usb_create_simple(usb_bus, "usb-kbd"); 2157c86580b8SMarkus Armbruster usb_create_simple(usb_bus, "usb-mouse"); 215853018216SPaolo Bonzini } 215953018216SPaolo Bonzini } 216053018216SPaolo Bonzini 216153018216SPaolo Bonzini if (spapr->rma_size < (MIN_RMA_SLOF << 20)) { 2162d54e4d76SDavid Gibson error_report( 2163d54e4d76SDavid Gibson "pSeries SLOF firmware requires >= %ldM guest RMA (Real Mode Area memory)", 2164d54e4d76SDavid Gibson MIN_RMA_SLOF); 216553018216SPaolo Bonzini exit(1); 216653018216SPaolo Bonzini } 216753018216SPaolo Bonzini 216853018216SPaolo Bonzini if (kernel_filename) { 216953018216SPaolo Bonzini uint64_t lowaddr = 0; 217053018216SPaolo Bonzini 2171a19f7fb0SDavid Gibson spapr->kernel_size = load_elf(kernel_filename, translate_kernel_address, 2172a19f7fb0SDavid Gibson NULL, NULL, &lowaddr, NULL, 1, 2173a19f7fb0SDavid Gibson PPC_ELF_MACHINE, 0, 0); 2174a19f7fb0SDavid Gibson if (spapr->kernel_size == ELF_LOAD_WRONG_ENDIAN) { 2175a19f7fb0SDavid Gibson spapr->kernel_size = load_elf(kernel_filename, 2176a19f7fb0SDavid Gibson translate_kernel_address, NULL, NULL, 2177a19f7fb0SDavid Gibson &lowaddr, NULL, 0, PPC_ELF_MACHINE, 21787ef295eaSPeter Crosthwaite 0, 0); 2179a19f7fb0SDavid Gibson spapr->kernel_le = spapr->kernel_size > 0; 218016457e7fSBenjamin Herrenschmidt } 2181a19f7fb0SDavid Gibson if (spapr->kernel_size < 0) { 2182a19f7fb0SDavid Gibson error_report("error loading %s: %s", kernel_filename, 2183a19f7fb0SDavid Gibson load_elf_strerror(spapr->kernel_size)); 218453018216SPaolo Bonzini exit(1); 218553018216SPaolo Bonzini } 218653018216SPaolo Bonzini 218753018216SPaolo Bonzini /* load initrd */ 218853018216SPaolo Bonzini if (initrd_filename) { 218953018216SPaolo Bonzini /* Try to locate the initrd in the gap between the kernel 219053018216SPaolo Bonzini * and the firmware. Add a bit of space just in case 219153018216SPaolo Bonzini */ 2192a19f7fb0SDavid Gibson spapr->initrd_base = (KERNEL_LOAD_ADDR + spapr->kernel_size 2193a19f7fb0SDavid Gibson + 0x1ffff) & ~0xffff; 2194a19f7fb0SDavid Gibson spapr->initrd_size = load_image_targphys(initrd_filename, 2195a19f7fb0SDavid Gibson spapr->initrd_base, 2196a19f7fb0SDavid Gibson load_limit 2197a19f7fb0SDavid Gibson - spapr->initrd_base); 2198a19f7fb0SDavid Gibson if (spapr->initrd_size < 0) { 2199d54e4d76SDavid Gibson error_report("could not load initial ram disk '%s'", 220053018216SPaolo Bonzini initrd_filename); 220153018216SPaolo Bonzini exit(1); 220253018216SPaolo Bonzini } 220353018216SPaolo Bonzini } 220453018216SPaolo Bonzini } 220553018216SPaolo Bonzini 22068e7ea787SAndreas Färber if (bios_name == NULL) { 22078e7ea787SAndreas Färber bios_name = FW_FILE_NAME; 22088e7ea787SAndreas Färber } 22098e7ea787SAndreas Färber filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name); 22104c56440dSStefan Weil if (!filename) { 221168fea5a0SThomas Huth error_report("Could not find LPAR firmware '%s'", bios_name); 22124c56440dSStefan Weil exit(1); 22134c56440dSStefan Weil } 221453018216SPaolo Bonzini fw_size = load_image_targphys(filename, 0, FW_MAX_SIZE); 221568fea5a0SThomas Huth if (fw_size <= 0) { 221668fea5a0SThomas Huth error_report("Could not load LPAR firmware '%s'", filename); 221753018216SPaolo Bonzini exit(1); 221853018216SPaolo Bonzini } 221953018216SPaolo Bonzini g_free(filename); 222053018216SPaolo Bonzini 222128e02042SDavid Gibson /* FIXME: Should register things through the MachineState's qdev 222228e02042SDavid Gibson * interface, this is a legacy from the sPAPREnvironment structure 222328e02042SDavid Gibson * which predated MachineState but had a similar function */ 22244be21d56SDavid Gibson vmstate_register(NULL, 0, &vmstate_spapr, spapr); 22254be21d56SDavid Gibson register_savevm_live(NULL, "spapr/htab", -1, 1, 22264be21d56SDavid Gibson &savevm_htab_handlers, spapr); 22274be21d56SDavid Gibson 222846503c2bSMichael Roth /* used by RTAS */ 222946503c2bSMichael Roth QTAILQ_INIT(&spapr->ccs_list); 223046503c2bSMichael Roth qemu_register_reset(spapr_ccs_reset_hook, spapr); 223146503c2bSMichael Roth 22325b2128d2SAlexander Graf qemu_register_boot_set(spapr_boot_set, spapr); 223342043e4fSLaurent Vivier 223442043e4fSLaurent Vivier /* to stop and start vmclock */ 223542043e4fSLaurent Vivier if (kvm_enabled()) { 223642043e4fSLaurent Vivier qemu_add_vm_change_state_handler(cpu_ppc_clock_vm_state_change, 223742043e4fSLaurent Vivier &spapr->tb); 223842043e4fSLaurent Vivier } 223953018216SPaolo Bonzini } 224053018216SPaolo Bonzini 2241135a129aSAneesh Kumar K.V static int spapr_kvm_type(const char *vm_type) 2242135a129aSAneesh Kumar K.V { 2243135a129aSAneesh Kumar K.V if (!vm_type) { 2244135a129aSAneesh Kumar K.V return 0; 2245135a129aSAneesh Kumar K.V } 2246135a129aSAneesh Kumar K.V 2247135a129aSAneesh Kumar K.V if (!strcmp(vm_type, "HV")) { 2248135a129aSAneesh Kumar K.V return 1; 2249135a129aSAneesh Kumar K.V } 2250135a129aSAneesh Kumar K.V 2251135a129aSAneesh Kumar K.V if (!strcmp(vm_type, "PR")) { 2252135a129aSAneesh Kumar K.V return 2; 2253135a129aSAneesh Kumar K.V } 2254135a129aSAneesh Kumar K.V 2255135a129aSAneesh Kumar K.V error_report("Unknown kvm-type specified '%s'", vm_type); 2256135a129aSAneesh Kumar K.V exit(1); 2257135a129aSAneesh Kumar K.V } 2258135a129aSAneesh Kumar K.V 225971461b0fSAlexey Kardashevskiy /* 2260627b84f4SGonglei * Implementation of an interface to adjust firmware path 226171461b0fSAlexey Kardashevskiy * for the bootindex property handling. 226271461b0fSAlexey Kardashevskiy */ 226371461b0fSAlexey Kardashevskiy static char *spapr_get_fw_dev_path(FWPathProvider *p, BusState *bus, 226471461b0fSAlexey Kardashevskiy DeviceState *dev) 226571461b0fSAlexey Kardashevskiy { 226671461b0fSAlexey Kardashevskiy #define CAST(type, obj, name) \ 226771461b0fSAlexey Kardashevskiy ((type *)object_dynamic_cast(OBJECT(obj), (name))) 226871461b0fSAlexey Kardashevskiy SCSIDevice *d = CAST(SCSIDevice, dev, TYPE_SCSI_DEVICE); 226971461b0fSAlexey Kardashevskiy sPAPRPHBState *phb = CAST(sPAPRPHBState, dev, TYPE_SPAPR_PCI_HOST_BRIDGE); 227071461b0fSAlexey Kardashevskiy 227171461b0fSAlexey Kardashevskiy if (d) { 227271461b0fSAlexey Kardashevskiy void *spapr = CAST(void, bus->parent, "spapr-vscsi"); 227371461b0fSAlexey Kardashevskiy VirtIOSCSI *virtio = CAST(VirtIOSCSI, bus->parent, TYPE_VIRTIO_SCSI); 227471461b0fSAlexey Kardashevskiy USBDevice *usb = CAST(USBDevice, bus->parent, TYPE_USB_DEVICE); 227571461b0fSAlexey Kardashevskiy 227671461b0fSAlexey Kardashevskiy if (spapr) { 227771461b0fSAlexey Kardashevskiy /* 227871461b0fSAlexey Kardashevskiy * Replace "channel@0/disk@0,0" with "disk@8000000000000000": 227971461b0fSAlexey Kardashevskiy * We use SRP luns of the form 8000 | (bus << 8) | (id << 5) | lun 228071461b0fSAlexey Kardashevskiy * in the top 16 bits of the 64-bit LUN 228171461b0fSAlexey Kardashevskiy */ 228271461b0fSAlexey Kardashevskiy unsigned id = 0x8000 | (d->id << 8) | d->lun; 228371461b0fSAlexey Kardashevskiy return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev), 228471461b0fSAlexey Kardashevskiy (uint64_t)id << 48); 228571461b0fSAlexey Kardashevskiy } else if (virtio) { 228671461b0fSAlexey Kardashevskiy /* 228771461b0fSAlexey Kardashevskiy * We use SRP luns of the form 01000000 | (target << 8) | lun 228871461b0fSAlexey Kardashevskiy * in the top 32 bits of the 64-bit LUN 228971461b0fSAlexey Kardashevskiy * Note: the quote above is from SLOF and it is wrong, 229071461b0fSAlexey Kardashevskiy * the actual binding is: 229171461b0fSAlexey Kardashevskiy * swap 0100 or 10 << or 20 << ( target lun-id -- srplun ) 229271461b0fSAlexey Kardashevskiy */ 229371461b0fSAlexey Kardashevskiy unsigned id = 0x1000000 | (d->id << 16) | d->lun; 229471461b0fSAlexey Kardashevskiy return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev), 229571461b0fSAlexey Kardashevskiy (uint64_t)id << 32); 229671461b0fSAlexey Kardashevskiy } else if (usb) { 229771461b0fSAlexey Kardashevskiy /* 229871461b0fSAlexey Kardashevskiy * We use SRP luns of the form 01000000 | (usb-port << 16) | lun 229971461b0fSAlexey Kardashevskiy * in the top 32 bits of the 64-bit LUN 230071461b0fSAlexey Kardashevskiy */ 230171461b0fSAlexey Kardashevskiy unsigned usb_port = atoi(usb->port->path); 230271461b0fSAlexey Kardashevskiy unsigned id = 0x1000000 | (usb_port << 16) | d->lun; 230371461b0fSAlexey Kardashevskiy return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev), 230471461b0fSAlexey Kardashevskiy (uint64_t)id << 32); 230571461b0fSAlexey Kardashevskiy } 230671461b0fSAlexey Kardashevskiy } 230771461b0fSAlexey Kardashevskiy 2308b99260ebSThomas Huth /* 2309b99260ebSThomas Huth * SLOF probes the USB devices, and if it recognizes that the device is a 2310b99260ebSThomas Huth * storage device, it changes its name to "storage" instead of "usb-host", 2311b99260ebSThomas Huth * and additionally adds a child node for the SCSI LUN, so the correct 2312b99260ebSThomas Huth * boot path in SLOF is something like .../storage@1/disk@xxx" instead. 2313b99260ebSThomas Huth */ 2314b99260ebSThomas Huth if (strcmp("usb-host", qdev_fw_name(dev)) == 0) { 2315b99260ebSThomas Huth USBDevice *usbdev = CAST(USBDevice, dev, TYPE_USB_DEVICE); 2316b99260ebSThomas Huth if (usb_host_dev_is_scsi_storage(usbdev)) { 2317b99260ebSThomas Huth return g_strdup_printf("storage@%s/disk", usbdev->port->path); 2318b99260ebSThomas Huth } 2319b99260ebSThomas Huth } 2320b99260ebSThomas Huth 232171461b0fSAlexey Kardashevskiy if (phb) { 232271461b0fSAlexey Kardashevskiy /* Replace "pci" with "pci@800000020000000" */ 232371461b0fSAlexey Kardashevskiy return g_strdup_printf("pci@%"PRIX64, phb->buid); 232471461b0fSAlexey Kardashevskiy } 232571461b0fSAlexey Kardashevskiy 232671461b0fSAlexey Kardashevskiy return NULL; 232771461b0fSAlexey Kardashevskiy } 232871461b0fSAlexey Kardashevskiy 232923825581SEduardo Habkost static char *spapr_get_kvm_type(Object *obj, Error **errp) 233023825581SEduardo Habkost { 233128e02042SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 233223825581SEduardo Habkost 233328e02042SDavid Gibson return g_strdup(spapr->kvm_type); 233423825581SEduardo Habkost } 233523825581SEduardo Habkost 233623825581SEduardo Habkost static void spapr_set_kvm_type(Object *obj, const char *value, Error **errp) 233723825581SEduardo Habkost { 233828e02042SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 233923825581SEduardo Habkost 234028e02042SDavid Gibson g_free(spapr->kvm_type); 234128e02042SDavid Gibson spapr->kvm_type = g_strdup(value); 234223825581SEduardo Habkost } 234323825581SEduardo Habkost 2344f6229214SMichael Roth static bool spapr_get_modern_hotplug_events(Object *obj, Error **errp) 2345f6229214SMichael Roth { 2346f6229214SMichael Roth sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 2347f6229214SMichael Roth 2348f6229214SMichael Roth return spapr->use_hotplug_event_source; 2349f6229214SMichael Roth } 2350f6229214SMichael Roth 2351f6229214SMichael Roth static void spapr_set_modern_hotplug_events(Object *obj, bool value, 2352f6229214SMichael Roth Error **errp) 2353f6229214SMichael Roth { 2354f6229214SMichael Roth sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 2355f6229214SMichael Roth 2356f6229214SMichael Roth spapr->use_hotplug_event_source = value; 2357f6229214SMichael Roth } 2358f6229214SMichael Roth 235923825581SEduardo Habkost static void spapr_machine_initfn(Object *obj) 236023825581SEduardo Habkost { 2361715c5407SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 2362715c5407SDavid Gibson 2363715c5407SDavid Gibson spapr->htab_fd = -1; 2364f6229214SMichael Roth spapr->use_hotplug_event_source = true; 236523825581SEduardo Habkost object_property_add_str(obj, "kvm-type", 236623825581SEduardo Habkost spapr_get_kvm_type, spapr_set_kvm_type, NULL); 236749d2e648SMarcel Apfelbaum object_property_set_description(obj, "kvm-type", 236849d2e648SMarcel Apfelbaum "Specifies the KVM virtualization mode (HV, PR)", 236949d2e648SMarcel Apfelbaum NULL); 2370f6229214SMichael Roth object_property_add_bool(obj, "modern-hotplug-events", 2371f6229214SMichael Roth spapr_get_modern_hotplug_events, 2372f6229214SMichael Roth spapr_set_modern_hotplug_events, 2373f6229214SMichael Roth NULL); 2374f6229214SMichael Roth object_property_set_description(obj, "modern-hotplug-events", 2375f6229214SMichael Roth "Use dedicated hotplug event mechanism in" 2376f6229214SMichael Roth " place of standard EPOW events when possible" 2377f6229214SMichael Roth " (required for memory hot-unplug support)", 2378f6229214SMichael Roth NULL); 237923825581SEduardo Habkost } 238023825581SEduardo Habkost 238187bbdd9cSDavid Gibson static void spapr_machine_finalizefn(Object *obj) 238287bbdd9cSDavid Gibson { 238387bbdd9cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 238487bbdd9cSDavid Gibson 238587bbdd9cSDavid Gibson g_free(spapr->kvm_type); 238687bbdd9cSDavid Gibson } 238787bbdd9cSDavid Gibson 23881c7ad77eSNicholas Piggin void spapr_do_system_reset_on_cpu(CPUState *cs, run_on_cpu_data arg) 238934316482SAlexey Kardashevskiy { 239034316482SAlexey Kardashevskiy cpu_synchronize_state(cs); 239134316482SAlexey Kardashevskiy ppc_cpu_do_system_reset(cs); 239234316482SAlexey Kardashevskiy } 239334316482SAlexey Kardashevskiy 239434316482SAlexey Kardashevskiy static void spapr_nmi(NMIState *n, int cpu_index, Error **errp) 239534316482SAlexey Kardashevskiy { 239634316482SAlexey Kardashevskiy CPUState *cs; 239734316482SAlexey Kardashevskiy 239834316482SAlexey Kardashevskiy CPU_FOREACH(cs) { 23991c7ad77eSNicholas Piggin async_run_on_cpu(cs, spapr_do_system_reset_on_cpu, RUN_ON_CPU_NULL); 240034316482SAlexey Kardashevskiy } 240134316482SAlexey Kardashevskiy } 240234316482SAlexey Kardashevskiy 240379b78a6bSMichael Roth static void spapr_add_lmbs(DeviceState *dev, uint64_t addr_start, uint64_t size, 240479b78a6bSMichael Roth uint32_t node, bool dedicated_hp_event_source, 240579b78a6bSMichael Roth Error **errp) 2406c20d332aSBharata B Rao { 2407c20d332aSBharata B Rao sPAPRDRConnector *drc; 2408c20d332aSBharata B Rao sPAPRDRConnectorClass *drck; 2409c20d332aSBharata B Rao uint32_t nr_lmbs = size/SPAPR_MEMORY_BLOCK_SIZE; 2410c20d332aSBharata B Rao int i, fdt_offset, fdt_size; 2411c20d332aSBharata B Rao void *fdt; 241279b78a6bSMichael Roth uint64_t addr = addr_start; 2413c20d332aSBharata B Rao 2414c20d332aSBharata B Rao for (i = 0; i < nr_lmbs; i++) { 2415c20d332aSBharata B Rao drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_LMB, 2416c20d332aSBharata B Rao addr/SPAPR_MEMORY_BLOCK_SIZE); 2417c20d332aSBharata B Rao g_assert(drc); 2418c20d332aSBharata B Rao 2419c20d332aSBharata B Rao fdt = create_device_tree(&fdt_size); 2420c20d332aSBharata B Rao fdt_offset = spapr_populate_memory_node(fdt, node, addr, 2421c20d332aSBharata B Rao SPAPR_MEMORY_BLOCK_SIZE); 2422c20d332aSBharata B Rao 2423c20d332aSBharata B Rao drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 2424c20d332aSBharata B Rao drck->attach(drc, dev, fdt, fdt_offset, !dev->hotplugged, errp); 2425c20d332aSBharata B Rao addr += SPAPR_MEMORY_BLOCK_SIZE; 24265c0139a8SMichael Roth if (!dev->hotplugged) { 24275c0139a8SMichael Roth /* guests expect coldplugged LMBs to be pre-allocated */ 24285c0139a8SMichael Roth drck->set_allocation_state(drc, SPAPR_DR_ALLOCATION_STATE_USABLE); 24295c0139a8SMichael Roth drck->set_isolation_state(drc, SPAPR_DR_ISOLATION_STATE_UNISOLATED); 24305c0139a8SMichael Roth } 2431c20d332aSBharata B Rao } 24325dd5238cSJianjun Duan /* send hotplug notification to the 24335dd5238cSJianjun Duan * guest only in case of hotplugged memory 24345dd5238cSJianjun Duan */ 24355dd5238cSJianjun Duan if (dev->hotplugged) { 243679b78a6bSMichael Roth if (dedicated_hp_event_source) { 243779b78a6bSMichael Roth drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_LMB, 243879b78a6bSMichael Roth addr_start / SPAPR_MEMORY_BLOCK_SIZE); 243979b78a6bSMichael Roth drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 244079b78a6bSMichael Roth spapr_hotplug_req_add_by_count_indexed(SPAPR_DR_CONNECTOR_TYPE_LMB, 244179b78a6bSMichael Roth nr_lmbs, 244279b78a6bSMichael Roth drck->get_index(drc)); 244379b78a6bSMichael Roth } else { 244479b78a6bSMichael Roth spapr_hotplug_req_add_by_count(SPAPR_DR_CONNECTOR_TYPE_LMB, 244579b78a6bSMichael Roth nr_lmbs); 244679b78a6bSMichael Roth } 2447c20d332aSBharata B Rao } 24485dd5238cSJianjun Duan } 2449c20d332aSBharata B Rao 2450c20d332aSBharata B Rao static void spapr_memory_plug(HotplugHandler *hotplug_dev, DeviceState *dev, 2451c20d332aSBharata B Rao uint32_t node, Error **errp) 2452c20d332aSBharata B Rao { 2453c20d332aSBharata B Rao Error *local_err = NULL; 2454c20d332aSBharata B Rao sPAPRMachineState *ms = SPAPR_MACHINE(hotplug_dev); 2455c20d332aSBharata B Rao PCDIMMDevice *dimm = PC_DIMM(dev); 2456c20d332aSBharata B Rao PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); 2457c20d332aSBharata B Rao MemoryRegion *mr = ddc->get_memory_region(dimm); 2458c20d332aSBharata B Rao uint64_t align = memory_region_get_alignment(mr); 2459c20d332aSBharata B Rao uint64_t size = memory_region_size(mr); 2460c20d332aSBharata B Rao uint64_t addr; 2461df587133SThomas Huth char *mem_dev; 2462c20d332aSBharata B Rao 2463c20d332aSBharata B Rao if (size % SPAPR_MEMORY_BLOCK_SIZE) { 2464c20d332aSBharata B Rao error_setg(&local_err, "Hotplugged memory size must be a multiple of " 2465c20d332aSBharata B Rao "%lld MB", SPAPR_MEMORY_BLOCK_SIZE/M_BYTE); 2466c20d332aSBharata B Rao goto out; 2467c20d332aSBharata B Rao } 2468c20d332aSBharata B Rao 2469df587133SThomas Huth mem_dev = object_property_get_str(OBJECT(dimm), PC_DIMM_MEMDEV_PROP, NULL); 2470df587133SThomas Huth if (mem_dev && !kvmppc_is_mem_backend_page_size_ok(mem_dev)) { 2471df587133SThomas Huth error_setg(&local_err, "Memory backend has bad page size. " 2472df587133SThomas Huth "Use 'memory-backend-file' with correct mem-path."); 2473df587133SThomas Huth goto out; 2474df587133SThomas Huth } 2475df587133SThomas Huth 2476d6a9b0b8SMichael S. Tsirkin pc_dimm_memory_plug(dev, &ms->hotplug_memory, mr, align, &local_err); 2477c20d332aSBharata B Rao if (local_err) { 2478c20d332aSBharata B Rao goto out; 2479c20d332aSBharata B Rao } 2480c20d332aSBharata B Rao 2481c20d332aSBharata B Rao addr = object_property_get_int(OBJECT(dimm), PC_DIMM_ADDR_PROP, &local_err); 2482c20d332aSBharata B Rao if (local_err) { 2483c20d332aSBharata B Rao pc_dimm_memory_unplug(dev, &ms->hotplug_memory, mr); 2484c20d332aSBharata B Rao goto out; 2485c20d332aSBharata B Rao } 2486c20d332aSBharata B Rao 248779b78a6bSMichael Roth spapr_add_lmbs(dev, addr, size, node, 248879b78a6bSMichael Roth spapr_ovec_test(ms->ov5_cas, OV5_HP_EVT), 248979b78a6bSMichael Roth &error_abort); 2490c20d332aSBharata B Rao 2491c20d332aSBharata B Rao out: 2492c20d332aSBharata B Rao error_propagate(errp, local_err); 2493c20d332aSBharata B Rao } 2494c20d332aSBharata B Rao 2495cf632463SBharata B Rao typedef struct sPAPRDIMMState { 2496cf632463SBharata B Rao uint32_t nr_lmbs; 2497cf632463SBharata B Rao } sPAPRDIMMState; 2498cf632463SBharata B Rao 2499cf632463SBharata B Rao static void spapr_lmb_release(DeviceState *dev, void *opaque) 2500cf632463SBharata B Rao { 2501cf632463SBharata B Rao sPAPRDIMMState *ds = (sPAPRDIMMState *)opaque; 2502cf632463SBharata B Rao HotplugHandler *hotplug_ctrl; 2503cf632463SBharata B Rao 2504cf632463SBharata B Rao if (--ds->nr_lmbs) { 2505cf632463SBharata B Rao return; 2506cf632463SBharata B Rao } 2507cf632463SBharata B Rao 2508cf632463SBharata B Rao g_free(ds); 2509cf632463SBharata B Rao 2510cf632463SBharata B Rao /* 2511cf632463SBharata B Rao * Now that all the LMBs have been removed by the guest, call the 2512cf632463SBharata B Rao * pc-dimm unplug handler to cleanup up the pc-dimm device. 2513cf632463SBharata B Rao */ 2514cf632463SBharata B Rao hotplug_ctrl = qdev_get_hotplug_handler(dev); 2515cf632463SBharata B Rao hotplug_handler_unplug(hotplug_ctrl, dev, &error_abort); 2516cf632463SBharata B Rao } 2517cf632463SBharata B Rao 2518cf632463SBharata B Rao static void spapr_del_lmbs(DeviceState *dev, uint64_t addr_start, uint64_t size, 2519cf632463SBharata B Rao Error **errp) 2520cf632463SBharata B Rao { 2521cf632463SBharata B Rao sPAPRDRConnector *drc; 2522cf632463SBharata B Rao sPAPRDRConnectorClass *drck; 2523cf632463SBharata B Rao uint32_t nr_lmbs = size / SPAPR_MEMORY_BLOCK_SIZE; 2524cf632463SBharata B Rao int i; 2525cf632463SBharata B Rao sPAPRDIMMState *ds = g_malloc0(sizeof(sPAPRDIMMState)); 2526cf632463SBharata B Rao uint64_t addr = addr_start; 2527cf632463SBharata B Rao 2528cf632463SBharata B Rao ds->nr_lmbs = nr_lmbs; 2529cf632463SBharata B Rao for (i = 0; i < nr_lmbs; i++) { 2530cf632463SBharata B Rao drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_LMB, 2531cf632463SBharata B Rao addr / SPAPR_MEMORY_BLOCK_SIZE); 2532cf632463SBharata B Rao g_assert(drc); 2533cf632463SBharata B Rao 2534cf632463SBharata B Rao drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 2535cf632463SBharata B Rao drck->detach(drc, dev, spapr_lmb_release, ds, errp); 2536cf632463SBharata B Rao addr += SPAPR_MEMORY_BLOCK_SIZE; 2537cf632463SBharata B Rao } 2538cf632463SBharata B Rao 2539cf632463SBharata B Rao drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_LMB, 2540cf632463SBharata B Rao addr_start / SPAPR_MEMORY_BLOCK_SIZE); 2541cf632463SBharata B Rao drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 2542cf632463SBharata B Rao spapr_hotplug_req_remove_by_count_indexed(SPAPR_DR_CONNECTOR_TYPE_LMB, 2543cf632463SBharata B Rao nr_lmbs, 2544cf632463SBharata B Rao drck->get_index(drc)); 2545cf632463SBharata B Rao } 2546cf632463SBharata B Rao 2547cf632463SBharata B Rao static void spapr_memory_unplug(HotplugHandler *hotplug_dev, DeviceState *dev, 2548cf632463SBharata B Rao Error **errp) 2549cf632463SBharata B Rao { 2550cf632463SBharata B Rao sPAPRMachineState *ms = SPAPR_MACHINE(hotplug_dev); 2551cf632463SBharata B Rao PCDIMMDevice *dimm = PC_DIMM(dev); 2552cf632463SBharata B Rao PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); 2553cf632463SBharata B Rao MemoryRegion *mr = ddc->get_memory_region(dimm); 2554cf632463SBharata B Rao 2555cf632463SBharata B Rao pc_dimm_memory_unplug(dev, &ms->hotplug_memory, mr); 2556cf632463SBharata B Rao object_unparent(OBJECT(dev)); 2557cf632463SBharata B Rao } 2558cf632463SBharata B Rao 2559cf632463SBharata B Rao static void spapr_memory_unplug_request(HotplugHandler *hotplug_dev, 2560cf632463SBharata B Rao DeviceState *dev, Error **errp) 2561cf632463SBharata B Rao { 2562cf632463SBharata B Rao Error *local_err = NULL; 2563cf632463SBharata B Rao PCDIMMDevice *dimm = PC_DIMM(dev); 2564cf632463SBharata B Rao PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); 2565cf632463SBharata B Rao MemoryRegion *mr = ddc->get_memory_region(dimm); 2566cf632463SBharata B Rao uint64_t size = memory_region_size(mr); 2567cf632463SBharata B Rao uint64_t addr; 2568cf632463SBharata B Rao 2569cf632463SBharata B Rao addr = object_property_get_int(OBJECT(dimm), PC_DIMM_ADDR_PROP, &local_err); 2570cf632463SBharata B Rao if (local_err) { 2571cf632463SBharata B Rao goto out; 2572cf632463SBharata B Rao } 2573cf632463SBharata B Rao 2574cf632463SBharata B Rao spapr_del_lmbs(dev, addr, size, &error_abort); 2575cf632463SBharata B Rao out: 2576cf632463SBharata B Rao error_propagate(errp, local_err); 2577cf632463SBharata B Rao } 2578cf632463SBharata B Rao 2579af81cf32SBharata B Rao void *spapr_populate_hotplug_cpu_dt(CPUState *cs, int *fdt_offset, 2580af81cf32SBharata B Rao sPAPRMachineState *spapr) 2581af81cf32SBharata B Rao { 2582af81cf32SBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(cs); 2583af81cf32SBharata B Rao DeviceClass *dc = DEVICE_GET_CLASS(cs); 2584af81cf32SBharata B Rao int id = ppc_get_vcpu_dt_id(cpu); 2585af81cf32SBharata B Rao void *fdt; 2586af81cf32SBharata B Rao int offset, fdt_size; 2587af81cf32SBharata B Rao char *nodename; 2588af81cf32SBharata B Rao 2589af81cf32SBharata B Rao fdt = create_device_tree(&fdt_size); 2590af81cf32SBharata B Rao nodename = g_strdup_printf("%s@%x", dc->fw_name, id); 2591af81cf32SBharata B Rao offset = fdt_add_subnode(fdt, 0, nodename); 2592af81cf32SBharata B Rao 2593af81cf32SBharata B Rao spapr_populate_cpu_dt(cs, fdt, offset, spapr); 2594af81cf32SBharata B Rao g_free(nodename); 2595af81cf32SBharata B Rao 2596af81cf32SBharata B Rao *fdt_offset = offset; 2597af81cf32SBharata B Rao return fdt; 2598af81cf32SBharata B Rao } 2599af81cf32SBharata B Rao 2600115debf2SIgor Mammedov static void spapr_core_unplug(HotplugHandler *hotplug_dev, DeviceState *dev, 2601115debf2SIgor Mammedov Error **errp) 2602ff9006ddSIgor Mammedov { 2603535455fdSIgor Mammedov MachineState *ms = MACHINE(qdev_get_machine()); 2604ff9006ddSIgor Mammedov CPUCore *cc = CPU_CORE(dev); 2605535455fdSIgor Mammedov CPUArchId *core_slot = spapr_find_cpu_slot(ms, cc->core_id, NULL); 2606ff9006ddSIgor Mammedov 2607535455fdSIgor Mammedov core_slot->cpu = NULL; 2608ff9006ddSIgor Mammedov object_unparent(OBJECT(dev)); 2609ff9006ddSIgor Mammedov } 2610ff9006ddSIgor Mammedov 2611115debf2SIgor Mammedov static void spapr_core_release(DeviceState *dev, void *opaque) 2612115debf2SIgor Mammedov { 2613115debf2SIgor Mammedov HotplugHandler *hotplug_ctrl; 2614115debf2SIgor Mammedov 2615115debf2SIgor Mammedov hotplug_ctrl = qdev_get_hotplug_handler(dev); 2616115debf2SIgor Mammedov hotplug_handler_unplug(hotplug_ctrl, dev, &error_abort); 2617115debf2SIgor Mammedov } 2618115debf2SIgor Mammedov 2619115debf2SIgor Mammedov static 2620115debf2SIgor Mammedov void spapr_core_unplug_request(HotplugHandler *hotplug_dev, DeviceState *dev, 2621ff9006ddSIgor Mammedov Error **errp) 2622ff9006ddSIgor Mammedov { 2623535455fdSIgor Mammedov int index; 2624535455fdSIgor Mammedov sPAPRDRConnector *drc; 2625ff9006ddSIgor Mammedov sPAPRDRConnectorClass *drck; 2626ff9006ddSIgor Mammedov Error *local_err = NULL; 2627535455fdSIgor Mammedov CPUCore *cc = CPU_CORE(dev); 2628535455fdSIgor Mammedov int smt = kvmppc_smt_threads(); 2629ff9006ddSIgor Mammedov 2630535455fdSIgor Mammedov if (!spapr_find_cpu_slot(MACHINE(hotplug_dev), cc->core_id, &index)) { 2631535455fdSIgor Mammedov error_setg(errp, "Unable to find CPU core with core-id: %d", 2632535455fdSIgor Mammedov cc->core_id); 2633535455fdSIgor Mammedov return; 2634535455fdSIgor Mammedov } 2635ff9006ddSIgor Mammedov if (index == 0) { 2636ff9006ddSIgor Mammedov error_setg(errp, "Boot CPU core may not be unplugged"); 2637ff9006ddSIgor Mammedov return; 2638ff9006ddSIgor Mammedov } 2639ff9006ddSIgor Mammedov 2640535455fdSIgor Mammedov drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_CPU, index * smt); 2641ff9006ddSIgor Mammedov g_assert(drc); 2642ff9006ddSIgor Mammedov 2643ff9006ddSIgor Mammedov drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 2644ff9006ddSIgor Mammedov drck->detach(drc, dev, spapr_core_release, NULL, &local_err); 2645ff9006ddSIgor Mammedov if (local_err) { 2646ff9006ddSIgor Mammedov error_propagate(errp, local_err); 2647ff9006ddSIgor Mammedov return; 2648ff9006ddSIgor Mammedov } 2649ff9006ddSIgor Mammedov 2650ff9006ddSIgor Mammedov spapr_hotplug_req_remove_by_index(drc); 2651ff9006ddSIgor Mammedov } 2652ff9006ddSIgor Mammedov 2653ff9006ddSIgor Mammedov static void spapr_core_plug(HotplugHandler *hotplug_dev, DeviceState *dev, 2654ff9006ddSIgor Mammedov Error **errp) 2655ff9006ddSIgor Mammedov { 2656ff9006ddSIgor Mammedov sPAPRMachineState *spapr = SPAPR_MACHINE(OBJECT(hotplug_dev)); 2657ff9006ddSIgor Mammedov MachineClass *mc = MACHINE_GET_CLASS(spapr); 2658ff9006ddSIgor Mammedov sPAPRCPUCore *core = SPAPR_CPU_CORE(OBJECT(dev)); 2659ff9006ddSIgor Mammedov CPUCore *cc = CPU_CORE(dev); 2660ff9006ddSIgor Mammedov CPUState *cs = CPU(core->threads); 2661ff9006ddSIgor Mammedov sPAPRDRConnector *drc; 2662ff9006ddSIgor Mammedov Error *local_err = NULL; 2663ff9006ddSIgor Mammedov void *fdt = NULL; 2664ff9006ddSIgor Mammedov int fdt_offset = 0; 2665ff9006ddSIgor Mammedov int smt = kvmppc_smt_threads(); 2666535455fdSIgor Mammedov CPUArchId *core_slot; 2667535455fdSIgor Mammedov int index; 2668ff9006ddSIgor Mammedov 2669535455fdSIgor Mammedov core_slot = spapr_find_cpu_slot(MACHINE(hotplug_dev), cc->core_id, &index); 2670535455fdSIgor Mammedov if (!core_slot) { 2671535455fdSIgor Mammedov error_setg(errp, "Unable to find CPU core with core-id: %d", 2672535455fdSIgor Mammedov cc->core_id); 2673535455fdSIgor Mammedov return; 2674535455fdSIgor Mammedov } 2675ff9006ddSIgor Mammedov drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_CPU, index * smt); 2676ff9006ddSIgor Mammedov 2677c5514d0eSIgor Mammedov g_assert(drc || !mc->has_hotpluggable_cpus); 2678ff9006ddSIgor Mammedov 2679ff9006ddSIgor Mammedov /* 2680ff9006ddSIgor Mammedov * Setup CPU DT entries only for hotplugged CPUs. For boot time or 2681ff9006ddSIgor Mammedov * coldplugged CPUs DT entries are setup in spapr_build_fdt(). 2682ff9006ddSIgor Mammedov */ 2683ff9006ddSIgor Mammedov if (dev->hotplugged) { 2684ff9006ddSIgor Mammedov fdt = spapr_populate_hotplug_cpu_dt(cs, &fdt_offset, spapr); 2685ff9006ddSIgor Mammedov } 2686ff9006ddSIgor Mammedov 2687ff9006ddSIgor Mammedov if (drc) { 2688ff9006ddSIgor Mammedov sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 2689ff9006ddSIgor Mammedov drck->attach(drc, dev, fdt, fdt_offset, !dev->hotplugged, &local_err); 2690ff9006ddSIgor Mammedov if (local_err) { 2691ff9006ddSIgor Mammedov g_free(fdt); 2692ff9006ddSIgor Mammedov error_propagate(errp, local_err); 2693ff9006ddSIgor Mammedov return; 2694ff9006ddSIgor Mammedov } 2695ff9006ddSIgor Mammedov } 2696ff9006ddSIgor Mammedov 2697ff9006ddSIgor Mammedov if (dev->hotplugged) { 2698ff9006ddSIgor Mammedov /* 2699ff9006ddSIgor Mammedov * Send hotplug notification interrupt to the guest only in case 2700ff9006ddSIgor Mammedov * of hotplugged CPUs. 2701ff9006ddSIgor Mammedov */ 2702ff9006ddSIgor Mammedov spapr_hotplug_req_add_by_index(drc); 2703ff9006ddSIgor Mammedov } else { 2704ff9006ddSIgor Mammedov /* 2705ff9006ddSIgor Mammedov * Set the right DRC states for cold plugged CPU. 2706ff9006ddSIgor Mammedov */ 2707ff9006ddSIgor Mammedov if (drc) { 2708ff9006ddSIgor Mammedov sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 2709ff9006ddSIgor Mammedov drck->set_allocation_state(drc, SPAPR_DR_ALLOCATION_STATE_USABLE); 2710ff9006ddSIgor Mammedov drck->set_isolation_state(drc, SPAPR_DR_ISOLATION_STATE_UNISOLATED); 2711ff9006ddSIgor Mammedov } 2712ff9006ddSIgor Mammedov } 2713535455fdSIgor Mammedov core_slot->cpu = OBJECT(dev); 2714ff9006ddSIgor Mammedov } 2715ff9006ddSIgor Mammedov 2716ff9006ddSIgor Mammedov static void spapr_core_pre_plug(HotplugHandler *hotplug_dev, DeviceState *dev, 2717ff9006ddSIgor Mammedov Error **errp) 2718ff9006ddSIgor Mammedov { 2719ff9006ddSIgor Mammedov MachineState *machine = MACHINE(OBJECT(hotplug_dev)); 2720ff9006ddSIgor Mammedov MachineClass *mc = MACHINE_GET_CLASS(hotplug_dev); 2721ff9006ddSIgor Mammedov Error *local_err = NULL; 2722ff9006ddSIgor Mammedov CPUCore *cc = CPU_CORE(dev); 2723ff9006ddSIgor Mammedov char *base_core_type = spapr_get_cpu_core_type(machine->cpu_model); 2724ff9006ddSIgor Mammedov const char *type = object_get_typename(OBJECT(dev)); 2725535455fdSIgor Mammedov CPUArchId *core_slot; 2726535455fdSIgor Mammedov int index; 2727ff9006ddSIgor Mammedov 2728c5514d0eSIgor Mammedov if (dev->hotplugged && !mc->has_hotpluggable_cpus) { 2729ff9006ddSIgor Mammedov error_setg(&local_err, "CPU hotplug not supported for this machine"); 2730ff9006ddSIgor Mammedov goto out; 2731ff9006ddSIgor Mammedov } 2732ff9006ddSIgor Mammedov 2733ff9006ddSIgor Mammedov if (strcmp(base_core_type, type)) { 2734ff9006ddSIgor Mammedov error_setg(&local_err, "CPU core type should be %s", base_core_type); 2735ff9006ddSIgor Mammedov goto out; 2736ff9006ddSIgor Mammedov } 2737ff9006ddSIgor Mammedov 2738ff9006ddSIgor Mammedov if (cc->core_id % smp_threads) { 2739ff9006ddSIgor Mammedov error_setg(&local_err, "invalid core id %d", cc->core_id); 2740ff9006ddSIgor Mammedov goto out; 2741ff9006ddSIgor Mammedov } 2742ff9006ddSIgor Mammedov 2743535455fdSIgor Mammedov core_slot = spapr_find_cpu_slot(MACHINE(hotplug_dev), cc->core_id, &index); 2744535455fdSIgor Mammedov if (!core_slot) { 2745ff9006ddSIgor Mammedov error_setg(&local_err, "core id %d out of range", cc->core_id); 2746ff9006ddSIgor Mammedov goto out; 2747ff9006ddSIgor Mammedov } 2748ff9006ddSIgor Mammedov 2749535455fdSIgor Mammedov if (core_slot->cpu) { 2750ff9006ddSIgor Mammedov error_setg(&local_err, "core %d already populated", cc->core_id); 2751ff9006ddSIgor Mammedov goto out; 2752ff9006ddSIgor Mammedov } 2753ff9006ddSIgor Mammedov 2754ff9006ddSIgor Mammedov out: 2755ff9006ddSIgor Mammedov g_free(base_core_type); 2756ff9006ddSIgor Mammedov error_propagate(errp, local_err); 2757ff9006ddSIgor Mammedov } 2758ff9006ddSIgor Mammedov 2759c20d332aSBharata B Rao static void spapr_machine_device_plug(HotplugHandler *hotplug_dev, 2760c20d332aSBharata B Rao DeviceState *dev, Error **errp) 2761c20d332aSBharata B Rao { 2762c20d332aSBharata B Rao sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(qdev_get_machine()); 2763c20d332aSBharata B Rao 2764c20d332aSBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { 2765b556854bSBharata B Rao int node; 2766c20d332aSBharata B Rao 2767c20d332aSBharata B Rao if (!smc->dr_lmb_enabled) { 2768c20d332aSBharata B Rao error_setg(errp, "Memory hotplug not supported for this machine"); 2769c20d332aSBharata B Rao return; 2770c20d332aSBharata B Rao } 2771c20d332aSBharata B Rao node = object_property_get_int(OBJECT(dev), PC_DIMM_NODE_PROP, errp); 2772c20d332aSBharata B Rao if (*errp) { 2773c20d332aSBharata B Rao return; 2774c20d332aSBharata B Rao } 27751a5512bbSGonglei if (node < 0 || node >= MAX_NODES) { 27761a5512bbSGonglei error_setg(errp, "Invaild node %d", node); 27771a5512bbSGonglei return; 27781a5512bbSGonglei } 2779c20d332aSBharata B Rao 2780b556854bSBharata B Rao /* 2781b556854bSBharata B Rao * Currently PowerPC kernel doesn't allow hot-adding memory to 2782b556854bSBharata B Rao * memory-less node, but instead will silently add the memory 2783b556854bSBharata B Rao * to the first node that has some memory. This causes two 2784b556854bSBharata B Rao * unexpected behaviours for the user. 2785b556854bSBharata B Rao * 2786b556854bSBharata B Rao * - Memory gets hotplugged to a different node than what the user 2787b556854bSBharata B Rao * specified. 2788b556854bSBharata B Rao * - Since pc-dimm subsystem in QEMU still thinks that memory belongs 2789b556854bSBharata B Rao * to memory-less node, a reboot will set things accordingly 2790b556854bSBharata B Rao * and the previously hotplugged memory now ends in the right node. 2791b556854bSBharata B Rao * This appears as if some memory moved from one node to another. 2792b556854bSBharata B Rao * 2793b556854bSBharata B Rao * So until kernel starts supporting memory hotplug to memory-less 2794b556854bSBharata B Rao * nodes, just prevent such attempts upfront in QEMU. 2795b556854bSBharata B Rao */ 2796b556854bSBharata B Rao if (nb_numa_nodes && !numa_info[node].node_mem) { 2797b556854bSBharata B Rao error_setg(errp, "Can't hotplug memory to memory-less node %d", 2798b556854bSBharata B Rao node); 2799b556854bSBharata B Rao return; 2800b556854bSBharata B Rao } 2801b556854bSBharata B Rao 2802c20d332aSBharata B Rao spapr_memory_plug(hotplug_dev, dev, node, errp); 2803af81cf32SBharata B Rao } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 2804af81cf32SBharata B Rao spapr_core_plug(hotplug_dev, dev, errp); 2805c20d332aSBharata B Rao } 2806c20d332aSBharata B Rao } 2807c20d332aSBharata B Rao 2808c20d332aSBharata B Rao static void spapr_machine_device_unplug(HotplugHandler *hotplug_dev, 2809c20d332aSBharata B Rao DeviceState *dev, Error **errp) 2810c20d332aSBharata B Rao { 2811cf632463SBharata B Rao sPAPRMachineState *sms = SPAPR_MACHINE(qdev_get_machine()); 28123c0c47e3SDavid Gibson MachineClass *mc = MACHINE_GET_CLASS(qdev_get_machine()); 28136f4b5c3eSBharata B Rao 2814c20d332aSBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { 2815cf632463SBharata B Rao if (spapr_ovec_test(sms->ov5_cas, OV5_HP_EVT)) { 2816cf632463SBharata B Rao spapr_memory_unplug(hotplug_dev, dev, errp); 2817cf632463SBharata B Rao } else { 2818cf632463SBharata B Rao error_setg(errp, "Memory hot unplug not supported for this guest"); 2819cf632463SBharata B Rao } 2820cf632463SBharata B Rao } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 2821c5514d0eSIgor Mammedov if (!mc->has_hotpluggable_cpus) { 2822cf632463SBharata B Rao error_setg(errp, "CPU hot unplug not supported on this machine"); 2823cf632463SBharata B Rao return; 2824cf632463SBharata B Rao } 2825cf632463SBharata B Rao spapr_core_unplug(hotplug_dev, dev, errp); 2826cf632463SBharata B Rao } 2827cf632463SBharata B Rao } 2828cf632463SBharata B Rao 2829cf632463SBharata B Rao static void spapr_machine_device_unplug_request(HotplugHandler *hotplug_dev, 2830cf632463SBharata B Rao DeviceState *dev, Error **errp) 2831cf632463SBharata B Rao { 2832cf632463SBharata B Rao sPAPRMachineState *sms = SPAPR_MACHINE(qdev_get_machine()); 2833cf632463SBharata B Rao MachineClass *mc = MACHINE_GET_CLASS(qdev_get_machine()); 2834cf632463SBharata B Rao 2835cf632463SBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { 2836cf632463SBharata B Rao if (spapr_ovec_test(sms->ov5_cas, OV5_HP_EVT)) { 2837cf632463SBharata B Rao spapr_memory_unplug_request(hotplug_dev, dev, errp); 2838cf632463SBharata B Rao } else { 2839cf632463SBharata B Rao /* NOTE: this means there is a window after guest reset, prior to 2840cf632463SBharata B Rao * CAS negotiation, where unplug requests will fail due to the 2841cf632463SBharata B Rao * capability not being detected yet. This is a bit different than 2842cf632463SBharata B Rao * the case with PCI unplug, where the events will be queued and 2843cf632463SBharata B Rao * eventually handled by the guest after boot 2844cf632463SBharata B Rao */ 2845cf632463SBharata B Rao error_setg(errp, "Memory hot unplug not supported for this guest"); 2846cf632463SBharata B Rao } 28476f4b5c3eSBharata B Rao } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 2848c5514d0eSIgor Mammedov if (!mc->has_hotpluggable_cpus) { 28496f4b5c3eSBharata B Rao error_setg(errp, "CPU hot unplug not supported on this machine"); 28506f4b5c3eSBharata B Rao return; 28516f4b5c3eSBharata B Rao } 2852115debf2SIgor Mammedov spapr_core_unplug_request(hotplug_dev, dev, errp); 2853c20d332aSBharata B Rao } 2854c20d332aSBharata B Rao } 2855c20d332aSBharata B Rao 285694a94e4cSBharata B Rao static void spapr_machine_device_pre_plug(HotplugHandler *hotplug_dev, 285794a94e4cSBharata B Rao DeviceState *dev, Error **errp) 285894a94e4cSBharata B Rao { 285994a94e4cSBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 286094a94e4cSBharata B Rao spapr_core_pre_plug(hotplug_dev, dev, errp); 286194a94e4cSBharata B Rao } 286294a94e4cSBharata B Rao } 286394a94e4cSBharata B Rao 28647ebaf795SBharata B Rao static HotplugHandler *spapr_get_hotplug_handler(MachineState *machine, 2865c20d332aSBharata B Rao DeviceState *dev) 2866c20d332aSBharata B Rao { 286794a94e4cSBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM) || 286894a94e4cSBharata B Rao object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 2869c20d332aSBharata B Rao return HOTPLUG_HANDLER(machine); 2870c20d332aSBharata B Rao } 2871c20d332aSBharata B Rao return NULL; 2872c20d332aSBharata B Rao } 2873c20d332aSBharata B Rao 287420bb648dSDavid Gibson static unsigned spapr_cpu_index_to_socket_id(unsigned cpu_index) 287520bb648dSDavid Gibson { 287620bb648dSDavid Gibson /* Allocate to NUMA nodes on a "socket" basis (not that concept of 287720bb648dSDavid Gibson * socket means much for the paravirtualized PAPR platform) */ 287820bb648dSDavid Gibson return cpu_index / smp_threads / smp_cores; 287920bb648dSDavid Gibson } 288020bb648dSDavid Gibson 2881535455fdSIgor Mammedov static const CPUArchIdList *spapr_possible_cpu_arch_ids(MachineState *machine) 2882535455fdSIgor Mammedov { 2883535455fdSIgor Mammedov int i; 2884535455fdSIgor Mammedov int spapr_max_cores = max_cpus / smp_threads; 2885535455fdSIgor Mammedov MachineClass *mc = MACHINE_GET_CLASS(machine); 2886535455fdSIgor Mammedov 2887c5514d0eSIgor Mammedov if (!mc->has_hotpluggable_cpus) { 2888535455fdSIgor Mammedov spapr_max_cores = QEMU_ALIGN_UP(smp_cpus, smp_threads) / smp_threads; 2889535455fdSIgor Mammedov } 2890535455fdSIgor Mammedov if (machine->possible_cpus) { 2891535455fdSIgor Mammedov assert(machine->possible_cpus->len == spapr_max_cores); 2892535455fdSIgor Mammedov return machine->possible_cpus; 2893535455fdSIgor Mammedov } 2894535455fdSIgor Mammedov 2895535455fdSIgor Mammedov machine->possible_cpus = g_malloc0(sizeof(CPUArchIdList) + 2896535455fdSIgor Mammedov sizeof(CPUArchId) * spapr_max_cores); 2897535455fdSIgor Mammedov machine->possible_cpus->len = spapr_max_cores; 2898535455fdSIgor Mammedov for (i = 0; i < machine->possible_cpus->len; i++) { 2899535455fdSIgor Mammedov int core_id = i * smp_threads; 2900535455fdSIgor Mammedov 2901f2d672c2SIgor Mammedov machine->possible_cpus->cpus[i].vcpus_count = smp_threads; 2902535455fdSIgor Mammedov machine->possible_cpus->cpus[i].arch_id = core_id; 2903535455fdSIgor Mammedov machine->possible_cpus->cpus[i].props.has_core_id = true; 2904535455fdSIgor Mammedov machine->possible_cpus->cpus[i].props.core_id = core_id; 2905535455fdSIgor Mammedov /* TODO: add 'has_node/node' here to describe 2906535455fdSIgor Mammedov to which node core belongs */ 2907535455fdSIgor Mammedov } 2908535455fdSIgor Mammedov return machine->possible_cpus; 2909535455fdSIgor Mammedov } 2910535455fdSIgor Mammedov 29116737d9adSDavid Gibson static void spapr_phb_placement(sPAPRMachineState *spapr, uint32_t index, 2912daa23699SDavid Gibson uint64_t *buid, hwaddr *pio, 2913daa23699SDavid Gibson hwaddr *mmio32, hwaddr *mmio64, 29146737d9adSDavid Gibson unsigned n_dma, uint32_t *liobns, Error **errp) 29156737d9adSDavid Gibson { 2916357d1e3bSDavid Gibson /* 2917357d1e3bSDavid Gibson * New-style PHB window placement. 2918357d1e3bSDavid Gibson * 2919357d1e3bSDavid Gibson * Goals: Gives large (1TiB), naturally aligned 64-bit MMIO window 2920357d1e3bSDavid Gibson * for each PHB, in addition to 2GiB 32-bit MMIO and 64kiB PIO 2921357d1e3bSDavid Gibson * windows. 2922357d1e3bSDavid Gibson * 2923357d1e3bSDavid Gibson * Some guest kernels can't work with MMIO windows above 1<<46 2924357d1e3bSDavid Gibson * (64TiB), so we place up to 31 PHBs in the area 32TiB..64TiB 2925357d1e3bSDavid Gibson * 2926357d1e3bSDavid Gibson * 32TiB..(33TiB+1984kiB) contains the 64kiB PIO windows for each 2927357d1e3bSDavid Gibson * PHB stacked together. (32TiB+2GiB)..(32TiB+64GiB) contains the 2928357d1e3bSDavid Gibson * 2GiB 32-bit MMIO windows for each PHB. Then 33..64TiB has the 2929357d1e3bSDavid Gibson * 1TiB 64-bit MMIO windows for each PHB. 2930357d1e3bSDavid Gibson */ 29316737d9adSDavid Gibson const uint64_t base_buid = 0x800000020000000ULL; 293225e6a118SMichael S. Tsirkin #define SPAPR_MAX_PHBS ((SPAPR_PCI_LIMIT - SPAPR_PCI_BASE) / \ 293325e6a118SMichael S. Tsirkin SPAPR_PCI_MEM64_WIN_SIZE - 1) 29346737d9adSDavid Gibson int i; 29356737d9adSDavid Gibson 2936357d1e3bSDavid Gibson /* Sanity check natural alignments */ 2937357d1e3bSDavid Gibson QEMU_BUILD_BUG_ON((SPAPR_PCI_BASE % SPAPR_PCI_MEM64_WIN_SIZE) != 0); 2938357d1e3bSDavid Gibson QEMU_BUILD_BUG_ON((SPAPR_PCI_LIMIT % SPAPR_PCI_MEM64_WIN_SIZE) != 0); 2939357d1e3bSDavid Gibson QEMU_BUILD_BUG_ON((SPAPR_PCI_MEM64_WIN_SIZE % SPAPR_PCI_MEM32_WIN_SIZE) != 0); 2940357d1e3bSDavid Gibson QEMU_BUILD_BUG_ON((SPAPR_PCI_MEM32_WIN_SIZE % SPAPR_PCI_IO_WIN_SIZE) != 0); 2941357d1e3bSDavid Gibson /* Sanity check bounds */ 294225e6a118SMichael S. Tsirkin QEMU_BUILD_BUG_ON((SPAPR_MAX_PHBS * SPAPR_PCI_IO_WIN_SIZE) > 294325e6a118SMichael S. Tsirkin SPAPR_PCI_MEM32_WIN_SIZE); 294425e6a118SMichael S. Tsirkin QEMU_BUILD_BUG_ON((SPAPR_MAX_PHBS * SPAPR_PCI_MEM32_WIN_SIZE) > 294525e6a118SMichael S. Tsirkin SPAPR_PCI_MEM64_WIN_SIZE); 29462efff1c0SDavid Gibson 294725e6a118SMichael S. Tsirkin if (index >= SPAPR_MAX_PHBS) { 294825e6a118SMichael S. Tsirkin error_setg(errp, "\"index\" for PAPR PHB is too large (max %llu)", 294925e6a118SMichael S. Tsirkin SPAPR_MAX_PHBS - 1); 29506737d9adSDavid Gibson return; 29516737d9adSDavid Gibson } 29526737d9adSDavid Gibson 29536737d9adSDavid Gibson *buid = base_buid + index; 29546737d9adSDavid Gibson for (i = 0; i < n_dma; ++i) { 29556737d9adSDavid Gibson liobns[i] = SPAPR_PCI_LIOBN(index, i); 29566737d9adSDavid Gibson } 29576737d9adSDavid Gibson 2958357d1e3bSDavid Gibson *pio = SPAPR_PCI_BASE + index * SPAPR_PCI_IO_WIN_SIZE; 2959357d1e3bSDavid Gibson *mmio32 = SPAPR_PCI_BASE + (index + 1) * SPAPR_PCI_MEM32_WIN_SIZE; 2960357d1e3bSDavid Gibson *mmio64 = SPAPR_PCI_BASE + (index + 1) * SPAPR_PCI_MEM64_WIN_SIZE; 29616737d9adSDavid Gibson } 29626737d9adSDavid Gibson 29637844e12bSCédric Le Goater static ICSState *spapr_ics_get(XICSFabric *dev, int irq) 29647844e12bSCédric Le Goater { 29657844e12bSCédric Le Goater sPAPRMachineState *spapr = SPAPR_MACHINE(dev); 29667844e12bSCédric Le Goater 29677844e12bSCédric Le Goater return ics_valid_irq(spapr->ics, irq) ? spapr->ics : NULL; 29687844e12bSCédric Le Goater } 29697844e12bSCédric Le Goater 29707844e12bSCédric Le Goater static void spapr_ics_resend(XICSFabric *dev) 29717844e12bSCédric Le Goater { 29727844e12bSCédric Le Goater sPAPRMachineState *spapr = SPAPR_MACHINE(dev); 29737844e12bSCédric Le Goater 29747844e12bSCédric Le Goater ics_resend(spapr->ics); 29757844e12bSCédric Le Goater } 29767844e12bSCédric Le Goater 2977b2fc59aaSCédric Le Goater static ICPState *spapr_icp_get(XICSFabric *xi, int server) 2978b2fc59aaSCédric Le Goater { 2979b2fc59aaSCédric Le Goater sPAPRMachineState *spapr = SPAPR_MACHINE(xi); 2980b2fc59aaSCédric Le Goater 2981852ad27eSCédric Le Goater return (server < spapr->nr_servers) ? &spapr->icps[server] : NULL; 2982b2fc59aaSCédric Le Goater } 2983b2fc59aaSCédric Le Goater 2984b2fc59aaSCédric Le Goater static void spapr_icp_resend(XICSFabric *xi) 2985b2fc59aaSCédric Le Goater { 2986b2fc59aaSCédric Le Goater sPAPRMachineState *spapr = SPAPR_MACHINE(xi); 2987b2fc59aaSCédric Le Goater int i; 2988b2fc59aaSCédric Le Goater 2989852ad27eSCédric Le Goater for (i = 0; i < spapr->nr_servers; i++) { 2990852ad27eSCédric Le Goater icp_resend(&spapr->icps[i]); 2991b2fc59aaSCédric Le Goater } 2992b2fc59aaSCédric Le Goater } 2993b2fc59aaSCédric Le Goater 299429ee3247SAlexey Kardashevskiy static void spapr_machine_class_init(ObjectClass *oc, void *data) 299553018216SPaolo Bonzini { 299629ee3247SAlexey Kardashevskiy MachineClass *mc = MACHINE_CLASS(oc); 2997224245bfSDavid Gibson sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(oc); 299871461b0fSAlexey Kardashevskiy FWPathProviderClass *fwc = FW_PATH_PROVIDER_CLASS(oc); 299934316482SAlexey Kardashevskiy NMIClass *nc = NMI_CLASS(oc); 3000c20d332aSBharata B Rao HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(oc); 30011d1be34dSDavid Gibson PPCVirtualHypervisorClass *vhc = PPC_VIRTUAL_HYPERVISOR_CLASS(oc); 30027844e12bSCédric Le Goater XICSFabricClass *xic = XICS_FABRIC_CLASS(oc); 300329ee3247SAlexey Kardashevskiy 30040eb9054cSDavid Gibson mc->desc = "pSeries Logical Partition (PAPR compliant)"; 3005fc9f38c3SDavid Gibson 3006fc9f38c3SDavid Gibson /* 3007fc9f38c3SDavid Gibson * We set up the default / latest behaviour here. The class_init 3008fc9f38c3SDavid Gibson * functions for the specific versioned machine types can override 3009fc9f38c3SDavid Gibson * these details for backwards compatibility 3010fc9f38c3SDavid Gibson */ 3011958db90cSMarcel Apfelbaum mc->init = ppc_spapr_init; 3012958db90cSMarcel Apfelbaum mc->reset = ppc_spapr_reset; 3013958db90cSMarcel Apfelbaum mc->block_default_type = IF_SCSI; 30146244bb7eSGreg Kurz mc->max_cpus = 1024; 3015958db90cSMarcel Apfelbaum mc->no_parallel = 1; 30165b2128d2SAlexander Graf mc->default_boot_order = ""; 3017a34944feSNikunj A Dadhania mc->default_ram_size = 512 * M_BYTE; 3018958db90cSMarcel Apfelbaum mc->kvm_type = spapr_kvm_type; 30199e3f9733SAlexander Graf mc->has_dynamic_sysbus = true; 3020e4024630SLaurent Vivier mc->pci_allow_0_address = true; 30217ebaf795SBharata B Rao mc->get_hotplug_handler = spapr_get_hotplug_handler; 302294a94e4cSBharata B Rao hc->pre_plug = spapr_machine_device_pre_plug; 3023c20d332aSBharata B Rao hc->plug = spapr_machine_device_plug; 3024c20d332aSBharata B Rao hc->unplug = spapr_machine_device_unplug; 302520bb648dSDavid Gibson mc->cpu_index_to_socket_id = spapr_cpu_index_to_socket_id; 3026535455fdSIgor Mammedov mc->possible_cpu_arch_ids = spapr_possible_cpu_arch_ids; 3027cf632463SBharata B Rao hc->unplug_request = spapr_machine_device_unplug_request; 302800b4fbe2SMarcel Apfelbaum 3029fc9f38c3SDavid Gibson smc->dr_lmb_enabled = true; 30303daa4a9fSThomas Huth smc->tcg_default_cpu = "POWER8"; 3031c5514d0eSIgor Mammedov mc->has_hotpluggable_cpus = true; 303271461b0fSAlexey Kardashevskiy fwc->get_dev_path = spapr_get_fw_dev_path; 303334316482SAlexey Kardashevskiy nc->nmi_monitor_handler = spapr_nmi; 30346737d9adSDavid Gibson smc->phb_placement = spapr_phb_placement; 30351d1be34dSDavid Gibson vhc->hypercall = emulate_spapr_hypercall; 3036e57ca75cSDavid Gibson vhc->hpt_mask = spapr_hpt_mask; 3037e57ca75cSDavid Gibson vhc->map_hptes = spapr_map_hptes; 3038e57ca75cSDavid Gibson vhc->unmap_hptes = spapr_unmap_hptes; 3039e57ca75cSDavid Gibson vhc->store_hpte = spapr_store_hpte; 30407844e12bSCédric Le Goater xic->ics_get = spapr_ics_get; 30417844e12bSCédric Le Goater xic->ics_resend = spapr_ics_resend; 3042b2fc59aaSCédric Le Goater xic->icp_get = spapr_icp_get; 3043b2fc59aaSCédric Le Goater xic->icp_resend = spapr_icp_resend; 304453018216SPaolo Bonzini } 304553018216SPaolo Bonzini 304629ee3247SAlexey Kardashevskiy static const TypeInfo spapr_machine_info = { 304729ee3247SAlexey Kardashevskiy .name = TYPE_SPAPR_MACHINE, 304829ee3247SAlexey Kardashevskiy .parent = TYPE_MACHINE, 30494aee7362SDavid Gibson .abstract = true, 30506ca1502eSAlexey Kardashevskiy .instance_size = sizeof(sPAPRMachineState), 305123825581SEduardo Habkost .instance_init = spapr_machine_initfn, 305287bbdd9cSDavid Gibson .instance_finalize = spapr_machine_finalizefn, 3053183930c0SDavid Gibson .class_size = sizeof(sPAPRMachineClass), 305429ee3247SAlexey Kardashevskiy .class_init = spapr_machine_class_init, 305571461b0fSAlexey Kardashevskiy .interfaces = (InterfaceInfo[]) { 305671461b0fSAlexey Kardashevskiy { TYPE_FW_PATH_PROVIDER }, 305734316482SAlexey Kardashevskiy { TYPE_NMI }, 3058c20d332aSBharata B Rao { TYPE_HOTPLUG_HANDLER }, 30591d1be34dSDavid Gibson { TYPE_PPC_VIRTUAL_HYPERVISOR }, 30607844e12bSCédric Le Goater { TYPE_XICS_FABRIC }, 306171461b0fSAlexey Kardashevskiy { } 306271461b0fSAlexey Kardashevskiy }, 306329ee3247SAlexey Kardashevskiy }; 306429ee3247SAlexey Kardashevskiy 3065fccbc785SDavid Gibson #define DEFINE_SPAPR_MACHINE(suffix, verstr, latest) \ 30665013c547SDavid Gibson static void spapr_machine_##suffix##_class_init(ObjectClass *oc, \ 30675013c547SDavid Gibson void *data) \ 30685013c547SDavid Gibson { \ 30695013c547SDavid Gibson MachineClass *mc = MACHINE_CLASS(oc); \ 30705013c547SDavid Gibson spapr_machine_##suffix##_class_options(mc); \ 3071fccbc785SDavid Gibson if (latest) { \ 3072fccbc785SDavid Gibson mc->alias = "pseries"; \ 3073fccbc785SDavid Gibson mc->is_default = 1; \ 3074fccbc785SDavid Gibson } \ 30755013c547SDavid Gibson } \ 30765013c547SDavid Gibson static void spapr_machine_##suffix##_instance_init(Object *obj) \ 30775013c547SDavid Gibson { \ 30785013c547SDavid Gibson MachineState *machine = MACHINE(obj); \ 30795013c547SDavid Gibson spapr_machine_##suffix##_instance_options(machine); \ 30805013c547SDavid Gibson } \ 30815013c547SDavid Gibson static const TypeInfo spapr_machine_##suffix##_info = { \ 30825013c547SDavid Gibson .name = MACHINE_TYPE_NAME("pseries-" verstr), \ 30835013c547SDavid Gibson .parent = TYPE_SPAPR_MACHINE, \ 30845013c547SDavid Gibson .class_init = spapr_machine_##suffix##_class_init, \ 30855013c547SDavid Gibson .instance_init = spapr_machine_##suffix##_instance_init, \ 30865013c547SDavid Gibson }; \ 30875013c547SDavid Gibson static void spapr_machine_register_##suffix(void) \ 30885013c547SDavid Gibson { \ 30895013c547SDavid Gibson type_register(&spapr_machine_##suffix##_info); \ 30905013c547SDavid Gibson } \ 30910e6aac87SEduardo Habkost type_init(spapr_machine_register_##suffix) 30925013c547SDavid Gibson 30931c5f29bbSDavid Gibson /* 3094fa325e6cSDavid Gibson * pseries-2.9 3095db800b21SDavid Gibson */ 3096fa325e6cSDavid Gibson static void spapr_machine_2_9_instance_options(MachineState *machine) 3097db800b21SDavid Gibson { 3098db800b21SDavid Gibson } 3099db800b21SDavid Gibson 3100fa325e6cSDavid Gibson static void spapr_machine_2_9_class_options(MachineClass *mc) 3101db800b21SDavid Gibson { 3102db800b21SDavid Gibson /* Defaults for the latest behaviour inherited from the base class */ 3103db800b21SDavid Gibson } 3104db800b21SDavid Gibson 3105fa325e6cSDavid Gibson DEFINE_SPAPR_MACHINE(2_9, "2.9", true); 3106fa325e6cSDavid Gibson 3107fa325e6cSDavid Gibson /* 3108fa325e6cSDavid Gibson * pseries-2.8 3109fa325e6cSDavid Gibson */ 3110fa325e6cSDavid Gibson #define SPAPR_COMPAT_2_8 \ 3111fa325e6cSDavid Gibson HW_COMPAT_2_8 3112fa325e6cSDavid Gibson 3113fa325e6cSDavid Gibson static void spapr_machine_2_8_instance_options(MachineState *machine) 3114fa325e6cSDavid Gibson { 3115fa325e6cSDavid Gibson spapr_machine_2_9_instance_options(machine); 3116fa325e6cSDavid Gibson } 3117fa325e6cSDavid Gibson 3118fa325e6cSDavid Gibson static void spapr_machine_2_8_class_options(MachineClass *mc) 3119fa325e6cSDavid Gibson { 3120fa325e6cSDavid Gibson spapr_machine_2_9_class_options(mc); 3121fa325e6cSDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_8); 3122fa325e6cSDavid Gibson } 3123fa325e6cSDavid Gibson 3124fa325e6cSDavid Gibson DEFINE_SPAPR_MACHINE(2_8, "2.8", false); 3125db800b21SDavid Gibson 3126db800b21SDavid Gibson /* 31271ea1eefcSBharata B Rao * pseries-2.7 31281ea1eefcSBharata B Rao */ 3129db800b21SDavid Gibson #define SPAPR_COMPAT_2_7 \ 3130db800b21SDavid Gibson HW_COMPAT_2_7 \ 3131357d1e3bSDavid Gibson { \ 3132357d1e3bSDavid Gibson .driver = TYPE_SPAPR_PCI_HOST_BRIDGE, \ 3133357d1e3bSDavid Gibson .property = "mem_win_size", \ 3134357d1e3bSDavid Gibson .value = stringify(SPAPR_PCI_2_7_MMIO_WIN_SIZE),\ 3135357d1e3bSDavid Gibson }, \ 3136357d1e3bSDavid Gibson { \ 3137357d1e3bSDavid Gibson .driver = TYPE_SPAPR_PCI_HOST_BRIDGE, \ 3138357d1e3bSDavid Gibson .property = "mem64_win_size", \ 3139357d1e3bSDavid Gibson .value = "0", \ 3140146c11f1SDavid Gibson }, \ 3141146c11f1SDavid Gibson { \ 3142146c11f1SDavid Gibson .driver = TYPE_POWERPC_CPU, \ 3143146c11f1SDavid Gibson .property = "pre-2.8-migration", \ 3144146c11f1SDavid Gibson .value = "on", \ 31455c4537bdSDavid Gibson }, \ 31465c4537bdSDavid Gibson { \ 31475c4537bdSDavid Gibson .driver = TYPE_SPAPR_PCI_HOST_BRIDGE, \ 31485c4537bdSDavid Gibson .property = "pre-2.8-migration", \ 31495c4537bdSDavid Gibson .value = "on", \ 3150357d1e3bSDavid Gibson }, 3151357d1e3bSDavid Gibson 3152357d1e3bSDavid Gibson static void phb_placement_2_7(sPAPRMachineState *spapr, uint32_t index, 3153357d1e3bSDavid Gibson uint64_t *buid, hwaddr *pio, 3154357d1e3bSDavid Gibson hwaddr *mmio32, hwaddr *mmio64, 3155357d1e3bSDavid Gibson unsigned n_dma, uint32_t *liobns, Error **errp) 3156357d1e3bSDavid Gibson { 3157357d1e3bSDavid Gibson /* Legacy PHB placement for pseries-2.7 and earlier machine types */ 3158357d1e3bSDavid Gibson const uint64_t base_buid = 0x800000020000000ULL; 3159357d1e3bSDavid Gibson const hwaddr phb_spacing = 0x1000000000ULL; /* 64 GiB */ 3160357d1e3bSDavid Gibson const hwaddr mmio_offset = 0xa0000000; /* 2 GiB + 512 MiB */ 3161357d1e3bSDavid Gibson const hwaddr pio_offset = 0x80000000; /* 2 GiB */ 3162357d1e3bSDavid Gibson const uint32_t max_index = 255; 3163357d1e3bSDavid Gibson const hwaddr phb0_alignment = 0x10000000000ULL; /* 1 TiB */ 3164357d1e3bSDavid Gibson 3165357d1e3bSDavid Gibson uint64_t ram_top = MACHINE(spapr)->ram_size; 3166357d1e3bSDavid Gibson hwaddr phb0_base, phb_base; 3167357d1e3bSDavid Gibson int i; 3168357d1e3bSDavid Gibson 3169357d1e3bSDavid Gibson /* Do we have hotpluggable memory? */ 3170357d1e3bSDavid Gibson if (MACHINE(spapr)->maxram_size > ram_top) { 3171357d1e3bSDavid Gibson /* Can't just use maxram_size, because there may be an 3172357d1e3bSDavid Gibson * alignment gap between normal and hotpluggable memory 3173357d1e3bSDavid Gibson * regions */ 3174357d1e3bSDavid Gibson ram_top = spapr->hotplug_memory.base + 3175357d1e3bSDavid Gibson memory_region_size(&spapr->hotplug_memory.mr); 3176357d1e3bSDavid Gibson } 3177357d1e3bSDavid Gibson 3178357d1e3bSDavid Gibson phb0_base = QEMU_ALIGN_UP(ram_top, phb0_alignment); 3179357d1e3bSDavid Gibson 3180357d1e3bSDavid Gibson if (index > max_index) { 3181357d1e3bSDavid Gibson error_setg(errp, "\"index\" for PAPR PHB is too large (max %u)", 3182357d1e3bSDavid Gibson max_index); 3183357d1e3bSDavid Gibson return; 3184357d1e3bSDavid Gibson } 3185357d1e3bSDavid Gibson 3186357d1e3bSDavid Gibson *buid = base_buid + index; 3187357d1e3bSDavid Gibson for (i = 0; i < n_dma; ++i) { 3188357d1e3bSDavid Gibson liobns[i] = SPAPR_PCI_LIOBN(index, i); 3189357d1e3bSDavid Gibson } 3190357d1e3bSDavid Gibson 3191357d1e3bSDavid Gibson phb_base = phb0_base + index * phb_spacing; 3192357d1e3bSDavid Gibson *pio = phb_base + pio_offset; 3193357d1e3bSDavid Gibson *mmio32 = phb_base + mmio_offset; 3194357d1e3bSDavid Gibson /* 3195357d1e3bSDavid Gibson * We don't set the 64-bit MMIO window, relying on the PHB's 3196357d1e3bSDavid Gibson * fallback behaviour of automatically splitting a large "32-bit" 3197357d1e3bSDavid Gibson * window into contiguous 32-bit and 64-bit windows 3198357d1e3bSDavid Gibson */ 3199357d1e3bSDavid Gibson } 3200db800b21SDavid Gibson 32011ea1eefcSBharata B Rao static void spapr_machine_2_7_instance_options(MachineState *machine) 32021ea1eefcSBharata B Rao { 3203f6229214SMichael Roth sPAPRMachineState *spapr = SPAPR_MACHINE(machine); 3204f6229214SMichael Roth 3205672de881SMichael Roth spapr_machine_2_8_instance_options(machine); 3206f6229214SMichael Roth spapr->use_hotplug_event_source = false; 32071ea1eefcSBharata B Rao } 32081ea1eefcSBharata B Rao 32091ea1eefcSBharata B Rao static void spapr_machine_2_7_class_options(MachineClass *mc) 32101ea1eefcSBharata B Rao { 32113daa4a9fSThomas Huth sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); 32123daa4a9fSThomas Huth 3213db800b21SDavid Gibson spapr_machine_2_8_class_options(mc); 32143daa4a9fSThomas Huth smc->tcg_default_cpu = "POWER7"; 3215db800b21SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_7); 3216357d1e3bSDavid Gibson smc->phb_placement = phb_placement_2_7; 32171ea1eefcSBharata B Rao } 32181ea1eefcSBharata B Rao 3219db800b21SDavid Gibson DEFINE_SPAPR_MACHINE(2_7, "2.7", false); 32201ea1eefcSBharata B Rao 32211ea1eefcSBharata B Rao /* 32224b23699cSDavid Gibson * pseries-2.6 32234b23699cSDavid Gibson */ 32241ea1eefcSBharata B Rao #define SPAPR_COMPAT_2_6 \ 3225ae4de14cSAlexey Kardashevskiy HW_COMPAT_2_6 \ 3226ae4de14cSAlexey Kardashevskiy { \ 3227ae4de14cSAlexey Kardashevskiy .driver = TYPE_SPAPR_PCI_HOST_BRIDGE,\ 3228ae4de14cSAlexey Kardashevskiy .property = "ddw",\ 3229ae4de14cSAlexey Kardashevskiy .value = stringify(off),\ 3230ae4de14cSAlexey Kardashevskiy }, 32311ea1eefcSBharata B Rao 32324b23699cSDavid Gibson static void spapr_machine_2_6_instance_options(MachineState *machine) 32334b23699cSDavid Gibson { 3234672de881SMichael Roth spapr_machine_2_7_instance_options(machine); 32354b23699cSDavid Gibson } 32364b23699cSDavid Gibson 32374b23699cSDavid Gibson static void spapr_machine_2_6_class_options(MachineClass *mc) 32384b23699cSDavid Gibson { 32391ea1eefcSBharata B Rao spapr_machine_2_7_class_options(mc); 3240c5514d0eSIgor Mammedov mc->has_hotpluggable_cpus = false; 32411ea1eefcSBharata B Rao SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_6); 32424b23699cSDavid Gibson } 32434b23699cSDavid Gibson 32441ea1eefcSBharata B Rao DEFINE_SPAPR_MACHINE(2_6, "2.6", false); 32454b23699cSDavid Gibson 32464b23699cSDavid Gibson /* 32471c5f29bbSDavid Gibson * pseries-2.5 32481c5f29bbSDavid Gibson */ 32494b23699cSDavid Gibson #define SPAPR_COMPAT_2_5 \ 325057c522f4SThomas Huth HW_COMPAT_2_5 \ 325157c522f4SThomas Huth { \ 325257c522f4SThomas Huth .driver = "spapr-vlan", \ 325357c522f4SThomas Huth .property = "use-rx-buffer-pools", \ 325457c522f4SThomas Huth .value = "off", \ 325557c522f4SThomas Huth }, 32564b23699cSDavid Gibson 32575013c547SDavid Gibson static void spapr_machine_2_5_instance_options(MachineState *machine) 32581c5f29bbSDavid Gibson { 3259672de881SMichael Roth spapr_machine_2_6_instance_options(machine); 32605013c547SDavid Gibson } 32615013c547SDavid Gibson 32625013c547SDavid Gibson static void spapr_machine_2_5_class_options(MachineClass *mc) 32635013c547SDavid Gibson { 326457040d45SThomas Huth sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); 326557040d45SThomas Huth 32664b23699cSDavid Gibson spapr_machine_2_6_class_options(mc); 326757040d45SThomas Huth smc->use_ohci_by_default = true; 32684b23699cSDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_5); 32691c5f29bbSDavid Gibson } 32701c5f29bbSDavid Gibson 32714b23699cSDavid Gibson DEFINE_SPAPR_MACHINE(2_5, "2.5", false); 32721c5f29bbSDavid Gibson 32731c5f29bbSDavid Gibson /* 32741c5f29bbSDavid Gibson * pseries-2.4 32751c5f29bbSDavid Gibson */ 327680fd50f9SCornelia Huck #define SPAPR_COMPAT_2_4 \ 327780fd50f9SCornelia Huck HW_COMPAT_2_4 327880fd50f9SCornelia Huck 32795013c547SDavid Gibson static void spapr_machine_2_4_instance_options(MachineState *machine) 32801c5f29bbSDavid Gibson { 32815013c547SDavid Gibson spapr_machine_2_5_instance_options(machine); 32825013c547SDavid Gibson } 32831c5f29bbSDavid Gibson 32845013c547SDavid Gibson static void spapr_machine_2_4_class_options(MachineClass *mc) 32855013c547SDavid Gibson { 3286fc9f38c3SDavid Gibson sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); 3287fc9f38c3SDavid Gibson 3288fc9f38c3SDavid Gibson spapr_machine_2_5_class_options(mc); 3289fc9f38c3SDavid Gibson smc->dr_lmb_enabled = false; 3290f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_4); 32911c5f29bbSDavid Gibson } 32921c5f29bbSDavid Gibson 3293fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_4, "2.4", false); 32941c5f29bbSDavid Gibson 32951c5f29bbSDavid Gibson /* 32961c5f29bbSDavid Gibson * pseries-2.3 32971c5f29bbSDavid Gibson */ 329838ff32c6SEduardo Habkost #define SPAPR_COMPAT_2_3 \ 32997619c7b0SMichael Roth HW_COMPAT_2_3 \ 33007619c7b0SMichael Roth {\ 33017619c7b0SMichael Roth .driver = "spapr-pci-host-bridge",\ 33027619c7b0SMichael Roth .property = "dynamic-reconfiguration",\ 33037619c7b0SMichael Roth .value = "off",\ 33047619c7b0SMichael Roth }, 330538ff32c6SEduardo Habkost 33065013c547SDavid Gibson static void spapr_machine_2_3_instance_options(MachineState *machine) 33071c5f29bbSDavid Gibson { 33085013c547SDavid Gibson spapr_machine_2_4_instance_options(machine); 33091c5f29bbSDavid Gibson savevm_skip_section_footers(); 33101c5f29bbSDavid Gibson global_state_set_optional(); 331109b5e30dSGreg Kurz savevm_skip_configuration(); 33121c5f29bbSDavid Gibson } 33131c5f29bbSDavid Gibson 33145013c547SDavid Gibson static void spapr_machine_2_3_class_options(MachineClass *mc) 33151c5f29bbSDavid Gibson { 3316fc9f38c3SDavid Gibson spapr_machine_2_4_class_options(mc); 3317f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_3); 33181c5f29bbSDavid Gibson } 3319fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_3, "2.3", false); 33201c5f29bbSDavid Gibson 33211c5f29bbSDavid Gibson /* 33221c5f29bbSDavid Gibson * pseries-2.2 33231c5f29bbSDavid Gibson */ 33241c5f29bbSDavid Gibson 3325b194df47SAlexey Kardashevskiy #define SPAPR_COMPAT_2_2 \ 33264dfd8eaaSEduardo Habkost HW_COMPAT_2_2 \ 3327b194df47SAlexey Kardashevskiy {\ 3328b194df47SAlexey Kardashevskiy .driver = TYPE_SPAPR_PCI_HOST_BRIDGE,\ 3329b194df47SAlexey Kardashevskiy .property = "mem_win_size",\ 3330b194df47SAlexey Kardashevskiy .value = "0x20000000",\ 3331dd754bafSEduardo Habkost }, 3332b194df47SAlexey Kardashevskiy 33335013c547SDavid Gibson static void spapr_machine_2_2_instance_options(MachineState *machine) 3334b0e966d0SJason Wang { 33355013c547SDavid Gibson spapr_machine_2_3_instance_options(machine); 3336cba0e779SGreg Kurz machine->suppress_vmdesc = true; 3337b0e966d0SJason Wang } 3338b0e966d0SJason Wang 33395013c547SDavid Gibson static void spapr_machine_2_2_class_options(MachineClass *mc) 3340b0e966d0SJason Wang { 3341fc9f38c3SDavid Gibson spapr_machine_2_3_class_options(mc); 3342f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_2); 33431c5f29bbSDavid Gibson } 3344fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_2, "2.2", false); 33451c5f29bbSDavid Gibson 33461c5f29bbSDavid Gibson /* 33471c5f29bbSDavid Gibson * pseries-2.1 33481c5f29bbSDavid Gibson */ 33491c5f29bbSDavid Gibson #define SPAPR_COMPAT_2_1 \ 33501c5f29bbSDavid Gibson HW_COMPAT_2_1 33511c5f29bbSDavid Gibson 33525013c547SDavid Gibson static void spapr_machine_2_1_instance_options(MachineState *machine) 33531c5f29bbSDavid Gibson { 33545013c547SDavid Gibson spapr_machine_2_2_instance_options(machine); 33551c5f29bbSDavid Gibson } 33561c5f29bbSDavid Gibson 33575013c547SDavid Gibson static void spapr_machine_2_1_class_options(MachineClass *mc) 3358b0e966d0SJason Wang { 3359fc9f38c3SDavid Gibson spapr_machine_2_2_class_options(mc); 3360f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_1); 33616026db45SAlexey Kardashevskiy } 3362fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_1, "2.1", false); 33636026db45SAlexey Kardashevskiy 336429ee3247SAlexey Kardashevskiy static void spapr_machine_register_types(void) 336529ee3247SAlexey Kardashevskiy { 336629ee3247SAlexey Kardashevskiy type_register_static(&spapr_machine_info); 336729ee3247SAlexey Kardashevskiy } 336829ee3247SAlexey Kardashevskiy 336929ee3247SAlexey Kardashevskiy type_init(spapr_machine_register_types) 3370