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*4e4169f7SCédric Le Goater static XICSState *try_create_xics(const char *type, const char *type_ics, 99*4e4169f7SCédric Le Goater int nr_servers, int nr_irqs, Error **errp) 100c04d6cfaSAnthony Liguori { 101*4e4169f7SCédric Le Goater Error *err = NULL, *local_err = NULL; 102*4e4169f7SCédric Le Goater XICSState *xics; 103*4e4169f7SCédric Le Goater ICSState *ics = NULL; 104c04d6cfaSAnthony Liguori 105*4e4169f7SCédric Le Goater xics = XICS_COMMON(object_new(type)); 106*4e4169f7SCédric Le Goater qdev_set_parent_bus(DEVICE(xics), sysbus_get_default()); 107*4e4169f7SCédric Le Goater object_property_set_int(OBJECT(xics), nr_servers, "nr_servers", &err); 108*4e4169f7SCédric Le Goater object_property_set_bool(OBJECT(xics), true, "realized", &local_err); 109*4e4169f7SCédric Le Goater error_propagate(&err, local_err); 11034f2af3dSMarkus Armbruster if (err) { 111*4e4169f7SCédric Le Goater goto error; 112c04d6cfaSAnthony Liguori } 113*4e4169f7SCédric Le Goater 114*4e4169f7SCédric Le Goater ics = ICS_SIMPLE(object_new(type_ics)); 115*4e4169f7SCédric Le Goater object_property_add_child(OBJECT(xics), "ics", OBJECT(ics), NULL); 116*4e4169f7SCédric Le Goater object_property_set_int(OBJECT(ics), nr_irqs, "nr-irqs", &err); 117*4e4169f7SCédric Le Goater object_property_add_const_link(OBJECT(ics), "xics", OBJECT(xics), NULL); 118*4e4169f7SCédric Le Goater object_property_set_bool(OBJECT(ics), true, "realized", &local_err); 119*4e4169f7SCédric Le Goater error_propagate(&err, local_err); 120*4e4169f7SCédric Le Goater if (err) { 121*4e4169f7SCédric Le Goater goto error; 122*4e4169f7SCédric Le Goater } 123*4e4169f7SCédric Le Goater QLIST_INSERT_HEAD(&xics->ics, ics, list); 124*4e4169f7SCédric Le Goater 125*4e4169f7SCédric Le Goater return xics; 126*4e4169f7SCédric Le Goater 127*4e4169f7SCédric Le Goater error: 128*4e4169f7SCédric Le Goater error_propagate(errp, err); 129*4e4169f7SCédric Le Goater if (ics) { 130*4e4169f7SCédric Le Goater object_unparent(OBJECT(ics)); 131*4e4169f7SCédric Le Goater } 132*4e4169f7SCédric Le Goater object_unparent(OBJECT(xics)); 133*4e4169f7SCédric Le Goater return NULL; 134c04d6cfaSAnthony Liguori } 135c04d6cfaSAnthony Liguori 136446f16a6SMarcel Apfelbaum static XICSState *xics_system_init(MachineState *machine, 1371e49182dSDavid Gibson int nr_servers, int nr_irqs, Error **errp) 138c04d6cfaSAnthony Liguori { 13927f24582SBenjamin Herrenschmidt XICSState *xics = NULL; 140c04d6cfaSAnthony Liguori 14111ad93f6SDavid Gibson if (kvm_enabled()) { 14234f2af3dSMarkus Armbruster Error *err = NULL; 14334f2af3dSMarkus Armbruster 144446f16a6SMarcel Apfelbaum if (machine_kernel_irqchip_allowed(machine)) { 145*4e4169f7SCédric Le Goater xics = try_create_xics(TYPE_XICS_SPAPR_KVM, TYPE_ICS_KVM, 146*4e4169f7SCédric Le Goater nr_servers, nr_irqs, &err); 14711ad93f6SDavid Gibson } 14827f24582SBenjamin Herrenschmidt if (machine_kernel_irqchip_required(machine) && !xics) { 149b83baa60SMarkus Armbruster error_reportf_err(err, 150b83baa60SMarkus Armbruster "kernel_irqchip requested but unavailable: "); 151b83baa60SMarkus Armbruster } else { 152903a41d3SStefano Dong (董兴水) error_free(err); 15311ad93f6SDavid Gibson } 154b83baa60SMarkus Armbruster } 15511ad93f6SDavid Gibson 15627f24582SBenjamin Herrenschmidt if (!xics) { 157*4e4169f7SCédric Le Goater xics = try_create_xics(TYPE_XICS_SPAPR, TYPE_ICS_SIMPLE, nr_servers, 158*4e4169f7SCédric Le Goater nr_irqs, errp); 159c04d6cfaSAnthony Liguori } 160c04d6cfaSAnthony Liguori 16127f24582SBenjamin Herrenschmidt return xics; 162c04d6cfaSAnthony Liguori } 163c04d6cfaSAnthony Liguori 164833d4668SAlexey Kardashevskiy static int spapr_fixup_cpu_smt_dt(void *fdt, int offset, PowerPCCPU *cpu, 165833d4668SAlexey Kardashevskiy int smt_threads) 166833d4668SAlexey Kardashevskiy { 167833d4668SAlexey Kardashevskiy int i, ret = 0; 168833d4668SAlexey Kardashevskiy uint32_t servers_prop[smt_threads]; 169833d4668SAlexey Kardashevskiy uint32_t gservers_prop[smt_threads * 2]; 170833d4668SAlexey Kardashevskiy int index = ppc_get_vcpu_dt_id(cpu); 171833d4668SAlexey Kardashevskiy 172d6e166c0SDavid Gibson if (cpu->compat_pvr) { 173d6e166c0SDavid Gibson ret = fdt_setprop_cell(fdt, offset, "cpu-version", cpu->compat_pvr); 1746d9412eaSAlexey Kardashevskiy if (ret < 0) { 1756d9412eaSAlexey Kardashevskiy return ret; 1766d9412eaSAlexey Kardashevskiy } 1776d9412eaSAlexey Kardashevskiy } 1786d9412eaSAlexey Kardashevskiy 179833d4668SAlexey Kardashevskiy /* Build interrupt servers and gservers properties */ 180833d4668SAlexey Kardashevskiy for (i = 0; i < smt_threads; i++) { 181833d4668SAlexey Kardashevskiy servers_prop[i] = cpu_to_be32(index + i); 182833d4668SAlexey Kardashevskiy /* Hack, direct the group queues back to cpu 0 */ 183833d4668SAlexey Kardashevskiy gservers_prop[i*2] = cpu_to_be32(index + i); 184833d4668SAlexey Kardashevskiy gservers_prop[i*2 + 1] = 0; 185833d4668SAlexey Kardashevskiy } 186833d4668SAlexey Kardashevskiy ret = fdt_setprop(fdt, offset, "ibm,ppc-interrupt-server#s", 187833d4668SAlexey Kardashevskiy servers_prop, sizeof(servers_prop)); 188833d4668SAlexey Kardashevskiy if (ret < 0) { 189833d4668SAlexey Kardashevskiy return ret; 190833d4668SAlexey Kardashevskiy } 191833d4668SAlexey Kardashevskiy ret = fdt_setprop(fdt, offset, "ibm,ppc-interrupt-gserver#s", 192833d4668SAlexey Kardashevskiy gservers_prop, sizeof(gservers_prop)); 193833d4668SAlexey Kardashevskiy 194833d4668SAlexey Kardashevskiy return ret; 195833d4668SAlexey Kardashevskiy } 196833d4668SAlexey Kardashevskiy 1970da6f3feSBharata B Rao static int spapr_fixup_cpu_numa_dt(void *fdt, int offset, CPUState *cs) 1980da6f3feSBharata B Rao { 1990da6f3feSBharata B Rao int ret = 0; 2000da6f3feSBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(cs); 2010da6f3feSBharata B Rao int index = ppc_get_vcpu_dt_id(cpu); 2020da6f3feSBharata B Rao uint32_t associativity[] = {cpu_to_be32(0x5), 2030da6f3feSBharata B Rao cpu_to_be32(0x0), 2040da6f3feSBharata B Rao cpu_to_be32(0x0), 2050da6f3feSBharata B Rao cpu_to_be32(0x0), 2060da6f3feSBharata B Rao cpu_to_be32(cs->numa_node), 2070da6f3feSBharata B Rao cpu_to_be32(index)}; 2080da6f3feSBharata B Rao 2090da6f3feSBharata B Rao /* Advertise NUMA via ibm,associativity */ 2100da6f3feSBharata B Rao if (nb_numa_nodes > 1) { 2110da6f3feSBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,associativity", associativity, 2120da6f3feSBharata B Rao sizeof(associativity)); 2130da6f3feSBharata B Rao } 2140da6f3feSBharata B Rao 2150da6f3feSBharata B Rao return ret; 2160da6f3feSBharata B Rao } 2170da6f3feSBharata B Rao 21828e02042SDavid Gibson static int spapr_fixup_cpu_dt(void *fdt, sPAPRMachineState *spapr) 21953018216SPaolo Bonzini { 22082677ed2SAlexey Kardashevskiy int ret = 0, offset, cpus_offset; 22182677ed2SAlexey Kardashevskiy CPUState *cs; 22253018216SPaolo Bonzini char cpu_model[32]; 22353018216SPaolo Bonzini int smt = kvmppc_smt_threads(); 22453018216SPaolo Bonzini uint32_t pft_size_prop[] = {0, cpu_to_be32(spapr->htab_shift)}; 22553018216SPaolo Bonzini 22682677ed2SAlexey Kardashevskiy CPU_FOREACH(cs) { 22782677ed2SAlexey Kardashevskiy PowerPCCPU *cpu = POWERPC_CPU(cs); 22882677ed2SAlexey Kardashevskiy DeviceClass *dc = DEVICE_GET_CLASS(cs); 22982677ed2SAlexey Kardashevskiy int index = ppc_get_vcpu_dt_id(cpu); 23012dbeb16SDavid Gibson int compat_smt = MIN(smp_threads, ppc_compat_max_threads(cpu)); 23153018216SPaolo Bonzini 2320f20ba62SAlexey Kardashevskiy if ((index % smt) != 0) { 23353018216SPaolo Bonzini continue; 23453018216SPaolo Bonzini } 23553018216SPaolo Bonzini 23682677ed2SAlexey Kardashevskiy snprintf(cpu_model, 32, "%s@%x", dc->fw_name, index); 23753018216SPaolo Bonzini 23882677ed2SAlexey Kardashevskiy cpus_offset = fdt_path_offset(fdt, "/cpus"); 23982677ed2SAlexey Kardashevskiy if (cpus_offset < 0) { 24082677ed2SAlexey Kardashevskiy cpus_offset = fdt_add_subnode(fdt, fdt_path_offset(fdt, "/"), 24182677ed2SAlexey Kardashevskiy "cpus"); 24282677ed2SAlexey Kardashevskiy if (cpus_offset < 0) { 24382677ed2SAlexey Kardashevskiy return cpus_offset; 24482677ed2SAlexey Kardashevskiy } 24582677ed2SAlexey Kardashevskiy } 24682677ed2SAlexey Kardashevskiy offset = fdt_subnode_offset(fdt, cpus_offset, cpu_model); 24782677ed2SAlexey Kardashevskiy if (offset < 0) { 24882677ed2SAlexey Kardashevskiy offset = fdt_add_subnode(fdt, cpus_offset, cpu_model); 24953018216SPaolo Bonzini if (offset < 0) { 25053018216SPaolo Bonzini return offset; 25153018216SPaolo Bonzini } 25282677ed2SAlexey Kardashevskiy } 25353018216SPaolo Bonzini 2540da6f3feSBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,pft-size", 2550da6f3feSBharata B Rao pft_size_prop, sizeof(pft_size_prop)); 25653018216SPaolo Bonzini if (ret < 0) { 25753018216SPaolo Bonzini return ret; 25853018216SPaolo Bonzini } 25953018216SPaolo Bonzini 2600da6f3feSBharata B Rao ret = spapr_fixup_cpu_numa_dt(fdt, offset, cs); 26153018216SPaolo Bonzini if (ret < 0) { 26253018216SPaolo Bonzini return ret; 26353018216SPaolo Bonzini } 264833d4668SAlexey Kardashevskiy 26512dbeb16SDavid Gibson ret = spapr_fixup_cpu_smt_dt(fdt, offset, cpu, compat_smt); 266833d4668SAlexey Kardashevskiy if (ret < 0) { 267833d4668SAlexey Kardashevskiy return ret; 268833d4668SAlexey Kardashevskiy } 26953018216SPaolo Bonzini } 27053018216SPaolo Bonzini return ret; 27153018216SPaolo Bonzini } 27253018216SPaolo Bonzini 273b082d65aSAlexey Kardashevskiy static hwaddr spapr_node0_size(void) 274b082d65aSAlexey Kardashevskiy { 275fb164994SDavid Gibson MachineState *machine = MACHINE(qdev_get_machine()); 276fb164994SDavid Gibson 277b082d65aSAlexey Kardashevskiy if (nb_numa_nodes) { 278b082d65aSAlexey Kardashevskiy int i; 279b082d65aSAlexey Kardashevskiy for (i = 0; i < nb_numa_nodes; ++i) { 280b082d65aSAlexey Kardashevskiy if (numa_info[i].node_mem) { 281fb164994SDavid Gibson return MIN(pow2floor(numa_info[i].node_mem), 282fb164994SDavid Gibson machine->ram_size); 283b082d65aSAlexey Kardashevskiy } 284b082d65aSAlexey Kardashevskiy } 285b082d65aSAlexey Kardashevskiy } 286fb164994SDavid Gibson return machine->ram_size; 287b082d65aSAlexey Kardashevskiy } 288b082d65aSAlexey Kardashevskiy 289a1d59c0fSAlexey Kardashevskiy static void add_str(GString *s, const gchar *s1) 290a1d59c0fSAlexey Kardashevskiy { 291a1d59c0fSAlexey Kardashevskiy g_string_append_len(s, s1, strlen(s1) + 1); 292a1d59c0fSAlexey Kardashevskiy } 29353018216SPaolo Bonzini 29403d196b7SBharata B Rao static int spapr_populate_memory_node(void *fdt, int nodeid, hwaddr start, 29526a8c353SAlexey Kardashevskiy hwaddr size) 29626a8c353SAlexey Kardashevskiy { 29726a8c353SAlexey Kardashevskiy uint32_t associativity[] = { 29826a8c353SAlexey Kardashevskiy cpu_to_be32(0x4), /* length */ 29926a8c353SAlexey Kardashevskiy cpu_to_be32(0x0), cpu_to_be32(0x0), 300c3b4f589SAlexey Kardashevskiy cpu_to_be32(0x0), cpu_to_be32(nodeid) 30126a8c353SAlexey Kardashevskiy }; 30226a8c353SAlexey Kardashevskiy char mem_name[32]; 30326a8c353SAlexey Kardashevskiy uint64_t mem_reg_property[2]; 30426a8c353SAlexey Kardashevskiy int off; 30526a8c353SAlexey Kardashevskiy 30626a8c353SAlexey Kardashevskiy mem_reg_property[0] = cpu_to_be64(start); 30726a8c353SAlexey Kardashevskiy mem_reg_property[1] = cpu_to_be64(size); 30826a8c353SAlexey Kardashevskiy 30926a8c353SAlexey Kardashevskiy sprintf(mem_name, "memory@" TARGET_FMT_lx, start); 31026a8c353SAlexey Kardashevskiy off = fdt_add_subnode(fdt, 0, mem_name); 31126a8c353SAlexey Kardashevskiy _FDT(off); 31226a8c353SAlexey Kardashevskiy _FDT((fdt_setprop_string(fdt, off, "device_type", "memory"))); 31326a8c353SAlexey Kardashevskiy _FDT((fdt_setprop(fdt, off, "reg", mem_reg_property, 31426a8c353SAlexey Kardashevskiy sizeof(mem_reg_property)))); 31526a8c353SAlexey Kardashevskiy _FDT((fdt_setprop(fdt, off, "ibm,associativity", associativity, 31626a8c353SAlexey Kardashevskiy sizeof(associativity)))); 31703d196b7SBharata B Rao return off; 31826a8c353SAlexey Kardashevskiy } 31926a8c353SAlexey Kardashevskiy 32028e02042SDavid Gibson static int spapr_populate_memory(sPAPRMachineState *spapr, void *fdt) 32153018216SPaolo Bonzini { 322fb164994SDavid Gibson MachineState *machine = MACHINE(spapr); 3237db8a127SAlexey Kardashevskiy hwaddr mem_start, node_size; 3247db8a127SAlexey Kardashevskiy int i, nb_nodes = nb_numa_nodes; 3257db8a127SAlexey Kardashevskiy NodeInfo *nodes = numa_info; 3267db8a127SAlexey Kardashevskiy NodeInfo ramnode; 32753018216SPaolo Bonzini 3287db8a127SAlexey Kardashevskiy /* No NUMA nodes, assume there is just one node with whole RAM */ 3297db8a127SAlexey Kardashevskiy if (!nb_numa_nodes) { 3307db8a127SAlexey Kardashevskiy nb_nodes = 1; 331fb164994SDavid Gibson ramnode.node_mem = machine->ram_size; 3327db8a127SAlexey Kardashevskiy nodes = &ramnode; 3335fe269b1SPaul Mackerras } 33453018216SPaolo Bonzini 3357db8a127SAlexey Kardashevskiy for (i = 0, mem_start = 0; i < nb_nodes; ++i) { 3367db8a127SAlexey Kardashevskiy if (!nodes[i].node_mem) { 3377db8a127SAlexey Kardashevskiy continue; 33853018216SPaolo Bonzini } 339fb164994SDavid Gibson if (mem_start >= machine->ram_size) { 3405fe269b1SPaul Mackerras node_size = 0; 3415fe269b1SPaul Mackerras } else { 3427db8a127SAlexey Kardashevskiy node_size = nodes[i].node_mem; 343fb164994SDavid Gibson if (node_size > machine->ram_size - mem_start) { 344fb164994SDavid Gibson node_size = machine->ram_size - mem_start; 3455fe269b1SPaul Mackerras } 3465fe269b1SPaul Mackerras } 3477db8a127SAlexey Kardashevskiy if (!mem_start) { 3487db8a127SAlexey Kardashevskiy /* ppc_spapr_init() checks for rma_size <= node0_size already */ 349e8f986fcSBharata B Rao spapr_populate_memory_node(fdt, i, 0, spapr->rma_size); 3507db8a127SAlexey Kardashevskiy mem_start += spapr->rma_size; 3517db8a127SAlexey Kardashevskiy node_size -= spapr->rma_size; 3527db8a127SAlexey Kardashevskiy } 3536010818cSAlexey Kardashevskiy for ( ; node_size; ) { 3546010818cSAlexey Kardashevskiy hwaddr sizetmp = pow2floor(node_size); 3556010818cSAlexey Kardashevskiy 3566010818cSAlexey Kardashevskiy /* mem_start != 0 here */ 3576010818cSAlexey Kardashevskiy if (ctzl(mem_start) < ctzl(sizetmp)) { 3586010818cSAlexey Kardashevskiy sizetmp = 1ULL << ctzl(mem_start); 3596010818cSAlexey Kardashevskiy } 3606010818cSAlexey Kardashevskiy 3616010818cSAlexey Kardashevskiy spapr_populate_memory_node(fdt, i, mem_start, sizetmp); 3626010818cSAlexey Kardashevskiy node_size -= sizetmp; 3636010818cSAlexey Kardashevskiy mem_start += sizetmp; 3646010818cSAlexey Kardashevskiy } 36553018216SPaolo Bonzini } 36653018216SPaolo Bonzini 36753018216SPaolo Bonzini return 0; 36853018216SPaolo Bonzini } 36953018216SPaolo Bonzini 370230bf719SThomas Huth /* Populate the "ibm,pa-features" property */ 371230bf719SThomas Huth static void spapr_populate_pa_features(CPUPPCState *env, void *fdt, int offset) 372230bf719SThomas Huth { 373230bf719SThomas Huth uint8_t pa_features_206[] = { 6, 0, 374230bf719SThomas Huth 0xf6, 0x1f, 0xc7, 0x00, 0x80, 0xc0 }; 375230bf719SThomas Huth uint8_t pa_features_207[] = { 24, 0, 376230bf719SThomas Huth 0xf6, 0x1f, 0xc7, 0xc0, 0x80, 0xf0, 377230bf719SThomas Huth 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 378230bf719SThomas Huth 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 379bac3bf28SThomas Huth 0x80, 0x00, 0x80, 0x00, 0x00, 0x00 }; 380230bf719SThomas Huth uint8_t *pa_features; 381230bf719SThomas Huth size_t pa_size; 382230bf719SThomas Huth 3834cbec30dSThomas Huth switch (env->mmu_model) { 3844cbec30dSThomas Huth case POWERPC_MMU_2_06: 3854cbec30dSThomas Huth case POWERPC_MMU_2_06a: 386230bf719SThomas Huth pa_features = pa_features_206; 387230bf719SThomas Huth pa_size = sizeof(pa_features_206); 3884cbec30dSThomas Huth break; 3894cbec30dSThomas Huth case POWERPC_MMU_2_07: 3904cbec30dSThomas Huth case POWERPC_MMU_2_07a: 391230bf719SThomas Huth pa_features = pa_features_207; 392230bf719SThomas Huth pa_size = sizeof(pa_features_207); 3934cbec30dSThomas Huth break; 3944cbec30dSThomas Huth default: 3954cbec30dSThomas Huth return; 396230bf719SThomas Huth } 397230bf719SThomas Huth 398230bf719SThomas Huth if (env->ci_large_pages) { 399230bf719SThomas Huth /* 400230bf719SThomas Huth * Note: we keep CI large pages off by default because a 64K capable 401230bf719SThomas Huth * guest provisioned with large pages might otherwise try to map a qemu 402230bf719SThomas Huth * framebuffer (or other kind of memory mapped PCI BAR) using 64K pages 403230bf719SThomas Huth * even if that qemu runs on a 4k host. 404230bf719SThomas Huth * We dd this bit back here if we are confident this is not an issue 405230bf719SThomas Huth */ 406230bf719SThomas Huth pa_features[3] |= 0x20; 407230bf719SThomas Huth } 408bac3bf28SThomas Huth if (kvmppc_has_cap_htm() && pa_size > 24) { 409bac3bf28SThomas Huth pa_features[24] |= 0x80; /* Transactional memory support */ 410bac3bf28SThomas Huth } 411230bf719SThomas Huth 412230bf719SThomas Huth _FDT((fdt_setprop(fdt, offset, "ibm,pa-features", pa_features, pa_size))); 413230bf719SThomas Huth } 414230bf719SThomas Huth 4150da6f3feSBharata B Rao static void spapr_populate_cpu_dt(CPUState *cs, void *fdt, int offset, 4160da6f3feSBharata B Rao sPAPRMachineState *spapr) 4170da6f3feSBharata B Rao { 4180da6f3feSBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(cs); 4190da6f3feSBharata B Rao CPUPPCState *env = &cpu->env; 4200da6f3feSBharata B Rao PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(cs); 4210da6f3feSBharata B Rao int index = ppc_get_vcpu_dt_id(cpu); 4220da6f3feSBharata B Rao uint32_t segs[] = {cpu_to_be32(28), cpu_to_be32(40), 4230da6f3feSBharata B Rao 0xffffffff, 0xffffffff}; 424afd10a0fSBharata B Rao uint32_t tbfreq = kvm_enabled() ? kvmppc_get_tbfreq() 425afd10a0fSBharata B Rao : SPAPR_TIMEBASE_FREQ; 4260da6f3feSBharata B Rao uint32_t cpufreq = kvm_enabled() ? kvmppc_get_clockfreq() : 1000000000; 4270da6f3feSBharata B Rao uint32_t page_sizes_prop[64]; 4280da6f3feSBharata B Rao size_t page_sizes_prop_size; 42922419c2aSDavid Gibson uint32_t vcpus_per_socket = smp_threads * smp_cores; 4300da6f3feSBharata B Rao uint32_t pft_size_prop[] = {0, cpu_to_be32(spapr->htab_shift)}; 43112dbeb16SDavid Gibson int compat_smt = MIN(smp_threads, ppc_compat_max_threads(cpu)); 432af81cf32SBharata B Rao sPAPRDRConnector *drc; 433af81cf32SBharata B Rao sPAPRDRConnectorClass *drck; 434af81cf32SBharata B Rao int drc_index; 435af81cf32SBharata B Rao 436af81cf32SBharata B Rao drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_CPU, index); 437af81cf32SBharata B Rao if (drc) { 438af81cf32SBharata B Rao drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 439af81cf32SBharata B Rao drc_index = drck->get_index(drc); 440af81cf32SBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,my-drc-index", drc_index))); 441af81cf32SBharata B Rao } 4420da6f3feSBharata B Rao 4430da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "reg", index))); 4440da6f3feSBharata B Rao _FDT((fdt_setprop_string(fdt, offset, "device_type", "cpu"))); 4450da6f3feSBharata B Rao 4460da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "cpu-version", env->spr[SPR_PVR]))); 4470da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "d-cache-block-size", 4480da6f3feSBharata B Rao env->dcache_line_size))); 4490da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "d-cache-line-size", 4500da6f3feSBharata B Rao env->dcache_line_size))); 4510da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "i-cache-block-size", 4520da6f3feSBharata B Rao env->icache_line_size))); 4530da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "i-cache-line-size", 4540da6f3feSBharata B Rao env->icache_line_size))); 4550da6f3feSBharata B Rao 4560da6f3feSBharata B Rao if (pcc->l1_dcache_size) { 4570da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "d-cache-size", 4580da6f3feSBharata B Rao pcc->l1_dcache_size))); 4590da6f3feSBharata B Rao } else { 460ce9863b7SCédric Le Goater error_report("Warning: Unknown L1 dcache size for cpu"); 4610da6f3feSBharata B Rao } 4620da6f3feSBharata B Rao if (pcc->l1_icache_size) { 4630da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "i-cache-size", 4640da6f3feSBharata B Rao pcc->l1_icache_size))); 4650da6f3feSBharata B Rao } else { 466ce9863b7SCédric Le Goater error_report("Warning: Unknown L1 icache size for cpu"); 4670da6f3feSBharata B Rao } 4680da6f3feSBharata B Rao 4690da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "timebase-frequency", tbfreq))); 4700da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "clock-frequency", cpufreq))); 471fd5da5c4SThomas Huth _FDT((fdt_setprop_cell(fdt, offset, "slb-size", env->slb_nr))); 4720da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,slb-size", env->slb_nr))); 4730da6f3feSBharata B Rao _FDT((fdt_setprop_string(fdt, offset, "status", "okay"))); 4740da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "64-bit", NULL, 0))); 4750da6f3feSBharata B Rao 4760da6f3feSBharata B Rao if (env->spr_cb[SPR_PURR].oea_read) { 4770da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,purr", NULL, 0))); 4780da6f3feSBharata B Rao } 4790da6f3feSBharata B Rao 4800da6f3feSBharata B Rao if (env->mmu_model & POWERPC_MMU_1TSEG) { 4810da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,processor-segment-sizes", 4820da6f3feSBharata B Rao segs, sizeof(segs)))); 4830da6f3feSBharata B Rao } 4840da6f3feSBharata B Rao 4850da6f3feSBharata B Rao /* Advertise VMX/VSX (vector extensions) if available 4860da6f3feSBharata B Rao * 0 / no property == no vector extensions 4870da6f3feSBharata B Rao * 1 == VMX / Altivec available 4880da6f3feSBharata B Rao * 2 == VSX available */ 4890da6f3feSBharata B Rao if (env->insns_flags & PPC_ALTIVEC) { 4900da6f3feSBharata B Rao uint32_t vmx = (env->insns_flags2 & PPC2_VSX) ? 2 : 1; 4910da6f3feSBharata B Rao 4920da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,vmx", vmx))); 4930da6f3feSBharata B Rao } 4940da6f3feSBharata B Rao 4950da6f3feSBharata B Rao /* Advertise DFP (Decimal Floating Point) if available 4960da6f3feSBharata B Rao * 0 / no property == no DFP 4970da6f3feSBharata B Rao * 1 == DFP available */ 4980da6f3feSBharata B Rao if (env->insns_flags2 & PPC2_DFP) { 4990da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,dfp", 1))); 5000da6f3feSBharata B Rao } 5010da6f3feSBharata B Rao 5023654fa95SCédric Le Goater page_sizes_prop_size = ppc_create_page_sizes_prop(env, page_sizes_prop, 5030da6f3feSBharata B Rao sizeof(page_sizes_prop)); 5040da6f3feSBharata B Rao if (page_sizes_prop_size) { 5050da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,segment-page-sizes", 5060da6f3feSBharata B Rao page_sizes_prop, page_sizes_prop_size))); 5070da6f3feSBharata B Rao } 5080da6f3feSBharata B Rao 509230bf719SThomas Huth spapr_populate_pa_features(env, fdt, offset); 51090da0d5aSBenjamin Herrenschmidt 5110da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,chip-id", 51222419c2aSDavid Gibson cs->cpu_index / vcpus_per_socket))); 5130da6f3feSBharata B Rao 5140da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,pft-size", 5150da6f3feSBharata B Rao pft_size_prop, sizeof(pft_size_prop)))); 5160da6f3feSBharata B Rao 5170da6f3feSBharata B Rao _FDT(spapr_fixup_cpu_numa_dt(fdt, offset, cs)); 5180da6f3feSBharata B Rao 51912dbeb16SDavid Gibson _FDT(spapr_fixup_cpu_smt_dt(fdt, offset, cpu, compat_smt)); 5200da6f3feSBharata B Rao } 5210da6f3feSBharata B Rao 5220da6f3feSBharata B Rao static void spapr_populate_cpus_dt_node(void *fdt, sPAPRMachineState *spapr) 5230da6f3feSBharata B Rao { 5240da6f3feSBharata B Rao CPUState *cs; 5250da6f3feSBharata B Rao int cpus_offset; 5260da6f3feSBharata B Rao char *nodename; 5270da6f3feSBharata B Rao int smt = kvmppc_smt_threads(); 5280da6f3feSBharata B Rao 5290da6f3feSBharata B Rao cpus_offset = fdt_add_subnode(fdt, 0, "cpus"); 5300da6f3feSBharata B Rao _FDT(cpus_offset); 5310da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, cpus_offset, "#address-cells", 0x1))); 5320da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, cpus_offset, "#size-cells", 0x0))); 5330da6f3feSBharata B Rao 5340da6f3feSBharata B Rao /* 5350da6f3feSBharata B Rao * We walk the CPUs in reverse order to ensure that CPU DT nodes 5360da6f3feSBharata B Rao * created by fdt_add_subnode() end up in the right order in FDT 5370da6f3feSBharata B Rao * for the guest kernel the enumerate the CPUs correctly. 5380da6f3feSBharata B Rao */ 5390da6f3feSBharata B Rao CPU_FOREACH_REVERSE(cs) { 5400da6f3feSBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(cs); 5410da6f3feSBharata B Rao int index = ppc_get_vcpu_dt_id(cpu); 5420da6f3feSBharata B Rao DeviceClass *dc = DEVICE_GET_CLASS(cs); 5430da6f3feSBharata B Rao int offset; 5440da6f3feSBharata B Rao 5450da6f3feSBharata B Rao if ((index % smt) != 0) { 5460da6f3feSBharata B Rao continue; 5470da6f3feSBharata B Rao } 5480da6f3feSBharata B Rao 5490da6f3feSBharata B Rao nodename = g_strdup_printf("%s@%x", dc->fw_name, index); 5500da6f3feSBharata B Rao offset = fdt_add_subnode(fdt, cpus_offset, nodename); 5510da6f3feSBharata B Rao g_free(nodename); 5520da6f3feSBharata B Rao _FDT(offset); 5530da6f3feSBharata B Rao spapr_populate_cpu_dt(cs, fdt, offset, spapr); 5540da6f3feSBharata B Rao } 5550da6f3feSBharata B Rao 5560da6f3feSBharata B Rao } 5570da6f3feSBharata B Rao 55803d196b7SBharata B Rao /* 55903d196b7SBharata B Rao * Adds ibm,dynamic-reconfiguration-memory node. 56003d196b7SBharata B Rao * Refer to docs/specs/ppc-spapr-hotplug.txt for the documentation 56103d196b7SBharata B Rao * of this device tree node. 56203d196b7SBharata B Rao */ 56303d196b7SBharata B Rao static int spapr_populate_drconf_memory(sPAPRMachineState *spapr, void *fdt) 56403d196b7SBharata B Rao { 56503d196b7SBharata B Rao MachineState *machine = MACHINE(spapr); 56603d196b7SBharata B Rao int ret, i, offset; 56703d196b7SBharata B Rao uint64_t lmb_size = SPAPR_MEMORY_BLOCK_SIZE; 56803d196b7SBharata B Rao uint32_t prop_lmb_size[] = {0, cpu_to_be32(lmb_size)}; 569d0e5a8f2SBharata B Rao uint32_t hotplug_lmb_start = spapr->hotplug_memory.base / lmb_size; 570d0e5a8f2SBharata B Rao uint32_t nr_lmbs = (spapr->hotplug_memory.base + 571d0e5a8f2SBharata B Rao memory_region_size(&spapr->hotplug_memory.mr)) / 572d0e5a8f2SBharata B Rao lmb_size; 57303d196b7SBharata B Rao uint32_t *int_buf, *cur_index, buf_len; 5746663864eSBharata B Rao int nr_nodes = nb_numa_nodes ? nb_numa_nodes : 1; 57503d196b7SBharata B Rao 576ef001f06SThomas Huth /* 577d0e5a8f2SBharata B Rao * Don't create the node if there is no hotpluggable memory 57816c25aefSBharata B Rao */ 579d0e5a8f2SBharata B Rao if (machine->ram_size == machine->maxram_size) { 58016c25aefSBharata B Rao return 0; 58116c25aefSBharata B Rao } 58216c25aefSBharata B Rao 58316c25aefSBharata B Rao /* 584ef001f06SThomas Huth * Allocate enough buffer size to fit in ibm,dynamic-memory 585ef001f06SThomas Huth * or ibm,associativity-lookup-arrays 586ef001f06SThomas Huth */ 587ef001f06SThomas Huth buf_len = MAX(nr_lmbs * SPAPR_DR_LMB_LIST_ENTRY_SIZE + 1, nr_nodes * 4 + 2) 588ef001f06SThomas Huth * sizeof(uint32_t); 58903d196b7SBharata B Rao cur_index = int_buf = g_malloc0(buf_len); 59003d196b7SBharata B Rao 59103d196b7SBharata B Rao offset = fdt_add_subnode(fdt, 0, "ibm,dynamic-reconfiguration-memory"); 59203d196b7SBharata B Rao 59303d196b7SBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,lmb-size", prop_lmb_size, 59403d196b7SBharata B Rao sizeof(prop_lmb_size)); 59503d196b7SBharata B Rao if (ret < 0) { 59603d196b7SBharata B Rao goto out; 59703d196b7SBharata B Rao } 59803d196b7SBharata B Rao 59903d196b7SBharata B Rao ret = fdt_setprop_cell(fdt, offset, "ibm,memory-flags-mask", 0xff); 60003d196b7SBharata B Rao if (ret < 0) { 60103d196b7SBharata B Rao goto out; 60203d196b7SBharata B Rao } 60303d196b7SBharata B Rao 60403d196b7SBharata B Rao ret = fdt_setprop_cell(fdt, offset, "ibm,memory-preservation-time", 0x0); 60503d196b7SBharata B Rao if (ret < 0) { 60603d196b7SBharata B Rao goto out; 60703d196b7SBharata B Rao } 60803d196b7SBharata B Rao 60903d196b7SBharata B Rao /* ibm,dynamic-memory */ 61003d196b7SBharata B Rao int_buf[0] = cpu_to_be32(nr_lmbs); 61103d196b7SBharata B Rao cur_index++; 61203d196b7SBharata B Rao for (i = 0; i < nr_lmbs; i++) { 613d0e5a8f2SBharata B Rao uint64_t addr = i * lmb_size; 61403d196b7SBharata B Rao uint32_t *dynamic_memory = cur_index; 61503d196b7SBharata B Rao 616d0e5a8f2SBharata B Rao if (i >= hotplug_lmb_start) { 617d0e5a8f2SBharata B Rao sPAPRDRConnector *drc; 618d0e5a8f2SBharata B Rao sPAPRDRConnectorClass *drck; 619d0e5a8f2SBharata B Rao 620d0e5a8f2SBharata B Rao drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_LMB, i); 62103d196b7SBharata B Rao g_assert(drc); 62203d196b7SBharata B Rao drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 62303d196b7SBharata B Rao 62403d196b7SBharata B Rao dynamic_memory[0] = cpu_to_be32(addr >> 32); 62503d196b7SBharata B Rao dynamic_memory[1] = cpu_to_be32(addr & 0xffffffff); 62603d196b7SBharata B Rao dynamic_memory[2] = cpu_to_be32(drck->get_index(drc)); 62703d196b7SBharata B Rao dynamic_memory[3] = cpu_to_be32(0); /* reserved */ 62803d196b7SBharata B Rao dynamic_memory[4] = cpu_to_be32(numa_get_node(addr, NULL)); 629d0e5a8f2SBharata B Rao if (memory_region_present(get_system_memory(), addr)) { 63003d196b7SBharata B Rao dynamic_memory[5] = cpu_to_be32(SPAPR_LMB_FLAGS_ASSIGNED); 63103d196b7SBharata B Rao } else { 63203d196b7SBharata B Rao dynamic_memory[5] = cpu_to_be32(0); 63303d196b7SBharata B Rao } 634d0e5a8f2SBharata B Rao } else { 635d0e5a8f2SBharata B Rao /* 636d0e5a8f2SBharata B Rao * LMB information for RMA, boot time RAM and gap b/n RAM and 637d0e5a8f2SBharata B Rao * hotplug memory region -- all these are marked as reserved 638d0e5a8f2SBharata B Rao * and as having no valid DRC. 639d0e5a8f2SBharata B Rao */ 640d0e5a8f2SBharata B Rao dynamic_memory[0] = cpu_to_be32(addr >> 32); 641d0e5a8f2SBharata B Rao dynamic_memory[1] = cpu_to_be32(addr & 0xffffffff); 642d0e5a8f2SBharata B Rao dynamic_memory[2] = cpu_to_be32(0); 643d0e5a8f2SBharata B Rao dynamic_memory[3] = cpu_to_be32(0); /* reserved */ 644d0e5a8f2SBharata B Rao dynamic_memory[4] = cpu_to_be32(-1); 645d0e5a8f2SBharata B Rao dynamic_memory[5] = cpu_to_be32(SPAPR_LMB_FLAGS_RESERVED | 646d0e5a8f2SBharata B Rao SPAPR_LMB_FLAGS_DRC_INVALID); 647d0e5a8f2SBharata B Rao } 64803d196b7SBharata B Rao 64903d196b7SBharata B Rao cur_index += SPAPR_DR_LMB_LIST_ENTRY_SIZE; 65003d196b7SBharata B Rao } 65103d196b7SBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,dynamic-memory", int_buf, buf_len); 65203d196b7SBharata B Rao if (ret < 0) { 65303d196b7SBharata B Rao goto out; 65403d196b7SBharata B Rao } 65503d196b7SBharata B Rao 65603d196b7SBharata B Rao /* ibm,associativity-lookup-arrays */ 65703d196b7SBharata B Rao cur_index = int_buf; 6586663864eSBharata B Rao int_buf[0] = cpu_to_be32(nr_nodes); 65903d196b7SBharata B Rao int_buf[1] = cpu_to_be32(4); /* Number of entries per associativity list */ 66003d196b7SBharata B Rao cur_index += 2; 6616663864eSBharata B Rao for (i = 0; i < nr_nodes; i++) { 66203d196b7SBharata B Rao uint32_t associativity[] = { 66303d196b7SBharata B Rao cpu_to_be32(0x0), 66403d196b7SBharata B Rao cpu_to_be32(0x0), 66503d196b7SBharata B Rao cpu_to_be32(0x0), 66603d196b7SBharata B Rao cpu_to_be32(i) 66703d196b7SBharata B Rao }; 66803d196b7SBharata B Rao memcpy(cur_index, associativity, sizeof(associativity)); 66903d196b7SBharata B Rao cur_index += 4; 67003d196b7SBharata B Rao } 67103d196b7SBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,associativity-lookup-arrays", int_buf, 67203d196b7SBharata B Rao (cur_index - int_buf) * sizeof(uint32_t)); 67303d196b7SBharata B Rao out: 67403d196b7SBharata B Rao g_free(int_buf); 67503d196b7SBharata B Rao return ret; 67603d196b7SBharata B Rao } 67703d196b7SBharata B Rao 6786787d27bSMichael Roth static int spapr_dt_cas_updates(sPAPRMachineState *spapr, void *fdt, 6796787d27bSMichael Roth sPAPROptionVector *ov5_updates) 6806787d27bSMichael Roth { 6816787d27bSMichael Roth sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(spapr); 682417ece33SMichael Roth int ret = 0, offset; 6836787d27bSMichael Roth 6846787d27bSMichael Roth /* Generate ibm,dynamic-reconfiguration-memory node if required */ 6856787d27bSMichael Roth if (spapr_ovec_test(ov5_updates, OV5_DRCONF_MEMORY)) { 6866787d27bSMichael Roth g_assert(smc->dr_lmb_enabled); 6876787d27bSMichael Roth ret = spapr_populate_drconf_memory(spapr, fdt); 688417ece33SMichael Roth if (ret) { 689417ece33SMichael Roth goto out; 690417ece33SMichael Roth } 6916787d27bSMichael Roth } 6926787d27bSMichael Roth 693417ece33SMichael Roth offset = fdt_path_offset(fdt, "/chosen"); 694417ece33SMichael Roth if (offset < 0) { 695417ece33SMichael Roth offset = fdt_add_subnode(fdt, 0, "chosen"); 696417ece33SMichael Roth if (offset < 0) { 697417ece33SMichael Roth return offset; 698417ece33SMichael Roth } 699417ece33SMichael Roth } 700417ece33SMichael Roth ret = spapr_ovec_populate_dt(fdt, offset, spapr->ov5_cas, 701417ece33SMichael Roth "ibm,architecture-vec-5"); 702417ece33SMichael Roth 703417ece33SMichael Roth out: 7046787d27bSMichael Roth return ret; 7056787d27bSMichael Roth } 7066787d27bSMichael Roth 70703d196b7SBharata B Rao int spapr_h_cas_compose_response(sPAPRMachineState *spapr, 70803d196b7SBharata B Rao target_ulong addr, target_ulong size, 7096787d27bSMichael Roth sPAPROptionVector *ov5_updates) 71003d196b7SBharata B Rao { 71103d196b7SBharata B Rao void *fdt, *fdt_skel; 71203d196b7SBharata B Rao sPAPRDeviceTreeUpdateHeader hdr = { .version_id = 1 }; 71303d196b7SBharata B Rao 71403d196b7SBharata B Rao size -= sizeof(hdr); 71503d196b7SBharata B Rao 71603d196b7SBharata B Rao /* Create sceleton */ 71703d196b7SBharata B Rao fdt_skel = g_malloc0(size); 71803d196b7SBharata B Rao _FDT((fdt_create(fdt_skel, size))); 71903d196b7SBharata B Rao _FDT((fdt_begin_node(fdt_skel, ""))); 72003d196b7SBharata B Rao _FDT((fdt_end_node(fdt_skel))); 72103d196b7SBharata B Rao _FDT((fdt_finish(fdt_skel))); 72203d196b7SBharata B Rao fdt = g_malloc0(size); 72303d196b7SBharata B Rao _FDT((fdt_open_into(fdt_skel, fdt, size))); 72403d196b7SBharata B Rao g_free(fdt_skel); 72503d196b7SBharata B Rao 72603d196b7SBharata B Rao /* Fixup cpu nodes */ 72703d196b7SBharata B Rao _FDT((spapr_fixup_cpu_dt(fdt, spapr))); 72803d196b7SBharata B Rao 7296787d27bSMichael Roth if (spapr_dt_cas_updates(spapr, fdt, ov5_updates)) { 7306787d27bSMichael Roth return -1; 73103d196b7SBharata B Rao } 73203d196b7SBharata B Rao 73303d196b7SBharata B Rao /* Pack resulting tree */ 73403d196b7SBharata B Rao _FDT((fdt_pack(fdt))); 73503d196b7SBharata B Rao 73603d196b7SBharata B Rao if (fdt_totalsize(fdt) + sizeof(hdr) > size) { 73703d196b7SBharata B Rao trace_spapr_cas_failed(size); 73803d196b7SBharata B Rao return -1; 73903d196b7SBharata B Rao } 74003d196b7SBharata B Rao 74103d196b7SBharata B Rao cpu_physical_memory_write(addr, &hdr, sizeof(hdr)); 74203d196b7SBharata B Rao cpu_physical_memory_write(addr + sizeof(hdr), fdt, fdt_totalsize(fdt)); 74303d196b7SBharata B Rao trace_spapr_cas_continue(fdt_totalsize(fdt) + sizeof(hdr)); 74403d196b7SBharata B Rao g_free(fdt); 74503d196b7SBharata B Rao 74603d196b7SBharata B Rao return 0; 74703d196b7SBharata B Rao } 74803d196b7SBharata B Rao 7493f5dabceSDavid Gibson static void spapr_dt_rtas(sPAPRMachineState *spapr, void *fdt) 7503f5dabceSDavid Gibson { 7513f5dabceSDavid Gibson int rtas; 7523f5dabceSDavid Gibson GString *hypertas = g_string_sized_new(256); 7533f5dabceSDavid Gibson GString *qemu_hypertas = g_string_sized_new(256); 7543f5dabceSDavid Gibson uint32_t refpoints[] = { cpu_to_be32(0x4), cpu_to_be32(0x4) }; 7553f5dabceSDavid Gibson uint64_t max_hotplug_addr = spapr->hotplug_memory.base + 7563f5dabceSDavid Gibson memory_region_size(&spapr->hotplug_memory.mr); 7573f5dabceSDavid Gibson uint32_t lrdr_capacity[] = { 7583f5dabceSDavid Gibson cpu_to_be32(max_hotplug_addr >> 32), 7593f5dabceSDavid Gibson cpu_to_be32(max_hotplug_addr & 0xffffffff), 7603f5dabceSDavid Gibson 0, cpu_to_be32(SPAPR_MEMORY_BLOCK_SIZE), 7613f5dabceSDavid Gibson cpu_to_be32(max_cpus / smp_threads), 7623f5dabceSDavid Gibson }; 7633f5dabceSDavid Gibson 7643f5dabceSDavid Gibson _FDT(rtas = fdt_add_subnode(fdt, 0, "rtas")); 7653f5dabceSDavid Gibson 7663f5dabceSDavid Gibson /* hypertas */ 7673f5dabceSDavid Gibson add_str(hypertas, "hcall-pft"); 7683f5dabceSDavid Gibson add_str(hypertas, "hcall-term"); 7693f5dabceSDavid Gibson add_str(hypertas, "hcall-dabr"); 7703f5dabceSDavid Gibson add_str(hypertas, "hcall-interrupt"); 7713f5dabceSDavid Gibson add_str(hypertas, "hcall-tce"); 7723f5dabceSDavid Gibson add_str(hypertas, "hcall-vio"); 7733f5dabceSDavid Gibson add_str(hypertas, "hcall-splpar"); 7743f5dabceSDavid Gibson add_str(hypertas, "hcall-bulk"); 7753f5dabceSDavid Gibson add_str(hypertas, "hcall-set-mode"); 7763f5dabceSDavid Gibson add_str(hypertas, "hcall-sprg0"); 7773f5dabceSDavid Gibson add_str(hypertas, "hcall-copy"); 7783f5dabceSDavid Gibson add_str(hypertas, "hcall-debug"); 7793f5dabceSDavid Gibson add_str(qemu_hypertas, "hcall-memop1"); 7803f5dabceSDavid Gibson 7813f5dabceSDavid Gibson if (!kvm_enabled() || kvmppc_spapr_use_multitce()) { 7823f5dabceSDavid Gibson add_str(hypertas, "hcall-multi-tce"); 7833f5dabceSDavid Gibson } 7843f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,hypertas-functions", 7853f5dabceSDavid Gibson hypertas->str, hypertas->len)); 7863f5dabceSDavid Gibson g_string_free(hypertas, TRUE); 7873f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "qemu,hypertas-functions", 7883f5dabceSDavid Gibson qemu_hypertas->str, qemu_hypertas->len)); 7893f5dabceSDavid Gibson g_string_free(qemu_hypertas, TRUE); 7903f5dabceSDavid Gibson 7913f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,associativity-reference-points", 7923f5dabceSDavid Gibson refpoints, sizeof(refpoints))); 7933f5dabceSDavid Gibson 7943f5dabceSDavid Gibson _FDT(fdt_setprop_cell(fdt, rtas, "rtas-error-log-max", 7953f5dabceSDavid Gibson RTAS_ERROR_LOG_MAX)); 7963f5dabceSDavid Gibson _FDT(fdt_setprop_cell(fdt, rtas, "rtas-event-scan-rate", 7973f5dabceSDavid Gibson RTAS_EVENT_SCAN_RATE)); 7983f5dabceSDavid Gibson 7993f5dabceSDavid Gibson if (msi_nonbroken) { 8003f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,change-msix-capable", NULL, 0)); 8013f5dabceSDavid Gibson } 8023f5dabceSDavid Gibson 8033f5dabceSDavid Gibson /* 8043f5dabceSDavid Gibson * According to PAPR, rtas ibm,os-term does not guarantee a return 8053f5dabceSDavid Gibson * back to the guest cpu. 8063f5dabceSDavid Gibson * 8073f5dabceSDavid Gibson * While an additional ibm,extended-os-term property indicates 8083f5dabceSDavid Gibson * that rtas call return will always occur. Set this property. 8093f5dabceSDavid Gibson */ 8103f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,extended-os-term", NULL, 0)); 8113f5dabceSDavid Gibson 8123f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,lrdr-capacity", 8133f5dabceSDavid Gibson lrdr_capacity, sizeof(lrdr_capacity))); 8143f5dabceSDavid Gibson 8153f5dabceSDavid Gibson spapr_dt_rtas_tokens(fdt, rtas); 8163f5dabceSDavid Gibson } 8173f5dabceSDavid Gibson 8187c866c6aSDavid Gibson static void spapr_dt_chosen(sPAPRMachineState *spapr, void *fdt) 8197c866c6aSDavid Gibson { 8207c866c6aSDavid Gibson MachineState *machine = MACHINE(spapr); 8217c866c6aSDavid Gibson int chosen; 8227c866c6aSDavid Gibson const char *boot_device = machine->boot_order; 8237c866c6aSDavid Gibson char *stdout_path = spapr_vio_stdout_path(spapr->vio_bus); 8247c866c6aSDavid Gibson size_t cb = 0; 8257c866c6aSDavid Gibson char *bootlist = get_boot_devices_list(&cb, true); 8267c866c6aSDavid Gibson 8277c866c6aSDavid Gibson _FDT(chosen = fdt_add_subnode(fdt, 0, "chosen")); 8287c866c6aSDavid Gibson 8297c866c6aSDavid Gibson _FDT(fdt_setprop_string(fdt, chosen, "bootargs", machine->kernel_cmdline)); 8307c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "linux,initrd-start", 8317c866c6aSDavid Gibson spapr->initrd_base)); 8327c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "linux,initrd-end", 8337c866c6aSDavid Gibson spapr->initrd_base + spapr->initrd_size)); 8347c866c6aSDavid Gibson 8357c866c6aSDavid Gibson if (spapr->kernel_size) { 8367c866c6aSDavid Gibson uint64_t kprop[2] = { cpu_to_be64(KERNEL_LOAD_ADDR), 8377c866c6aSDavid Gibson cpu_to_be64(spapr->kernel_size) }; 8387c866c6aSDavid Gibson 8397c866c6aSDavid Gibson _FDT(fdt_setprop(fdt, chosen, "qemu,boot-kernel", 8407c866c6aSDavid Gibson &kprop, sizeof(kprop))); 8417c866c6aSDavid Gibson if (spapr->kernel_le) { 8427c866c6aSDavid Gibson _FDT(fdt_setprop(fdt, chosen, "qemu,boot-kernel-le", NULL, 0)); 8437c866c6aSDavid Gibson } 8447c866c6aSDavid Gibson } 8457c866c6aSDavid Gibson if (boot_menu) { 8467c866c6aSDavid Gibson _FDT((fdt_setprop_cell(fdt, chosen, "qemu,boot-menu", boot_menu))); 8477c866c6aSDavid Gibson } 8487c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "qemu,graphic-width", graphic_width)); 8497c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "qemu,graphic-height", graphic_height)); 8507c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "qemu,graphic-depth", graphic_depth)); 8517c866c6aSDavid Gibson 8527c866c6aSDavid Gibson if (cb && bootlist) { 8537c866c6aSDavid Gibson int i; 8547c866c6aSDavid Gibson 8557c866c6aSDavid Gibson for (i = 0; i < cb; i++) { 8567c866c6aSDavid Gibson if (bootlist[i] == '\n') { 8577c866c6aSDavid Gibson bootlist[i] = ' '; 8587c866c6aSDavid Gibson } 8597c866c6aSDavid Gibson } 8607c866c6aSDavid Gibson _FDT(fdt_setprop_string(fdt, chosen, "qemu,boot-list", bootlist)); 8617c866c6aSDavid Gibson } 8627c866c6aSDavid Gibson 8637c866c6aSDavid Gibson if (boot_device && strlen(boot_device)) { 8647c866c6aSDavid Gibson _FDT(fdt_setprop_string(fdt, chosen, "qemu,boot-device", boot_device)); 8657c866c6aSDavid Gibson } 8667c866c6aSDavid Gibson 8677c866c6aSDavid Gibson if (!spapr->has_graphics && stdout_path) { 8687c866c6aSDavid Gibson _FDT(fdt_setprop_string(fdt, chosen, "linux,stdout-path", stdout_path)); 8697c866c6aSDavid Gibson } 8707c866c6aSDavid Gibson 8717c866c6aSDavid Gibson g_free(stdout_path); 8727c866c6aSDavid Gibson g_free(bootlist); 8737c866c6aSDavid Gibson } 8747c866c6aSDavid Gibson 875fca5f2dcSDavid Gibson static void spapr_dt_hypervisor(sPAPRMachineState *spapr, void *fdt) 876fca5f2dcSDavid Gibson { 877fca5f2dcSDavid Gibson /* The /hypervisor node isn't in PAPR - this is a hack to allow PR 878fca5f2dcSDavid Gibson * KVM to work under pHyp with some guest co-operation */ 879fca5f2dcSDavid Gibson int hypervisor; 880fca5f2dcSDavid Gibson uint8_t hypercall[16]; 881fca5f2dcSDavid Gibson 882fca5f2dcSDavid Gibson _FDT(hypervisor = fdt_add_subnode(fdt, 0, "hypervisor")); 883fca5f2dcSDavid Gibson /* indicate KVM hypercall interface */ 884fca5f2dcSDavid Gibson _FDT(fdt_setprop_string(fdt, hypervisor, "compatible", "linux,kvm")); 885fca5f2dcSDavid Gibson if (kvmppc_has_cap_fixup_hcalls()) { 886fca5f2dcSDavid Gibson /* 887fca5f2dcSDavid Gibson * Older KVM versions with older guest kernels were broken 888fca5f2dcSDavid Gibson * with the magic page, don't allow the guest to map it. 889fca5f2dcSDavid Gibson */ 890fca5f2dcSDavid Gibson if (!kvmppc_get_hypercall(first_cpu->env_ptr, hypercall, 891fca5f2dcSDavid Gibson sizeof(hypercall))) { 892fca5f2dcSDavid Gibson _FDT(fdt_setprop(fdt, hypervisor, "hcall-instructions", 893fca5f2dcSDavid Gibson hypercall, sizeof(hypercall))); 894fca5f2dcSDavid Gibson } 895fca5f2dcSDavid Gibson } 896fca5f2dcSDavid Gibson } 897fca5f2dcSDavid Gibson 898997b6cfcSDavid Gibson static void *spapr_build_fdt(sPAPRMachineState *spapr, 89953018216SPaolo Bonzini hwaddr rtas_addr, 90053018216SPaolo Bonzini hwaddr rtas_size) 90153018216SPaolo Bonzini { 9025b2128d2SAlexander Graf MachineState *machine = MACHINE(qdev_get_machine()); 9033c0c47e3SDavid Gibson MachineClass *mc = MACHINE_GET_CLASS(machine); 904c20d332aSBharata B Rao sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(machine); 9057c866c6aSDavid Gibson int ret; 90653018216SPaolo Bonzini void *fdt; 90753018216SPaolo Bonzini sPAPRPHBState *phb; 908398a0bd5SDavid Gibson char *buf; 90953018216SPaolo Bonzini 910398a0bd5SDavid Gibson fdt = g_malloc0(FDT_MAX_SIZE); 911398a0bd5SDavid Gibson _FDT((fdt_create_empty_tree(fdt, FDT_MAX_SIZE))); 91253018216SPaolo Bonzini 913398a0bd5SDavid Gibson /* Root node */ 914398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "device_type", "chrp")); 915398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "model", "IBM pSeries (emulated by qemu)")); 916398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "compatible", "qemu,pseries")); 917398a0bd5SDavid Gibson 918398a0bd5SDavid Gibson /* 919398a0bd5SDavid Gibson * Add info to guest to indentify which host is it being run on 920398a0bd5SDavid Gibson * and what is the uuid of the guest 921398a0bd5SDavid Gibson */ 922398a0bd5SDavid Gibson if (kvmppc_get_host_model(&buf)) { 923398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "host-model", buf)); 924398a0bd5SDavid Gibson g_free(buf); 925398a0bd5SDavid Gibson } 926398a0bd5SDavid Gibson if (kvmppc_get_host_serial(&buf)) { 927398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "host-serial", buf)); 928398a0bd5SDavid Gibson g_free(buf); 929398a0bd5SDavid Gibson } 930398a0bd5SDavid Gibson 931398a0bd5SDavid Gibson buf = qemu_uuid_unparse_strdup(&qemu_uuid); 932398a0bd5SDavid Gibson 933398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "vm,uuid", buf)); 934398a0bd5SDavid Gibson if (qemu_uuid_set) { 935398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "system-id", buf)); 936398a0bd5SDavid Gibson } 937398a0bd5SDavid Gibson g_free(buf); 938398a0bd5SDavid Gibson 939398a0bd5SDavid Gibson if (qemu_get_vm_name()) { 940398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "ibm,partition-name", 941398a0bd5SDavid Gibson qemu_get_vm_name())); 942398a0bd5SDavid Gibson } 943398a0bd5SDavid Gibson 944398a0bd5SDavid Gibson _FDT(fdt_setprop_cell(fdt, 0, "#address-cells", 2)); 945398a0bd5SDavid Gibson _FDT(fdt_setprop_cell(fdt, 0, "#size-cells", 2)); 94653018216SPaolo Bonzini 9479b9a1908SDavid Gibson /* /interrupt controller */ 9489b9a1908SDavid Gibson spapr_dt_xics(spapr->xics, fdt, PHANDLE_XICP); 9499b9a1908SDavid Gibson 950e8f986fcSBharata B Rao ret = spapr_populate_memory(spapr, fdt); 951e8f986fcSBharata B Rao if (ret < 0) { 952ce9863b7SCédric Le Goater error_report("couldn't setup memory nodes in fdt"); 953e8f986fcSBharata B Rao exit(1); 95453018216SPaolo Bonzini } 95553018216SPaolo Bonzini 956bf5a6696SDavid Gibson /* /vdevice */ 957bf5a6696SDavid Gibson spapr_dt_vdevice(spapr->vio_bus, fdt); 95853018216SPaolo Bonzini 9594d9392beSThomas Huth if (object_resolve_path_type("", TYPE_SPAPR_RNG, NULL)) { 9604d9392beSThomas Huth ret = spapr_rng_populate_dt(fdt); 9614d9392beSThomas Huth if (ret < 0) { 962ce9863b7SCédric Le Goater error_report("could not set up rng device in the fdt"); 9634d9392beSThomas Huth exit(1); 9644d9392beSThomas Huth } 9654d9392beSThomas Huth } 9664d9392beSThomas Huth 96753018216SPaolo Bonzini QLIST_FOREACH(phb, &spapr->phbs, list) { 96853018216SPaolo Bonzini ret = spapr_populate_pci_dt(phb, PHANDLE_XICP, fdt); 96953018216SPaolo Bonzini if (ret < 0) { 970da34fed7SThomas Huth error_report("couldn't setup PCI devices in fdt"); 97153018216SPaolo Bonzini exit(1); 97253018216SPaolo Bonzini } 973da34fed7SThomas Huth } 97453018216SPaolo Bonzini 9750da6f3feSBharata B Rao /* cpus */ 9760da6f3feSBharata B Rao spapr_populate_cpus_dt_node(fdt, spapr); 97753018216SPaolo Bonzini 978c20d332aSBharata B Rao if (smc->dr_lmb_enabled) { 979c20d332aSBharata B Rao _FDT(spapr_drc_populate_dt(fdt, 0, NULL, SPAPR_DR_CONNECTOR_TYPE_LMB)); 980c20d332aSBharata B Rao } 981c20d332aSBharata B Rao 982c5514d0eSIgor Mammedov if (mc->has_hotpluggable_cpus) { 983af81cf32SBharata B Rao int offset = fdt_path_offset(fdt, "/cpus"); 984af81cf32SBharata B Rao ret = spapr_drc_populate_dt(fdt, offset, NULL, 985af81cf32SBharata B Rao SPAPR_DR_CONNECTOR_TYPE_CPU); 986af81cf32SBharata B Rao if (ret < 0) { 987af81cf32SBharata B Rao error_report("Couldn't set up CPU DR device tree properties"); 988af81cf32SBharata B Rao exit(1); 989af81cf32SBharata B Rao } 990af81cf32SBharata B Rao } 991af81cf32SBharata B Rao 992ffb1e275SDavid Gibson /* /event-sources */ 993ffbb1705SMichael Roth spapr_dt_events(spapr, fdt); 994ffb1e275SDavid Gibson 9953f5dabceSDavid Gibson /* /rtas */ 9963f5dabceSDavid Gibson spapr_dt_rtas(spapr, fdt); 9973f5dabceSDavid Gibson 9987c866c6aSDavid Gibson /* /chosen */ 9997c866c6aSDavid Gibson spapr_dt_chosen(spapr, fdt); 1000cf6e5223SDavid Gibson 1001fca5f2dcSDavid Gibson /* /hypervisor */ 1002fca5f2dcSDavid Gibson if (kvm_enabled()) { 1003fca5f2dcSDavid Gibson spapr_dt_hypervisor(spapr, fdt); 1004fca5f2dcSDavid Gibson } 1005fca5f2dcSDavid Gibson 1006cf6e5223SDavid Gibson /* Build memory reserve map */ 1007cf6e5223SDavid Gibson if (spapr->kernel_size) { 1008cf6e5223SDavid Gibson _FDT((fdt_add_mem_rsv(fdt, KERNEL_LOAD_ADDR, spapr->kernel_size))); 1009cf6e5223SDavid Gibson } 1010cf6e5223SDavid Gibson if (spapr->initrd_size) { 1011cf6e5223SDavid Gibson _FDT((fdt_add_mem_rsv(fdt, spapr->initrd_base, spapr->initrd_size))); 1012cf6e5223SDavid Gibson } 1013cf6e5223SDavid Gibson 10146787d27bSMichael Roth /* ibm,client-architecture-support updates */ 10156787d27bSMichael Roth ret = spapr_dt_cas_updates(spapr, fdt, spapr->ov5_cas); 10166787d27bSMichael Roth if (ret < 0) { 10176787d27bSMichael Roth error_report("couldn't setup CAS properties fdt"); 10186787d27bSMichael Roth exit(1); 10196787d27bSMichael Roth } 10206787d27bSMichael Roth 1021997b6cfcSDavid Gibson return fdt; 102253018216SPaolo Bonzini } 102353018216SPaolo Bonzini 102453018216SPaolo Bonzini static uint64_t translate_kernel_address(void *opaque, uint64_t addr) 102553018216SPaolo Bonzini { 102653018216SPaolo Bonzini return (addr & 0x0fffffff) + KERNEL_LOAD_ADDR; 102753018216SPaolo Bonzini } 102853018216SPaolo Bonzini 10291d1be34dSDavid Gibson static void emulate_spapr_hypercall(PPCVirtualHypervisor *vhyp, 10301d1be34dSDavid Gibson PowerPCCPU *cpu) 103153018216SPaolo Bonzini { 103253018216SPaolo Bonzini CPUPPCState *env = &cpu->env; 103353018216SPaolo Bonzini 10348d04fb55SJan Kiszka /* The TCG path should also be holding the BQL at this point */ 10358d04fb55SJan Kiszka g_assert(qemu_mutex_iothread_locked()); 10368d04fb55SJan Kiszka 103753018216SPaolo Bonzini if (msr_pr) { 103853018216SPaolo Bonzini hcall_dprintf("Hypercall made with MSR[PR]=1\n"); 103953018216SPaolo Bonzini env->gpr[3] = H_PRIVILEGE; 104053018216SPaolo Bonzini } else { 104153018216SPaolo Bonzini env->gpr[3] = spapr_hypercall(cpu, env->gpr[3], &env->gpr[4]); 104253018216SPaolo Bonzini } 104353018216SPaolo Bonzini } 104453018216SPaolo Bonzini 1045e6b8fd24SSamuel Mendoza-Jonas #define HPTE(_table, _i) (void *)(((uint64_t *)(_table)) + ((_i) * 2)) 1046e6b8fd24SSamuel Mendoza-Jonas #define HPTE_VALID(_hpte) (tswap64(*((uint64_t *)(_hpte))) & HPTE64_V_VALID) 1047e6b8fd24SSamuel Mendoza-Jonas #define HPTE_DIRTY(_hpte) (tswap64(*((uint64_t *)(_hpte))) & HPTE64_V_HPTE_DIRTY) 1048e6b8fd24SSamuel Mendoza-Jonas #define CLEAN_HPTE(_hpte) ((*(uint64_t *)(_hpte)) &= tswap64(~HPTE64_V_HPTE_DIRTY)) 1049e6b8fd24SSamuel Mendoza-Jonas #define DIRTY_HPTE(_hpte) ((*(uint64_t *)(_hpte)) |= tswap64(HPTE64_V_HPTE_DIRTY)) 1050e6b8fd24SSamuel Mendoza-Jonas 1051715c5407SDavid Gibson /* 1052715c5407SDavid Gibson * Get the fd to access the kernel htab, re-opening it if necessary 1053715c5407SDavid Gibson */ 1054715c5407SDavid Gibson static int get_htab_fd(sPAPRMachineState *spapr) 1055715c5407SDavid Gibson { 1056715c5407SDavid Gibson if (spapr->htab_fd >= 0) { 1057715c5407SDavid Gibson return spapr->htab_fd; 1058715c5407SDavid Gibson } 1059715c5407SDavid Gibson 1060715c5407SDavid Gibson spapr->htab_fd = kvmppc_get_htab_fd(false); 1061715c5407SDavid Gibson if (spapr->htab_fd < 0) { 1062715c5407SDavid Gibson error_report("Unable to open fd for reading hash table from KVM: %s", 1063715c5407SDavid Gibson strerror(errno)); 1064715c5407SDavid Gibson } 1065715c5407SDavid Gibson 1066715c5407SDavid Gibson return spapr->htab_fd; 1067715c5407SDavid Gibson } 1068715c5407SDavid Gibson 1069715c5407SDavid Gibson static void close_htab_fd(sPAPRMachineState *spapr) 1070715c5407SDavid Gibson { 1071715c5407SDavid Gibson if (spapr->htab_fd >= 0) { 1072715c5407SDavid Gibson close(spapr->htab_fd); 1073715c5407SDavid Gibson } 1074715c5407SDavid Gibson spapr->htab_fd = -1; 1075715c5407SDavid Gibson } 1076715c5407SDavid Gibson 1077e57ca75cSDavid Gibson static hwaddr spapr_hpt_mask(PPCVirtualHypervisor *vhyp) 1078e57ca75cSDavid Gibson { 1079e57ca75cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 1080e57ca75cSDavid Gibson 1081e57ca75cSDavid Gibson return HTAB_SIZE(spapr) / HASH_PTEG_SIZE_64 - 1; 1082e57ca75cSDavid Gibson } 1083e57ca75cSDavid Gibson 1084e57ca75cSDavid Gibson static const ppc_hash_pte64_t *spapr_map_hptes(PPCVirtualHypervisor *vhyp, 1085e57ca75cSDavid Gibson hwaddr ptex, int n) 1086e57ca75cSDavid Gibson { 1087e57ca75cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 1088e57ca75cSDavid Gibson hwaddr pte_offset = ptex * HASH_PTE_SIZE_64; 1089e57ca75cSDavid Gibson 1090e57ca75cSDavid Gibson if (!spapr->htab) { 1091e57ca75cSDavid Gibson /* 1092e57ca75cSDavid Gibson * HTAB is controlled by KVM. Fetch into temporary buffer 1093e57ca75cSDavid Gibson */ 1094e57ca75cSDavid Gibson ppc_hash_pte64_t *hptes = g_malloc(n * HASH_PTE_SIZE_64); 1095e57ca75cSDavid Gibson kvmppc_read_hptes(hptes, ptex, n); 1096e57ca75cSDavid Gibson return hptes; 1097e57ca75cSDavid Gibson } 1098e57ca75cSDavid Gibson 1099e57ca75cSDavid Gibson /* 1100e57ca75cSDavid Gibson * HTAB is controlled by QEMU. Just point to the internally 1101e57ca75cSDavid Gibson * accessible PTEG. 1102e57ca75cSDavid Gibson */ 1103e57ca75cSDavid Gibson return (const ppc_hash_pte64_t *)(spapr->htab + pte_offset); 1104e57ca75cSDavid Gibson } 1105e57ca75cSDavid Gibson 1106e57ca75cSDavid Gibson static void spapr_unmap_hptes(PPCVirtualHypervisor *vhyp, 1107e57ca75cSDavid Gibson const ppc_hash_pte64_t *hptes, 1108e57ca75cSDavid Gibson hwaddr ptex, int n) 1109e57ca75cSDavid Gibson { 1110e57ca75cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 1111e57ca75cSDavid Gibson 1112e57ca75cSDavid Gibson if (!spapr->htab) { 1113e57ca75cSDavid Gibson g_free((void *)hptes); 1114e57ca75cSDavid Gibson } 1115e57ca75cSDavid Gibson 1116e57ca75cSDavid Gibson /* Nothing to do for qemu managed HPT */ 1117e57ca75cSDavid Gibson } 1118e57ca75cSDavid Gibson 1119e57ca75cSDavid Gibson static void spapr_store_hpte(PPCVirtualHypervisor *vhyp, hwaddr ptex, 1120e57ca75cSDavid Gibson uint64_t pte0, uint64_t pte1) 1121e57ca75cSDavid Gibson { 1122e57ca75cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 1123e57ca75cSDavid Gibson hwaddr offset = ptex * HASH_PTE_SIZE_64; 1124e57ca75cSDavid Gibson 1125e57ca75cSDavid Gibson if (!spapr->htab) { 1126e57ca75cSDavid Gibson kvmppc_write_hpte(ptex, pte0, pte1); 1127e57ca75cSDavid Gibson } else { 1128e57ca75cSDavid Gibson stq_p(spapr->htab + offset, pte0); 1129e57ca75cSDavid Gibson stq_p(spapr->htab + offset + HASH_PTE_SIZE_64 / 2, pte1); 1130e57ca75cSDavid Gibson } 1131e57ca75cSDavid Gibson } 1132e57ca75cSDavid Gibson 11338dfe8e7fSDavid Gibson static int spapr_hpt_shift_for_ramsize(uint64_t ramsize) 11348dfe8e7fSDavid Gibson { 11358dfe8e7fSDavid Gibson int shift; 11368dfe8e7fSDavid Gibson 11378dfe8e7fSDavid Gibson /* We aim for a hash table of size 1/128 the size of RAM (rounded 11388dfe8e7fSDavid Gibson * up). The PAPR recommendation is actually 1/64 of RAM size, but 11398dfe8e7fSDavid Gibson * that's much more than is needed for Linux guests */ 11408dfe8e7fSDavid Gibson shift = ctz64(pow2ceil(ramsize)) - 7; 11418dfe8e7fSDavid Gibson shift = MAX(shift, 18); /* Minimum architected size */ 11428dfe8e7fSDavid Gibson shift = MIN(shift, 46); /* Maximum architected size */ 11438dfe8e7fSDavid Gibson return shift; 11448dfe8e7fSDavid Gibson } 11458dfe8e7fSDavid Gibson 1146c5f54f3eSDavid Gibson static void spapr_reallocate_hpt(sPAPRMachineState *spapr, int shift, 1147c5f54f3eSDavid Gibson Error **errp) 114853018216SPaolo Bonzini { 1149c5f54f3eSDavid Gibson long rc; 115053018216SPaolo Bonzini 1151c5f54f3eSDavid Gibson /* Clean up any HPT info from a previous boot */ 1152c5f54f3eSDavid Gibson g_free(spapr->htab); 1153c5f54f3eSDavid Gibson spapr->htab = NULL; 1154c5f54f3eSDavid Gibson spapr->htab_shift = 0; 1155c5f54f3eSDavid Gibson close_htab_fd(spapr); 115653018216SPaolo Bonzini 1157c5f54f3eSDavid Gibson rc = kvmppc_reset_htab(shift); 1158c5f54f3eSDavid Gibson if (rc < 0) { 1159c5f54f3eSDavid Gibson /* kernel-side HPT needed, but couldn't allocate one */ 1160c5f54f3eSDavid Gibson error_setg_errno(errp, errno, 1161c5f54f3eSDavid Gibson "Failed to allocate KVM HPT of order %d (try smaller maxmem?)", 1162c5f54f3eSDavid Gibson shift); 1163c5f54f3eSDavid Gibson /* This is almost certainly fatal, but if the caller really 1164c5f54f3eSDavid Gibson * wants to carry on with shift == 0, it's welcome to try */ 1165c5f54f3eSDavid Gibson } else if (rc > 0) { 1166c5f54f3eSDavid Gibson /* kernel-side HPT allocated */ 1167c5f54f3eSDavid Gibson if (rc != shift) { 1168c5f54f3eSDavid Gibson error_setg(errp, 1169c5f54f3eSDavid Gibson "Requested order %d HPT, but kernel allocated order %ld (try smaller maxmem?)", 1170c5f54f3eSDavid Gibson shift, rc); 11717735fedaSBharata B Rao } 11727735fedaSBharata B Rao 117353018216SPaolo Bonzini spapr->htab_shift = shift; 1174c18ad9a5SDavid Gibson spapr->htab = NULL; 1175b817772aSBharata B Rao } else { 1176c5f54f3eSDavid Gibson /* kernel-side HPT not needed, allocate in userspace instead */ 1177c5f54f3eSDavid Gibson size_t size = 1ULL << shift; 1178c5f54f3eSDavid Gibson int i; 117901a57972SSamuel Mendoza-Jonas 1180c5f54f3eSDavid Gibson spapr->htab = qemu_memalign(size, size); 1181c5f54f3eSDavid Gibson if (!spapr->htab) { 1182c5f54f3eSDavid Gibson error_setg_errno(errp, errno, 1183c5f54f3eSDavid Gibson "Could not allocate HPT of order %d", shift); 1184c5f54f3eSDavid Gibson return; 1185b817772aSBharata B Rao } 1186b817772aSBharata B Rao 1187c5f54f3eSDavid Gibson memset(spapr->htab, 0, size); 1188c5f54f3eSDavid Gibson spapr->htab_shift = shift; 1189b817772aSBharata B Rao 1190c5f54f3eSDavid Gibson for (i = 0; i < size / HASH_PTE_SIZE_64; i++) { 1191c5f54f3eSDavid Gibson DIRTY_HPTE(HPTE(spapr->htab, i)); 11927735fedaSBharata B Rao } 119353018216SPaolo Bonzini } 119453018216SPaolo Bonzini } 119553018216SPaolo Bonzini 11964f01a637SDavid Gibson static void find_unknown_sysbus_device(SysBusDevice *sbdev, void *opaque) 11979e3f9733SAlexander Graf { 11989e3f9733SAlexander Graf bool matched = false; 11999e3f9733SAlexander Graf 12009e3f9733SAlexander Graf if (object_dynamic_cast(OBJECT(sbdev), TYPE_SPAPR_PCI_HOST_BRIDGE)) { 12019e3f9733SAlexander Graf matched = true; 12029e3f9733SAlexander Graf } 12039e3f9733SAlexander Graf 12049e3f9733SAlexander Graf if (!matched) { 12059e3f9733SAlexander Graf error_report("Device %s is not supported by this machine yet.", 12069e3f9733SAlexander Graf qdev_fw_name(DEVICE(sbdev))); 12079e3f9733SAlexander Graf exit(1); 12089e3f9733SAlexander Graf } 12099e3f9733SAlexander Graf } 12109e3f9733SAlexander Graf 121153018216SPaolo Bonzini static void ppc_spapr_reset(void) 121253018216SPaolo Bonzini { 1213c5f54f3eSDavid Gibson MachineState *machine = MACHINE(qdev_get_machine()); 1214c5f54f3eSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(machine); 1215182735efSAndreas Färber PowerPCCPU *first_ppc_cpu; 1216b7d1f77aSBenjamin Herrenschmidt uint32_t rtas_limit; 1217cae172abSDavid Gibson hwaddr rtas_addr, fdt_addr; 1218997b6cfcSDavid Gibson void *fdt; 1219997b6cfcSDavid Gibson int rc; 1220259186a7SAndreas Färber 12219e3f9733SAlexander Graf /* Check for unknown sysbus devices */ 12229e3f9733SAlexander Graf foreach_dynamic_sysbus_device(find_unknown_sysbus_device, NULL); 12239e3f9733SAlexander Graf 1224c5f54f3eSDavid Gibson /* Allocate and/or reset the hash page table */ 1225c5f54f3eSDavid Gibson spapr_reallocate_hpt(spapr, 1226c5f54f3eSDavid Gibson spapr_hpt_shift_for_ramsize(machine->maxram_size), 1227c5f54f3eSDavid Gibson &error_fatal); 1228c5f54f3eSDavid Gibson 1229c5f54f3eSDavid Gibson /* Update the RMA size if necessary */ 1230c5f54f3eSDavid Gibson if (spapr->vrma_adjust) { 1231c5f54f3eSDavid Gibson spapr->rma_size = kvmppc_rma_size(spapr_node0_size(), 1232c5f54f3eSDavid Gibson spapr->htab_shift); 1233c5f54f3eSDavid Gibson } 123453018216SPaolo Bonzini 123553018216SPaolo Bonzini qemu_devices_reset(); 123653018216SPaolo Bonzini 1237b7d1f77aSBenjamin Herrenschmidt /* 1238b7d1f77aSBenjamin Herrenschmidt * We place the device tree and RTAS just below either the top of the RMA, 1239b7d1f77aSBenjamin Herrenschmidt * or just below 2GB, whichever is lowere, so that it can be 1240b7d1f77aSBenjamin Herrenschmidt * processed with 32-bit real mode code if necessary 1241b7d1f77aSBenjamin Herrenschmidt */ 1242b7d1f77aSBenjamin Herrenschmidt rtas_limit = MIN(spapr->rma_size, RTAS_MAX_ADDR); 1243cae172abSDavid Gibson rtas_addr = rtas_limit - RTAS_MAX_SIZE; 1244cae172abSDavid Gibson fdt_addr = rtas_addr - FDT_MAX_SIZE; 1245b7d1f77aSBenjamin Herrenschmidt 12466787d27bSMichael Roth /* if this reset wasn't generated by CAS, we should reset our 12476787d27bSMichael Roth * negotiated options and start from scratch */ 12486787d27bSMichael Roth if (!spapr->cas_reboot) { 12496787d27bSMichael Roth spapr_ovec_cleanup(spapr->ov5_cas); 12506787d27bSMichael Roth spapr->ov5_cas = spapr_ovec_new(); 12516787d27bSMichael Roth } 12526787d27bSMichael Roth 1253cae172abSDavid Gibson fdt = spapr_build_fdt(spapr, rtas_addr, spapr->rtas_size); 125453018216SPaolo Bonzini 12552cac78c1SDavid Gibson spapr_load_rtas(spapr, fdt, rtas_addr); 1256b7d1f77aSBenjamin Herrenschmidt 1257997b6cfcSDavid Gibson rc = fdt_pack(fdt); 1258997b6cfcSDavid Gibson 1259997b6cfcSDavid Gibson /* Should only fail if we've built a corrupted tree */ 1260997b6cfcSDavid Gibson assert(rc == 0); 1261997b6cfcSDavid Gibson 1262997b6cfcSDavid Gibson if (fdt_totalsize(fdt) > FDT_MAX_SIZE) { 1263997b6cfcSDavid Gibson error_report("FDT too big ! 0x%x bytes (max is 0x%x)", 1264997b6cfcSDavid Gibson fdt_totalsize(fdt), FDT_MAX_SIZE); 1265997b6cfcSDavid Gibson exit(1); 1266997b6cfcSDavid Gibson } 1267997b6cfcSDavid Gibson 1268997b6cfcSDavid Gibson /* Load the fdt */ 1269997b6cfcSDavid Gibson qemu_fdt_dumpdtb(fdt, fdt_totalsize(fdt)); 1270cae172abSDavid Gibson cpu_physical_memory_write(fdt_addr, fdt, fdt_totalsize(fdt)); 1271997b6cfcSDavid Gibson g_free(fdt); 1272997b6cfcSDavid Gibson 127353018216SPaolo Bonzini /* Set up the entry state */ 1274182735efSAndreas Färber first_ppc_cpu = POWERPC_CPU(first_cpu); 1275cae172abSDavid Gibson first_ppc_cpu->env.gpr[3] = fdt_addr; 1276182735efSAndreas Färber first_ppc_cpu->env.gpr[5] = 0; 1277182735efSAndreas Färber first_cpu->halted = 0; 12781b718907SDavid Gibson first_ppc_cpu->env.nip = SPAPR_ENTRY_POINT; 127953018216SPaolo Bonzini 12806787d27bSMichael Roth spapr->cas_reboot = false; 128153018216SPaolo Bonzini } 128253018216SPaolo Bonzini 128328e02042SDavid Gibson static void spapr_create_nvram(sPAPRMachineState *spapr) 128453018216SPaolo Bonzini { 12852ff3de68SMarkus Armbruster DeviceState *dev = qdev_create(&spapr->vio_bus->bus, "spapr-nvram"); 12863978b863SPaolo Bonzini DriveInfo *dinfo = drive_get(IF_PFLASH, 0, 0); 128753018216SPaolo Bonzini 12883978b863SPaolo Bonzini if (dinfo) { 12896231a6daSMarkus Armbruster qdev_prop_set_drive(dev, "drive", blk_by_legacy_dinfo(dinfo), 12906231a6daSMarkus Armbruster &error_fatal); 129153018216SPaolo Bonzini } 129253018216SPaolo Bonzini 129353018216SPaolo Bonzini qdev_init_nofail(dev); 129453018216SPaolo Bonzini 129553018216SPaolo Bonzini spapr->nvram = (struct sPAPRNVRAM *)dev; 129653018216SPaolo Bonzini } 129753018216SPaolo Bonzini 129828e02042SDavid Gibson static void spapr_rtc_create(sPAPRMachineState *spapr) 129928df36a1SDavid Gibson { 130028df36a1SDavid Gibson DeviceState *dev = qdev_create(NULL, TYPE_SPAPR_RTC); 130128df36a1SDavid Gibson 130228df36a1SDavid Gibson qdev_init_nofail(dev); 130328df36a1SDavid Gibson spapr->rtc = dev; 130474e5ae28SDavid Gibson 130574e5ae28SDavid Gibson object_property_add_alias(qdev_get_machine(), "rtc-time", 130674e5ae28SDavid Gibson OBJECT(spapr->rtc), "date", NULL); 130728df36a1SDavid Gibson } 130828df36a1SDavid Gibson 130953018216SPaolo Bonzini /* Returns whether we want to use VGA or not */ 131014c6a894SDavid Gibson static bool spapr_vga_init(PCIBus *pci_bus, Error **errp) 131153018216SPaolo Bonzini { 131253018216SPaolo Bonzini switch (vga_interface_type) { 131353018216SPaolo Bonzini case VGA_NONE: 13147effdaa3SMark Wu return false; 13157effdaa3SMark Wu case VGA_DEVICE: 13167effdaa3SMark Wu return true; 131753018216SPaolo Bonzini case VGA_STD: 1318b798c190SBenjamin Herrenschmidt case VGA_VIRTIO: 131953018216SPaolo Bonzini return pci_vga_init(pci_bus) != NULL; 132053018216SPaolo Bonzini default: 132114c6a894SDavid Gibson error_setg(errp, 132214c6a894SDavid Gibson "Unsupported VGA mode, only -vga std or -vga virtio is supported"); 132314c6a894SDavid Gibson return false; 132453018216SPaolo Bonzini } 132553018216SPaolo Bonzini } 132653018216SPaolo Bonzini 1327880ae7deSDavid Gibson static int spapr_post_load(void *opaque, int version_id) 1328880ae7deSDavid Gibson { 132928e02042SDavid Gibson sPAPRMachineState *spapr = (sPAPRMachineState *)opaque; 1330880ae7deSDavid Gibson int err = 0; 1331880ae7deSDavid Gibson 1332631b22eaSStefan Weil /* In earlier versions, there was no separate qdev for the PAPR 1333880ae7deSDavid Gibson * RTC, so the RTC offset was stored directly in sPAPREnvironment. 1334880ae7deSDavid Gibson * So when migrating from those versions, poke the incoming offset 1335880ae7deSDavid Gibson * value into the RTC device */ 1336880ae7deSDavid Gibson if (version_id < 3) { 1337880ae7deSDavid Gibson err = spapr_rtc_import_offset(spapr->rtc, spapr->rtc_offset); 1338880ae7deSDavid Gibson } 1339880ae7deSDavid Gibson 1340880ae7deSDavid Gibson return err; 1341880ae7deSDavid Gibson } 1342880ae7deSDavid Gibson 1343880ae7deSDavid Gibson static bool version_before_3(void *opaque, int version_id) 1344880ae7deSDavid Gibson { 1345880ae7deSDavid Gibson return version_id < 3; 1346880ae7deSDavid Gibson } 1347880ae7deSDavid Gibson 134862ef3760SMichael Roth static bool spapr_ov5_cas_needed(void *opaque) 134962ef3760SMichael Roth { 135062ef3760SMichael Roth sPAPRMachineState *spapr = opaque; 135162ef3760SMichael Roth sPAPROptionVector *ov5_mask = spapr_ovec_new(); 135262ef3760SMichael Roth sPAPROptionVector *ov5_legacy = spapr_ovec_new(); 135362ef3760SMichael Roth sPAPROptionVector *ov5_removed = spapr_ovec_new(); 135462ef3760SMichael Roth bool cas_needed; 135562ef3760SMichael Roth 135662ef3760SMichael Roth /* Prior to the introduction of sPAPROptionVector, we had two option 135762ef3760SMichael Roth * vectors we dealt with: OV5_FORM1_AFFINITY, and OV5_DRCONF_MEMORY. 135862ef3760SMichael Roth * Both of these options encode machine topology into the device-tree 135962ef3760SMichael Roth * in such a way that the now-booted OS should still be able to interact 136062ef3760SMichael Roth * appropriately with QEMU regardless of what options were actually 136162ef3760SMichael Roth * negotiatied on the source side. 136262ef3760SMichael Roth * 136362ef3760SMichael Roth * As such, we can avoid migrating the CAS-negotiated options if these 136462ef3760SMichael Roth * are the only options available on the current machine/platform. 136562ef3760SMichael Roth * Since these are the only options available for pseries-2.7 and 136662ef3760SMichael Roth * earlier, this allows us to maintain old->new/new->old migration 136762ef3760SMichael Roth * compatibility. 136862ef3760SMichael Roth * 136962ef3760SMichael Roth * For QEMU 2.8+, there are additional CAS-negotiatable options available 137062ef3760SMichael Roth * via default pseries-2.8 machines and explicit command-line parameters. 137162ef3760SMichael Roth * Some of these options, like OV5_HP_EVT, *do* require QEMU to be aware 137262ef3760SMichael Roth * of the actual CAS-negotiated values to continue working properly. For 137362ef3760SMichael Roth * example, availability of memory unplug depends on knowing whether 137462ef3760SMichael Roth * OV5_HP_EVT was negotiated via CAS. 137562ef3760SMichael Roth * 137662ef3760SMichael Roth * Thus, for any cases where the set of available CAS-negotiatable 137762ef3760SMichael Roth * options extends beyond OV5_FORM1_AFFINITY and OV5_DRCONF_MEMORY, we 137862ef3760SMichael Roth * include the CAS-negotiated options in the migration stream. 137962ef3760SMichael Roth */ 138062ef3760SMichael Roth spapr_ovec_set(ov5_mask, OV5_FORM1_AFFINITY); 138162ef3760SMichael Roth spapr_ovec_set(ov5_mask, OV5_DRCONF_MEMORY); 138262ef3760SMichael Roth 138362ef3760SMichael Roth /* spapr_ovec_diff returns true if bits were removed. we avoid using 138462ef3760SMichael Roth * the mask itself since in the future it's possible "legacy" bits may be 138562ef3760SMichael Roth * removed via machine options, which could generate a false positive 138662ef3760SMichael Roth * that breaks migration. 138762ef3760SMichael Roth */ 138862ef3760SMichael Roth spapr_ovec_intersect(ov5_legacy, spapr->ov5, ov5_mask); 138962ef3760SMichael Roth cas_needed = spapr_ovec_diff(ov5_removed, spapr->ov5, ov5_legacy); 139062ef3760SMichael Roth 139162ef3760SMichael Roth spapr_ovec_cleanup(ov5_mask); 139262ef3760SMichael Roth spapr_ovec_cleanup(ov5_legacy); 139362ef3760SMichael Roth spapr_ovec_cleanup(ov5_removed); 139462ef3760SMichael Roth 139562ef3760SMichael Roth return cas_needed; 139662ef3760SMichael Roth } 139762ef3760SMichael Roth 139862ef3760SMichael Roth static const VMStateDescription vmstate_spapr_ov5_cas = { 139962ef3760SMichael Roth .name = "spapr_option_vector_ov5_cas", 140062ef3760SMichael Roth .version_id = 1, 140162ef3760SMichael Roth .minimum_version_id = 1, 140262ef3760SMichael Roth .needed = spapr_ov5_cas_needed, 140362ef3760SMichael Roth .fields = (VMStateField[]) { 140462ef3760SMichael Roth VMSTATE_STRUCT_POINTER_V(ov5_cas, sPAPRMachineState, 1, 140562ef3760SMichael Roth vmstate_spapr_ovec, sPAPROptionVector), 140662ef3760SMichael Roth VMSTATE_END_OF_LIST() 140762ef3760SMichael Roth }, 140862ef3760SMichael Roth }; 140962ef3760SMichael Roth 14104be21d56SDavid Gibson static const VMStateDescription vmstate_spapr = { 14114be21d56SDavid Gibson .name = "spapr", 1412880ae7deSDavid Gibson .version_id = 3, 14134be21d56SDavid Gibson .minimum_version_id = 1, 1414880ae7deSDavid Gibson .post_load = spapr_post_load, 14154be21d56SDavid Gibson .fields = (VMStateField[]) { 1416880ae7deSDavid Gibson /* used to be @next_irq */ 1417880ae7deSDavid Gibson VMSTATE_UNUSED_BUFFER(version_before_3, 0, 4), 14184be21d56SDavid Gibson 14194be21d56SDavid Gibson /* RTC offset */ 142028e02042SDavid Gibson VMSTATE_UINT64_TEST(rtc_offset, sPAPRMachineState, version_before_3), 1421880ae7deSDavid Gibson 142228e02042SDavid Gibson VMSTATE_PPC_TIMEBASE_V(tb, sPAPRMachineState, 2), 14234be21d56SDavid Gibson VMSTATE_END_OF_LIST() 14244be21d56SDavid Gibson }, 142562ef3760SMichael Roth .subsections = (const VMStateDescription*[]) { 142662ef3760SMichael Roth &vmstate_spapr_ov5_cas, 142762ef3760SMichael Roth NULL 142862ef3760SMichael Roth } 14294be21d56SDavid Gibson }; 14304be21d56SDavid Gibson 14314be21d56SDavid Gibson static int htab_save_setup(QEMUFile *f, void *opaque) 14324be21d56SDavid Gibson { 143328e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 14344be21d56SDavid Gibson 14354be21d56SDavid Gibson /* "Iteration" header */ 14364be21d56SDavid Gibson qemu_put_be32(f, spapr->htab_shift); 14374be21d56SDavid Gibson 1438e68cb8b4SAlexey Kardashevskiy if (spapr->htab) { 1439e68cb8b4SAlexey Kardashevskiy spapr->htab_save_index = 0; 1440e68cb8b4SAlexey Kardashevskiy spapr->htab_first_pass = true; 1441e68cb8b4SAlexey Kardashevskiy } else { 1442e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 14434be21d56SDavid Gibson } 14444be21d56SDavid Gibson 1445e68cb8b4SAlexey Kardashevskiy 1446e68cb8b4SAlexey Kardashevskiy return 0; 1447e68cb8b4SAlexey Kardashevskiy } 14484be21d56SDavid Gibson 144928e02042SDavid Gibson static void htab_save_first_pass(QEMUFile *f, sPAPRMachineState *spapr, 14504be21d56SDavid Gibson int64_t max_ns) 14514be21d56SDavid Gibson { 1452378bc217SDavid Gibson bool has_timeout = max_ns != -1; 14534be21d56SDavid Gibson int htabslots = HTAB_SIZE(spapr) / HASH_PTE_SIZE_64; 14544be21d56SDavid Gibson int index = spapr->htab_save_index; 1455bc72ad67SAlex Bligh int64_t starttime = qemu_clock_get_ns(QEMU_CLOCK_REALTIME); 14564be21d56SDavid Gibson 14574be21d56SDavid Gibson assert(spapr->htab_first_pass); 14584be21d56SDavid Gibson 14594be21d56SDavid Gibson do { 14604be21d56SDavid Gibson int chunkstart; 14614be21d56SDavid Gibson 14624be21d56SDavid Gibson /* Consume invalid HPTEs */ 14634be21d56SDavid Gibson while ((index < htabslots) 14644be21d56SDavid Gibson && !HPTE_VALID(HPTE(spapr->htab, index))) { 14654be21d56SDavid Gibson index++; 14664be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 14674be21d56SDavid Gibson } 14684be21d56SDavid Gibson 14694be21d56SDavid Gibson /* Consume valid HPTEs */ 14704be21d56SDavid Gibson chunkstart = index; 1471338c25b6SSamuel Mendoza-Jonas while ((index < htabslots) && (index - chunkstart < USHRT_MAX) 14724be21d56SDavid Gibson && HPTE_VALID(HPTE(spapr->htab, index))) { 14734be21d56SDavid Gibson index++; 14744be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 14754be21d56SDavid Gibson } 14764be21d56SDavid Gibson 14774be21d56SDavid Gibson if (index > chunkstart) { 14784be21d56SDavid Gibson int n_valid = index - chunkstart; 14794be21d56SDavid Gibson 14804be21d56SDavid Gibson qemu_put_be32(f, chunkstart); 14814be21d56SDavid Gibson qemu_put_be16(f, n_valid); 14824be21d56SDavid Gibson qemu_put_be16(f, 0); 14834be21d56SDavid Gibson qemu_put_buffer(f, HPTE(spapr->htab, chunkstart), 14844be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_valid); 14854be21d56SDavid Gibson 1486378bc217SDavid Gibson if (has_timeout && 1487378bc217SDavid Gibson (qemu_clock_get_ns(QEMU_CLOCK_REALTIME) - starttime) > max_ns) { 14884be21d56SDavid Gibson break; 14894be21d56SDavid Gibson } 14904be21d56SDavid Gibson } 14914be21d56SDavid Gibson } while ((index < htabslots) && !qemu_file_rate_limit(f)); 14924be21d56SDavid Gibson 14934be21d56SDavid Gibson if (index >= htabslots) { 14944be21d56SDavid Gibson assert(index == htabslots); 14954be21d56SDavid Gibson index = 0; 14964be21d56SDavid Gibson spapr->htab_first_pass = false; 14974be21d56SDavid Gibson } 14984be21d56SDavid Gibson spapr->htab_save_index = index; 14994be21d56SDavid Gibson } 15004be21d56SDavid Gibson 150128e02042SDavid Gibson static int htab_save_later_pass(QEMUFile *f, sPAPRMachineState *spapr, 15024be21d56SDavid Gibson int64_t max_ns) 15034be21d56SDavid Gibson { 15044be21d56SDavid Gibson bool final = max_ns < 0; 15054be21d56SDavid Gibson int htabslots = HTAB_SIZE(spapr) / HASH_PTE_SIZE_64; 15064be21d56SDavid Gibson int examined = 0, sent = 0; 15074be21d56SDavid Gibson int index = spapr->htab_save_index; 1508bc72ad67SAlex Bligh int64_t starttime = qemu_clock_get_ns(QEMU_CLOCK_REALTIME); 15094be21d56SDavid Gibson 15104be21d56SDavid Gibson assert(!spapr->htab_first_pass); 15114be21d56SDavid Gibson 15124be21d56SDavid Gibson do { 15134be21d56SDavid Gibson int chunkstart, invalidstart; 15144be21d56SDavid Gibson 15154be21d56SDavid Gibson /* Consume non-dirty HPTEs */ 15164be21d56SDavid Gibson while ((index < htabslots) 15174be21d56SDavid Gibson && !HPTE_DIRTY(HPTE(spapr->htab, index))) { 15184be21d56SDavid Gibson index++; 15194be21d56SDavid Gibson examined++; 15204be21d56SDavid Gibson } 15214be21d56SDavid Gibson 15224be21d56SDavid Gibson chunkstart = index; 15234be21d56SDavid Gibson /* Consume valid dirty HPTEs */ 1524338c25b6SSamuel Mendoza-Jonas while ((index < htabslots) && (index - chunkstart < USHRT_MAX) 15254be21d56SDavid Gibson && HPTE_DIRTY(HPTE(spapr->htab, index)) 15264be21d56SDavid Gibson && HPTE_VALID(HPTE(spapr->htab, index))) { 15274be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 15284be21d56SDavid Gibson index++; 15294be21d56SDavid Gibson examined++; 15304be21d56SDavid Gibson } 15314be21d56SDavid Gibson 15324be21d56SDavid Gibson invalidstart = index; 15334be21d56SDavid Gibson /* Consume invalid dirty HPTEs */ 1534338c25b6SSamuel Mendoza-Jonas while ((index < htabslots) && (index - invalidstart < USHRT_MAX) 15354be21d56SDavid Gibson && HPTE_DIRTY(HPTE(spapr->htab, index)) 15364be21d56SDavid Gibson && !HPTE_VALID(HPTE(spapr->htab, index))) { 15374be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 15384be21d56SDavid Gibson index++; 15394be21d56SDavid Gibson examined++; 15404be21d56SDavid Gibson } 15414be21d56SDavid Gibson 15424be21d56SDavid Gibson if (index > chunkstart) { 15434be21d56SDavid Gibson int n_valid = invalidstart - chunkstart; 15444be21d56SDavid Gibson int n_invalid = index - invalidstart; 15454be21d56SDavid Gibson 15464be21d56SDavid Gibson qemu_put_be32(f, chunkstart); 15474be21d56SDavid Gibson qemu_put_be16(f, n_valid); 15484be21d56SDavid Gibson qemu_put_be16(f, n_invalid); 15494be21d56SDavid Gibson qemu_put_buffer(f, HPTE(spapr->htab, chunkstart), 15504be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_valid); 15514be21d56SDavid Gibson sent += index - chunkstart; 15524be21d56SDavid Gibson 1553bc72ad67SAlex Bligh if (!final && (qemu_clock_get_ns(QEMU_CLOCK_REALTIME) - starttime) > max_ns) { 15544be21d56SDavid Gibson break; 15554be21d56SDavid Gibson } 15564be21d56SDavid Gibson } 15574be21d56SDavid Gibson 15584be21d56SDavid Gibson if (examined >= htabslots) { 15594be21d56SDavid Gibson break; 15604be21d56SDavid Gibson } 15614be21d56SDavid Gibson 15624be21d56SDavid Gibson if (index >= htabslots) { 15634be21d56SDavid Gibson assert(index == htabslots); 15644be21d56SDavid Gibson index = 0; 15654be21d56SDavid Gibson } 15664be21d56SDavid Gibson } while ((examined < htabslots) && (!qemu_file_rate_limit(f) || final)); 15674be21d56SDavid Gibson 15684be21d56SDavid Gibson if (index >= htabslots) { 15694be21d56SDavid Gibson assert(index == htabslots); 15704be21d56SDavid Gibson index = 0; 15714be21d56SDavid Gibson } 15724be21d56SDavid Gibson 15734be21d56SDavid Gibson spapr->htab_save_index = index; 15744be21d56SDavid Gibson 1575e68cb8b4SAlexey Kardashevskiy return (examined >= htabslots) && (sent == 0) ? 1 : 0; 15764be21d56SDavid Gibson } 15774be21d56SDavid Gibson 1578e68cb8b4SAlexey Kardashevskiy #define MAX_ITERATION_NS 5000000 /* 5 ms */ 1579e68cb8b4SAlexey Kardashevskiy #define MAX_KVM_BUF_SIZE 2048 1580e68cb8b4SAlexey Kardashevskiy 15814be21d56SDavid Gibson static int htab_save_iterate(QEMUFile *f, void *opaque) 15824be21d56SDavid Gibson { 158328e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 1584715c5407SDavid Gibson int fd; 1585e68cb8b4SAlexey Kardashevskiy int rc = 0; 15864be21d56SDavid Gibson 15874be21d56SDavid Gibson /* Iteration header */ 15884be21d56SDavid Gibson qemu_put_be32(f, 0); 15894be21d56SDavid Gibson 1590e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1591e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 1592e68cb8b4SAlexey Kardashevskiy 1593715c5407SDavid Gibson fd = get_htab_fd(spapr); 1594715c5407SDavid Gibson if (fd < 0) { 1595715c5407SDavid Gibson return fd; 159601a57972SSamuel Mendoza-Jonas } 159701a57972SSamuel Mendoza-Jonas 1598715c5407SDavid Gibson rc = kvmppc_save_htab(f, fd, MAX_KVM_BUF_SIZE, MAX_ITERATION_NS); 1599e68cb8b4SAlexey Kardashevskiy if (rc < 0) { 1600e68cb8b4SAlexey Kardashevskiy return rc; 1601e68cb8b4SAlexey Kardashevskiy } 1602e68cb8b4SAlexey Kardashevskiy } else if (spapr->htab_first_pass) { 16034be21d56SDavid Gibson htab_save_first_pass(f, spapr, MAX_ITERATION_NS); 16044be21d56SDavid Gibson } else { 1605e68cb8b4SAlexey Kardashevskiy rc = htab_save_later_pass(f, spapr, MAX_ITERATION_NS); 16064be21d56SDavid Gibson } 16074be21d56SDavid Gibson 16084be21d56SDavid Gibson /* End marker */ 16094be21d56SDavid Gibson qemu_put_be32(f, 0); 16104be21d56SDavid Gibson qemu_put_be16(f, 0); 16114be21d56SDavid Gibson qemu_put_be16(f, 0); 16124be21d56SDavid Gibson 1613e68cb8b4SAlexey Kardashevskiy return rc; 16144be21d56SDavid Gibson } 16154be21d56SDavid Gibson 16164be21d56SDavid Gibson static int htab_save_complete(QEMUFile *f, void *opaque) 16174be21d56SDavid Gibson { 161828e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 1619715c5407SDavid Gibson int fd; 16204be21d56SDavid Gibson 16214be21d56SDavid Gibson /* Iteration header */ 16224be21d56SDavid Gibson qemu_put_be32(f, 0); 16234be21d56SDavid Gibson 1624e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1625e68cb8b4SAlexey Kardashevskiy int rc; 1626e68cb8b4SAlexey Kardashevskiy 1627e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 1628e68cb8b4SAlexey Kardashevskiy 1629715c5407SDavid Gibson fd = get_htab_fd(spapr); 1630715c5407SDavid Gibson if (fd < 0) { 1631715c5407SDavid Gibson return fd; 163201a57972SSamuel Mendoza-Jonas } 163301a57972SSamuel Mendoza-Jonas 1634715c5407SDavid Gibson rc = kvmppc_save_htab(f, fd, MAX_KVM_BUF_SIZE, -1); 1635e68cb8b4SAlexey Kardashevskiy if (rc < 0) { 1636e68cb8b4SAlexey Kardashevskiy return rc; 1637e68cb8b4SAlexey Kardashevskiy } 1638e68cb8b4SAlexey Kardashevskiy } else { 1639378bc217SDavid Gibson if (spapr->htab_first_pass) { 1640378bc217SDavid Gibson htab_save_first_pass(f, spapr, -1); 1641378bc217SDavid Gibson } 16424be21d56SDavid Gibson htab_save_later_pass(f, spapr, -1); 1643e68cb8b4SAlexey Kardashevskiy } 16444be21d56SDavid Gibson 16454be21d56SDavid Gibson /* End marker */ 16464be21d56SDavid Gibson qemu_put_be32(f, 0); 16474be21d56SDavid Gibson qemu_put_be16(f, 0); 16484be21d56SDavid Gibson qemu_put_be16(f, 0); 16494be21d56SDavid Gibson 16504be21d56SDavid Gibson return 0; 16514be21d56SDavid Gibson } 16524be21d56SDavid Gibson 16534be21d56SDavid Gibson static int htab_load(QEMUFile *f, void *opaque, int version_id) 16544be21d56SDavid Gibson { 165528e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 16564be21d56SDavid Gibson uint32_t section_hdr; 1657e68cb8b4SAlexey Kardashevskiy int fd = -1; 16584be21d56SDavid Gibson 16594be21d56SDavid Gibson if (version_id < 1 || version_id > 1) { 166098a5d100SDavid Gibson error_report("htab_load() bad version"); 16614be21d56SDavid Gibson return -EINVAL; 16624be21d56SDavid Gibson } 16634be21d56SDavid Gibson 16644be21d56SDavid Gibson section_hdr = qemu_get_be32(f); 16654be21d56SDavid Gibson 16664be21d56SDavid Gibson if (section_hdr) { 16679897e462SGreg Kurz Error *local_err = NULL; 1668c5f54f3eSDavid Gibson 1669c5f54f3eSDavid Gibson /* First section gives the htab size */ 1670c5f54f3eSDavid Gibson spapr_reallocate_hpt(spapr, section_hdr, &local_err); 1671c5f54f3eSDavid Gibson if (local_err) { 1672c5f54f3eSDavid Gibson error_report_err(local_err); 16734be21d56SDavid Gibson return -EINVAL; 16744be21d56SDavid Gibson } 16754be21d56SDavid Gibson return 0; 16764be21d56SDavid Gibson } 16774be21d56SDavid Gibson 1678e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1679e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 1680e68cb8b4SAlexey Kardashevskiy 1681e68cb8b4SAlexey Kardashevskiy fd = kvmppc_get_htab_fd(true); 1682e68cb8b4SAlexey Kardashevskiy if (fd < 0) { 168398a5d100SDavid Gibson error_report("Unable to open fd to restore KVM hash table: %s", 1684e68cb8b4SAlexey Kardashevskiy strerror(errno)); 1685e68cb8b4SAlexey Kardashevskiy } 1686e68cb8b4SAlexey Kardashevskiy } 1687e68cb8b4SAlexey Kardashevskiy 16884be21d56SDavid Gibson while (true) { 16894be21d56SDavid Gibson uint32_t index; 16904be21d56SDavid Gibson uint16_t n_valid, n_invalid; 16914be21d56SDavid Gibson 16924be21d56SDavid Gibson index = qemu_get_be32(f); 16934be21d56SDavid Gibson n_valid = qemu_get_be16(f); 16944be21d56SDavid Gibson n_invalid = qemu_get_be16(f); 16954be21d56SDavid Gibson 16964be21d56SDavid Gibson if ((index == 0) && (n_valid == 0) && (n_invalid == 0)) { 16974be21d56SDavid Gibson /* End of Stream */ 16984be21d56SDavid Gibson break; 16994be21d56SDavid Gibson } 17004be21d56SDavid Gibson 1701e68cb8b4SAlexey Kardashevskiy if ((index + n_valid + n_invalid) > 17024be21d56SDavid Gibson (HTAB_SIZE(spapr) / HASH_PTE_SIZE_64)) { 17034be21d56SDavid Gibson /* Bad index in stream */ 170498a5d100SDavid Gibson error_report( 170598a5d100SDavid Gibson "htab_load() bad index %d (%hd+%hd entries) in htab stream (htab_shift=%d)", 170698a5d100SDavid Gibson index, n_valid, n_invalid, spapr->htab_shift); 17074be21d56SDavid Gibson return -EINVAL; 17084be21d56SDavid Gibson } 17094be21d56SDavid Gibson 1710e68cb8b4SAlexey Kardashevskiy if (spapr->htab) { 17114be21d56SDavid Gibson if (n_valid) { 17124be21d56SDavid Gibson qemu_get_buffer(f, HPTE(spapr->htab, index), 17134be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_valid); 17144be21d56SDavid Gibson } 17154be21d56SDavid Gibson if (n_invalid) { 17164be21d56SDavid Gibson memset(HPTE(spapr->htab, index + n_valid), 0, 17174be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_invalid); 17184be21d56SDavid Gibson } 1719e68cb8b4SAlexey Kardashevskiy } else { 1720e68cb8b4SAlexey Kardashevskiy int rc; 1721e68cb8b4SAlexey Kardashevskiy 1722e68cb8b4SAlexey Kardashevskiy assert(fd >= 0); 1723e68cb8b4SAlexey Kardashevskiy 1724e68cb8b4SAlexey Kardashevskiy rc = kvmppc_load_htab_chunk(f, fd, index, n_valid, n_invalid); 1725e68cb8b4SAlexey Kardashevskiy if (rc < 0) { 1726e68cb8b4SAlexey Kardashevskiy return rc; 1727e68cb8b4SAlexey Kardashevskiy } 1728e68cb8b4SAlexey Kardashevskiy } 1729e68cb8b4SAlexey Kardashevskiy } 1730e68cb8b4SAlexey Kardashevskiy 1731e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1732e68cb8b4SAlexey Kardashevskiy assert(fd >= 0); 1733e68cb8b4SAlexey Kardashevskiy close(fd); 17344be21d56SDavid Gibson } 17354be21d56SDavid Gibson 17364be21d56SDavid Gibson return 0; 17374be21d56SDavid Gibson } 17384be21d56SDavid Gibson 1739c573fc03SThomas Huth static void htab_cleanup(void *opaque) 1740c573fc03SThomas Huth { 1741c573fc03SThomas Huth sPAPRMachineState *spapr = opaque; 1742c573fc03SThomas Huth 1743c573fc03SThomas Huth close_htab_fd(spapr); 1744c573fc03SThomas Huth } 1745c573fc03SThomas Huth 17464be21d56SDavid Gibson static SaveVMHandlers savevm_htab_handlers = { 17474be21d56SDavid Gibson .save_live_setup = htab_save_setup, 17484be21d56SDavid Gibson .save_live_iterate = htab_save_iterate, 1749a3e06c3dSDr. David Alan Gilbert .save_live_complete_precopy = htab_save_complete, 1750c573fc03SThomas Huth .cleanup = htab_cleanup, 17514be21d56SDavid Gibson .load_state = htab_load, 17524be21d56SDavid Gibson }; 17534be21d56SDavid Gibson 17545b2128d2SAlexander Graf static void spapr_boot_set(void *opaque, const char *boot_device, 17555b2128d2SAlexander Graf Error **errp) 17565b2128d2SAlexander Graf { 17575b2128d2SAlexander Graf MachineState *machine = MACHINE(qdev_get_machine()); 17585b2128d2SAlexander Graf machine->boot_order = g_strdup(boot_device); 17595b2128d2SAlexander Graf } 17605b2128d2SAlexander Graf 1761224245bfSDavid Gibson /* 1762224245bfSDavid Gibson * Reset routine for LMB DR devices. 1763224245bfSDavid Gibson * 1764224245bfSDavid Gibson * Unlike PCI DR devices, LMB DR devices explicitly register this reset 1765224245bfSDavid Gibson * routine. Reset for PCI DR devices will be handled by PHB reset routine 1766224245bfSDavid Gibson * when it walks all its children devices. LMB devices reset occurs 1767224245bfSDavid Gibson * as part of spapr_ppc_reset(). 1768224245bfSDavid Gibson */ 1769224245bfSDavid Gibson static void spapr_drc_reset(void *opaque) 1770224245bfSDavid Gibson { 1771224245bfSDavid Gibson sPAPRDRConnector *drc = opaque; 1772224245bfSDavid Gibson DeviceState *d = DEVICE(drc); 1773224245bfSDavid Gibson 1774224245bfSDavid Gibson if (d) { 1775224245bfSDavid Gibson device_reset(d); 1776224245bfSDavid Gibson } 1777224245bfSDavid Gibson } 1778224245bfSDavid Gibson 1779224245bfSDavid Gibson static void spapr_create_lmb_dr_connectors(sPAPRMachineState *spapr) 1780224245bfSDavid Gibson { 1781224245bfSDavid Gibson MachineState *machine = MACHINE(spapr); 1782224245bfSDavid Gibson uint64_t lmb_size = SPAPR_MEMORY_BLOCK_SIZE; 1783e8f986fcSBharata B Rao uint32_t nr_lmbs = (machine->maxram_size - machine->ram_size)/lmb_size; 1784224245bfSDavid Gibson int i; 1785224245bfSDavid Gibson 1786224245bfSDavid Gibson for (i = 0; i < nr_lmbs; i++) { 1787224245bfSDavid Gibson sPAPRDRConnector *drc; 1788224245bfSDavid Gibson uint64_t addr; 1789224245bfSDavid Gibson 1790e8f986fcSBharata B Rao addr = i * lmb_size + spapr->hotplug_memory.base; 1791224245bfSDavid Gibson drc = spapr_dr_connector_new(OBJECT(spapr), SPAPR_DR_CONNECTOR_TYPE_LMB, 1792224245bfSDavid Gibson addr/lmb_size); 1793224245bfSDavid Gibson qemu_register_reset(spapr_drc_reset, drc); 1794224245bfSDavid Gibson } 1795224245bfSDavid Gibson } 1796224245bfSDavid Gibson 1797224245bfSDavid Gibson /* 1798224245bfSDavid Gibson * If RAM size, maxmem size and individual node mem sizes aren't aligned 1799224245bfSDavid Gibson * to SPAPR_MEMORY_BLOCK_SIZE(256MB), then refuse to start the guest 1800224245bfSDavid Gibson * since we can't support such unaligned sizes with DRCONF_MEMORY. 1801224245bfSDavid Gibson */ 18027c150d6fSDavid Gibson static void spapr_validate_node_memory(MachineState *machine, Error **errp) 1803224245bfSDavid Gibson { 1804224245bfSDavid Gibson int i; 1805224245bfSDavid Gibson 18067c150d6fSDavid Gibson if (machine->ram_size % SPAPR_MEMORY_BLOCK_SIZE) { 18077c150d6fSDavid Gibson error_setg(errp, "Memory size 0x" RAM_ADDR_FMT 18087c150d6fSDavid Gibson " is not aligned to %llu MiB", 18097c150d6fSDavid Gibson machine->ram_size, 1810224245bfSDavid Gibson SPAPR_MEMORY_BLOCK_SIZE / M_BYTE); 18117c150d6fSDavid Gibson return; 18127c150d6fSDavid Gibson } 18137c150d6fSDavid Gibson 18147c150d6fSDavid Gibson if (machine->maxram_size % SPAPR_MEMORY_BLOCK_SIZE) { 18157c150d6fSDavid Gibson error_setg(errp, "Maximum memory size 0x" RAM_ADDR_FMT 18167c150d6fSDavid Gibson " is not aligned to %llu MiB", 18177c150d6fSDavid Gibson machine->ram_size, 18187c150d6fSDavid Gibson SPAPR_MEMORY_BLOCK_SIZE / M_BYTE); 18197c150d6fSDavid Gibson return; 1820224245bfSDavid Gibson } 1821224245bfSDavid Gibson 1822224245bfSDavid Gibson for (i = 0; i < nb_numa_nodes; i++) { 1823224245bfSDavid Gibson if (numa_info[i].node_mem % SPAPR_MEMORY_BLOCK_SIZE) { 18247c150d6fSDavid Gibson error_setg(errp, 18257c150d6fSDavid Gibson "Node %d memory size 0x%" PRIx64 18267c150d6fSDavid Gibson " is not aligned to %llu MiB", 18277c150d6fSDavid Gibson i, numa_info[i].node_mem, 1828224245bfSDavid Gibson SPAPR_MEMORY_BLOCK_SIZE / M_BYTE); 18297c150d6fSDavid Gibson return; 1830224245bfSDavid Gibson } 1831224245bfSDavid Gibson } 1832224245bfSDavid Gibson } 1833224245bfSDavid Gibson 1834535455fdSIgor Mammedov /* find cpu slot in machine->possible_cpus by core_id */ 1835535455fdSIgor Mammedov static CPUArchId *spapr_find_cpu_slot(MachineState *ms, uint32_t id, int *idx) 1836535455fdSIgor Mammedov { 1837535455fdSIgor Mammedov int index = id / smp_threads; 1838535455fdSIgor Mammedov 1839535455fdSIgor Mammedov if (index >= ms->possible_cpus->len) { 1840535455fdSIgor Mammedov return NULL; 1841535455fdSIgor Mammedov } 1842535455fdSIgor Mammedov if (idx) { 1843535455fdSIgor Mammedov *idx = index; 1844535455fdSIgor Mammedov } 1845535455fdSIgor Mammedov return &ms->possible_cpus->cpus[index]; 1846535455fdSIgor Mammedov } 1847535455fdSIgor Mammedov 18480c86d0fdSDavid Gibson static void spapr_init_cpus(sPAPRMachineState *spapr) 18490c86d0fdSDavid Gibson { 18500c86d0fdSDavid Gibson MachineState *machine = MACHINE(spapr); 18510c86d0fdSDavid Gibson MachineClass *mc = MACHINE_GET_CLASS(machine); 18520c86d0fdSDavid Gibson char *type = spapr_get_cpu_core_type(machine->cpu_model); 18530c86d0fdSDavid Gibson int smt = kvmppc_smt_threads(); 1854535455fdSIgor Mammedov const CPUArchIdList *possible_cpus; 1855535455fdSIgor Mammedov int boot_cores_nr = smp_cpus / smp_threads; 18560c86d0fdSDavid Gibson int i; 18570c86d0fdSDavid Gibson 18580c86d0fdSDavid Gibson if (!type) { 18590c86d0fdSDavid Gibson error_report("Unable to find sPAPR CPU Core definition"); 18600c86d0fdSDavid Gibson exit(1); 18610c86d0fdSDavid Gibson } 18620c86d0fdSDavid Gibson 1863535455fdSIgor Mammedov possible_cpus = mc->possible_cpu_arch_ids(machine); 1864c5514d0eSIgor Mammedov if (mc->has_hotpluggable_cpus) { 18650c86d0fdSDavid Gibson if (smp_cpus % smp_threads) { 18660c86d0fdSDavid Gibson error_report("smp_cpus (%u) must be multiple of threads (%u)", 18670c86d0fdSDavid Gibson smp_cpus, smp_threads); 18680c86d0fdSDavid Gibson exit(1); 18690c86d0fdSDavid Gibson } 18700c86d0fdSDavid Gibson if (max_cpus % smp_threads) { 18710c86d0fdSDavid Gibson error_report("max_cpus (%u) must be multiple of threads (%u)", 18720c86d0fdSDavid Gibson max_cpus, smp_threads); 18730c86d0fdSDavid Gibson exit(1); 18740c86d0fdSDavid Gibson } 18750c86d0fdSDavid Gibson } else { 18760c86d0fdSDavid Gibson if (max_cpus != smp_cpus) { 18770c86d0fdSDavid Gibson error_report("This machine version does not support CPU hotplug"); 18780c86d0fdSDavid Gibson exit(1); 18790c86d0fdSDavid Gibson } 1880535455fdSIgor Mammedov boot_cores_nr = possible_cpus->len; 18810c86d0fdSDavid Gibson } 18820c86d0fdSDavid Gibson 1883535455fdSIgor Mammedov for (i = 0; i < possible_cpus->len; i++) { 18840c86d0fdSDavid Gibson int core_id = i * smp_threads; 18850c86d0fdSDavid Gibson 1886c5514d0eSIgor Mammedov if (mc->has_hotpluggable_cpus) { 18870c86d0fdSDavid Gibson sPAPRDRConnector *drc = 18880c86d0fdSDavid Gibson spapr_dr_connector_new(OBJECT(spapr), 18890c86d0fdSDavid Gibson SPAPR_DR_CONNECTOR_TYPE_CPU, 18900c86d0fdSDavid Gibson (core_id / smp_threads) * smt); 18910c86d0fdSDavid Gibson 18920c86d0fdSDavid Gibson qemu_register_reset(spapr_drc_reset, drc); 18930c86d0fdSDavid Gibson } 18940c86d0fdSDavid Gibson 1895535455fdSIgor Mammedov if (i < boot_cores_nr) { 18960c86d0fdSDavid Gibson Object *core = object_new(type); 18970c86d0fdSDavid Gibson int nr_threads = smp_threads; 18980c86d0fdSDavid Gibson 18990c86d0fdSDavid Gibson /* Handle the partially filled core for older machine types */ 19000c86d0fdSDavid Gibson if ((i + 1) * smp_threads >= smp_cpus) { 19010c86d0fdSDavid Gibson nr_threads = smp_cpus - i * smp_threads; 19020c86d0fdSDavid Gibson } 19030c86d0fdSDavid Gibson 19040c86d0fdSDavid Gibson object_property_set_int(core, nr_threads, "nr-threads", 19050c86d0fdSDavid Gibson &error_fatal); 19060c86d0fdSDavid Gibson object_property_set_int(core, core_id, CPU_CORE_PROP_CORE_ID, 19070c86d0fdSDavid Gibson &error_fatal); 19080c86d0fdSDavid Gibson object_property_set_bool(core, true, "realized", &error_fatal); 19090c86d0fdSDavid Gibson } 19100c86d0fdSDavid Gibson } 19110c86d0fdSDavid Gibson g_free(type); 19120c86d0fdSDavid Gibson } 19130c86d0fdSDavid Gibson 191453018216SPaolo Bonzini /* pSeries LPAR / sPAPR hardware init */ 19153ef96221SMarcel Apfelbaum static void ppc_spapr_init(MachineState *machine) 191653018216SPaolo Bonzini { 191728e02042SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(machine); 1918224245bfSDavid Gibson sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(machine); 19193ef96221SMarcel Apfelbaum const char *kernel_filename = machine->kernel_filename; 19203ef96221SMarcel Apfelbaum const char *initrd_filename = machine->initrd_filename; 192153018216SPaolo Bonzini PCIHostState *phb; 192253018216SPaolo Bonzini int i; 192353018216SPaolo Bonzini MemoryRegion *sysmem = get_system_memory(); 192453018216SPaolo Bonzini MemoryRegion *ram = g_new(MemoryRegion, 1); 1925658fa66bSAlexey Kardashevskiy MemoryRegion *rma_region; 1926658fa66bSAlexey Kardashevskiy void *rma = NULL; 192753018216SPaolo Bonzini hwaddr rma_alloc_size; 1928b082d65aSAlexey Kardashevskiy hwaddr node0_size = spapr_node0_size(); 1929b7d1f77aSBenjamin Herrenschmidt long load_limit, fw_size; 193053018216SPaolo Bonzini char *filename; 193194a94e4cSBharata B Rao int smt = kvmppc_smt_threads(); 193253018216SPaolo Bonzini 1933226419d6SMichael S. Tsirkin msi_nonbroken = true; 193453018216SPaolo Bonzini 193553018216SPaolo Bonzini QLIST_INIT(&spapr->phbs); 193653018216SPaolo Bonzini 193753018216SPaolo Bonzini /* Allocate RMA if necessary */ 1938658fa66bSAlexey Kardashevskiy rma_alloc_size = kvmppc_alloc_rma(&rma); 193953018216SPaolo Bonzini 194053018216SPaolo Bonzini if (rma_alloc_size == -1) { 1941730fce59SThomas Huth error_report("Unable to create RMA"); 194253018216SPaolo Bonzini exit(1); 194353018216SPaolo Bonzini } 194453018216SPaolo Bonzini 1945c4177479SAlexey Kardashevskiy if (rma_alloc_size && (rma_alloc_size < node0_size)) { 194653018216SPaolo Bonzini spapr->rma_size = rma_alloc_size; 194753018216SPaolo Bonzini } else { 1948c4177479SAlexey Kardashevskiy spapr->rma_size = node0_size; 194953018216SPaolo Bonzini 195053018216SPaolo Bonzini /* With KVM, we don't actually know whether KVM supports an 195153018216SPaolo Bonzini * unbounded RMA (PR KVM) or is limited by the hash table size 195253018216SPaolo Bonzini * (HV KVM using VRMA), so we always assume the latter 195353018216SPaolo Bonzini * 195453018216SPaolo Bonzini * In that case, we also limit the initial allocations for RTAS 195553018216SPaolo Bonzini * etc... to 256M since we have no way to know what the VRMA size 195653018216SPaolo Bonzini * is going to be as it depends on the size of the hash table 195753018216SPaolo Bonzini * isn't determined yet. 195853018216SPaolo Bonzini */ 195953018216SPaolo Bonzini if (kvm_enabled()) { 196053018216SPaolo Bonzini spapr->vrma_adjust = 1; 196153018216SPaolo Bonzini spapr->rma_size = MIN(spapr->rma_size, 0x10000000); 196253018216SPaolo Bonzini } 1963912acdf4SBenjamin Herrenschmidt 1964912acdf4SBenjamin Herrenschmidt /* Actually we don't support unbounded RMA anymore since we 1965912acdf4SBenjamin Herrenschmidt * added proper emulation of HV mode. The max we can get is 1966912acdf4SBenjamin Herrenschmidt * 16G which also happens to be what we configure for PAPR 1967912acdf4SBenjamin Herrenschmidt * mode so make sure we don't do anything bigger than that 1968912acdf4SBenjamin Herrenschmidt */ 1969912acdf4SBenjamin Herrenschmidt spapr->rma_size = MIN(spapr->rma_size, 0x400000000ull); 197053018216SPaolo Bonzini } 197153018216SPaolo Bonzini 1972c4177479SAlexey Kardashevskiy if (spapr->rma_size > node0_size) { 1973d54e4d76SDavid Gibson error_report("Numa node 0 has to span the RMA (%#08"HWADDR_PRIx")", 1974c4177479SAlexey Kardashevskiy spapr->rma_size); 1975c4177479SAlexey Kardashevskiy exit(1); 1976c4177479SAlexey Kardashevskiy } 1977c4177479SAlexey Kardashevskiy 1978b7d1f77aSBenjamin Herrenschmidt /* Setup a load limit for the ramdisk leaving room for SLOF and FDT */ 1979b7d1f77aSBenjamin Herrenschmidt load_limit = MIN(spapr->rma_size, RTAS_MAX_ADDR) - FW_OVERHEAD; 198053018216SPaolo Bonzini 19817b565160SDavid Gibson /* Set up Interrupt Controller before we create the VCPUs */ 198227f24582SBenjamin Herrenschmidt spapr->xics = xics_system_init(machine, 198394a94e4cSBharata B Rao DIV_ROUND_UP(max_cpus * smt, smp_threads), 1984161deaf2SBenjamin Herrenschmidt XICS_IRQS_SPAPR, &error_fatal); 19857b565160SDavid Gibson 1986facdb8b6SMichael Roth /* Set up containers for ibm,client-set-architecture negotiated options */ 1987facdb8b6SMichael Roth spapr->ov5 = spapr_ovec_new(); 1988facdb8b6SMichael Roth spapr->ov5_cas = spapr_ovec_new(); 1989facdb8b6SMichael Roth 1990224245bfSDavid Gibson if (smc->dr_lmb_enabled) { 1991facdb8b6SMichael Roth spapr_ovec_set(spapr->ov5, OV5_DRCONF_MEMORY); 19927c150d6fSDavid Gibson spapr_validate_node_memory(machine, &error_fatal); 1993224245bfSDavid Gibson } 1994224245bfSDavid Gibson 1995417ece33SMichael Roth spapr_ovec_set(spapr->ov5, OV5_FORM1_AFFINITY); 1996417ece33SMichael Roth 1997ffbb1705SMichael Roth /* advertise support for dedicated HP event source to guests */ 1998ffbb1705SMichael Roth if (spapr->use_hotplug_event_source) { 1999ffbb1705SMichael Roth spapr_ovec_set(spapr->ov5, OV5_HP_EVT); 2000ffbb1705SMichael Roth } 2001ffbb1705SMichael Roth 200253018216SPaolo Bonzini /* init CPUs */ 200319fb2c36SBharata B Rao if (machine->cpu_model == NULL) { 20043daa4a9fSThomas Huth machine->cpu_model = kvm_enabled() ? "host" : smc->tcg_default_cpu; 200553018216SPaolo Bonzini } 200694a94e4cSBharata B Rao 2007e703d2f7SGreg Kurz ppc_cpu_parse_features(machine->cpu_model); 2008e703d2f7SGreg Kurz 20090c86d0fdSDavid Gibson spapr_init_cpus(spapr); 201053018216SPaolo Bonzini 2011026bfd89SDavid Gibson if (kvm_enabled()) { 2012026bfd89SDavid Gibson /* Enable H_LOGICAL_CI_* so SLOF can talk to in-kernel devices */ 2013026bfd89SDavid Gibson kvmppc_enable_logical_ci_hcalls(); 2014ef9971ddSAlexey Kardashevskiy kvmppc_enable_set_mode_hcall(); 20155145ad4fSNathan Whitehorn 20165145ad4fSNathan Whitehorn /* H_CLEAR_MOD/_REF are mandatory in PAPR, but off by default */ 20175145ad4fSNathan Whitehorn kvmppc_enable_clear_ref_mod_hcalls(); 2018026bfd89SDavid Gibson } 2019026bfd89SDavid Gibson 202053018216SPaolo Bonzini /* allocate RAM */ 2021f92f5da1SAlexey Kardashevskiy memory_region_allocate_system_memory(ram, NULL, "ppc_spapr.ram", 2022fb164994SDavid Gibson machine->ram_size); 2023f92f5da1SAlexey Kardashevskiy memory_region_add_subregion(sysmem, 0, ram); 202453018216SPaolo Bonzini 2025658fa66bSAlexey Kardashevskiy if (rma_alloc_size && rma) { 2026658fa66bSAlexey Kardashevskiy rma_region = g_new(MemoryRegion, 1); 2027658fa66bSAlexey Kardashevskiy memory_region_init_ram_ptr(rma_region, NULL, "ppc_spapr.rma", 2028658fa66bSAlexey Kardashevskiy rma_alloc_size, rma); 2029658fa66bSAlexey Kardashevskiy vmstate_register_ram_global(rma_region); 2030658fa66bSAlexey Kardashevskiy memory_region_add_subregion(sysmem, 0, rma_region); 2031658fa66bSAlexey Kardashevskiy } 2032658fa66bSAlexey Kardashevskiy 20334a1c9cf0SBharata B Rao /* initialize hotplug memory address space */ 20344a1c9cf0SBharata B Rao if (machine->ram_size < machine->maxram_size) { 20354a1c9cf0SBharata B Rao ram_addr_t hotplug_mem_size = machine->maxram_size - machine->ram_size; 203671c9a3ddSBharata B Rao /* 203771c9a3ddSBharata B Rao * Limit the number of hotpluggable memory slots to half the number 203871c9a3ddSBharata B Rao * slots that KVM supports, leaving the other half for PCI and other 203971c9a3ddSBharata B Rao * devices. However ensure that number of slots doesn't drop below 32. 204071c9a3ddSBharata B Rao */ 204171c9a3ddSBharata B Rao int max_memslots = kvm_enabled() ? kvm_get_max_memslots() / 2 : 204271c9a3ddSBharata B Rao SPAPR_MAX_RAM_SLOTS; 20434a1c9cf0SBharata B Rao 204471c9a3ddSBharata B Rao if (max_memslots < SPAPR_MAX_RAM_SLOTS) { 204571c9a3ddSBharata B Rao max_memslots = SPAPR_MAX_RAM_SLOTS; 204671c9a3ddSBharata B Rao } 204771c9a3ddSBharata B Rao if (machine->ram_slots > max_memslots) { 2048d54e4d76SDavid Gibson error_report("Specified number of memory slots %" 2049d54e4d76SDavid Gibson PRIu64" exceeds max supported %d", 205071c9a3ddSBharata B Rao machine->ram_slots, max_memslots); 2051d54e4d76SDavid Gibson exit(1); 20524a1c9cf0SBharata B Rao } 20534a1c9cf0SBharata B Rao 20544a1c9cf0SBharata B Rao spapr->hotplug_memory.base = ROUND_UP(machine->ram_size, 20554a1c9cf0SBharata B Rao SPAPR_HOTPLUG_MEM_ALIGN); 20564a1c9cf0SBharata B Rao memory_region_init(&spapr->hotplug_memory.mr, OBJECT(spapr), 20574a1c9cf0SBharata B Rao "hotplug-memory", hotplug_mem_size); 20584a1c9cf0SBharata B Rao memory_region_add_subregion(sysmem, spapr->hotplug_memory.base, 20594a1c9cf0SBharata B Rao &spapr->hotplug_memory.mr); 20604a1c9cf0SBharata B Rao } 20614a1c9cf0SBharata B Rao 2062224245bfSDavid Gibson if (smc->dr_lmb_enabled) { 2063224245bfSDavid Gibson spapr_create_lmb_dr_connectors(spapr); 2064224245bfSDavid Gibson } 2065224245bfSDavid Gibson 206653018216SPaolo Bonzini filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, "spapr-rtas.bin"); 20674c56440dSStefan Weil if (!filename) { 2068730fce59SThomas Huth error_report("Could not find LPAR rtas '%s'", "spapr-rtas.bin"); 20694c56440dSStefan Weil exit(1); 20704c56440dSStefan Weil } 2071b7d1f77aSBenjamin Herrenschmidt spapr->rtas_size = get_image_size(filename); 20728afc22a2SZhou Jie if (spapr->rtas_size < 0) { 20738afc22a2SZhou Jie error_report("Could not get size of LPAR rtas '%s'", filename); 20748afc22a2SZhou Jie exit(1); 20758afc22a2SZhou Jie } 2076b7d1f77aSBenjamin Herrenschmidt spapr->rtas_blob = g_malloc(spapr->rtas_size); 2077b7d1f77aSBenjamin Herrenschmidt if (load_image_size(filename, spapr->rtas_blob, spapr->rtas_size) < 0) { 2078730fce59SThomas Huth error_report("Could not load LPAR rtas '%s'", filename); 207953018216SPaolo Bonzini exit(1); 208053018216SPaolo Bonzini } 208153018216SPaolo Bonzini if (spapr->rtas_size > RTAS_MAX_SIZE) { 2082730fce59SThomas Huth error_report("RTAS too big ! 0x%zx bytes (max is 0x%x)", 20832f285bddSPeter Maydell (size_t)spapr->rtas_size, RTAS_MAX_SIZE); 208453018216SPaolo Bonzini exit(1); 208553018216SPaolo Bonzini } 208653018216SPaolo Bonzini g_free(filename); 208753018216SPaolo Bonzini 2088ffbb1705SMichael Roth /* Set up RTAS event infrastructure */ 208953018216SPaolo Bonzini spapr_events_init(spapr); 209053018216SPaolo Bonzini 209112f42174SDavid Gibson /* Set up the RTC RTAS interfaces */ 209228df36a1SDavid Gibson spapr_rtc_create(spapr); 209312f42174SDavid Gibson 209453018216SPaolo Bonzini /* Set up VIO bus */ 209553018216SPaolo Bonzini spapr->vio_bus = spapr_vio_bus_init(); 209653018216SPaolo Bonzini 209753018216SPaolo Bonzini for (i = 0; i < MAX_SERIAL_PORTS; i++) { 209853018216SPaolo Bonzini if (serial_hds[i]) { 209953018216SPaolo Bonzini spapr_vty_create(spapr->vio_bus, serial_hds[i]); 210053018216SPaolo Bonzini } 210153018216SPaolo Bonzini } 210253018216SPaolo Bonzini 210353018216SPaolo Bonzini /* We always have at least the nvram device on VIO */ 210453018216SPaolo Bonzini spapr_create_nvram(spapr); 210553018216SPaolo Bonzini 210653018216SPaolo Bonzini /* Set up PCI */ 210753018216SPaolo Bonzini spapr_pci_rtas_init(); 210853018216SPaolo Bonzini 210989dfd6e1SDavid Gibson phb = spapr_create_phb(spapr, 0); 211053018216SPaolo Bonzini 211153018216SPaolo Bonzini for (i = 0; i < nb_nics; i++) { 211253018216SPaolo Bonzini NICInfo *nd = &nd_table[i]; 211353018216SPaolo Bonzini 211453018216SPaolo Bonzini if (!nd->model) { 211553018216SPaolo Bonzini nd->model = g_strdup("ibmveth"); 211653018216SPaolo Bonzini } 211753018216SPaolo Bonzini 211853018216SPaolo Bonzini if (strcmp(nd->model, "ibmveth") == 0) { 211953018216SPaolo Bonzini spapr_vlan_create(spapr->vio_bus, nd); 212053018216SPaolo Bonzini } else { 212129b358f9SDavid Gibson pci_nic_init_nofail(&nd_table[i], phb->bus, nd->model, NULL); 212253018216SPaolo Bonzini } 212353018216SPaolo Bonzini } 212453018216SPaolo Bonzini 212553018216SPaolo Bonzini for (i = 0; i <= drive_get_max_bus(IF_SCSI); i++) { 212653018216SPaolo Bonzini spapr_vscsi_create(spapr->vio_bus); 212753018216SPaolo Bonzini } 212853018216SPaolo Bonzini 212953018216SPaolo Bonzini /* Graphics */ 213014c6a894SDavid Gibson if (spapr_vga_init(phb->bus, &error_fatal)) { 213153018216SPaolo Bonzini spapr->has_graphics = true; 2132c6e76503SPaolo Bonzini machine->usb |= defaults_enabled() && !machine->usb_disabled; 213353018216SPaolo Bonzini } 213453018216SPaolo Bonzini 21354ee9ced9SMarcel Apfelbaum if (machine->usb) { 213657040d45SThomas Huth if (smc->use_ohci_by_default) { 213753018216SPaolo Bonzini pci_create_simple(phb->bus, -1, "pci-ohci"); 213857040d45SThomas Huth } else { 213957040d45SThomas Huth pci_create_simple(phb->bus, -1, "nec-usb-xhci"); 214057040d45SThomas Huth } 2141c86580b8SMarkus Armbruster 214253018216SPaolo Bonzini if (spapr->has_graphics) { 2143c86580b8SMarkus Armbruster USBBus *usb_bus = usb_bus_find(-1); 2144c86580b8SMarkus Armbruster 2145c86580b8SMarkus Armbruster usb_create_simple(usb_bus, "usb-kbd"); 2146c86580b8SMarkus Armbruster usb_create_simple(usb_bus, "usb-mouse"); 214753018216SPaolo Bonzini } 214853018216SPaolo Bonzini } 214953018216SPaolo Bonzini 215053018216SPaolo Bonzini if (spapr->rma_size < (MIN_RMA_SLOF << 20)) { 2151d54e4d76SDavid Gibson error_report( 2152d54e4d76SDavid Gibson "pSeries SLOF firmware requires >= %ldM guest RMA (Real Mode Area memory)", 2153d54e4d76SDavid Gibson MIN_RMA_SLOF); 215453018216SPaolo Bonzini exit(1); 215553018216SPaolo Bonzini } 215653018216SPaolo Bonzini 215753018216SPaolo Bonzini if (kernel_filename) { 215853018216SPaolo Bonzini uint64_t lowaddr = 0; 215953018216SPaolo Bonzini 2160a19f7fb0SDavid Gibson spapr->kernel_size = load_elf(kernel_filename, translate_kernel_address, 2161a19f7fb0SDavid Gibson NULL, NULL, &lowaddr, NULL, 1, 2162a19f7fb0SDavid Gibson PPC_ELF_MACHINE, 0, 0); 2163a19f7fb0SDavid Gibson if (spapr->kernel_size == ELF_LOAD_WRONG_ENDIAN) { 2164a19f7fb0SDavid Gibson spapr->kernel_size = load_elf(kernel_filename, 2165a19f7fb0SDavid Gibson translate_kernel_address, NULL, NULL, 2166a19f7fb0SDavid Gibson &lowaddr, NULL, 0, PPC_ELF_MACHINE, 21677ef295eaSPeter Crosthwaite 0, 0); 2168a19f7fb0SDavid Gibson spapr->kernel_le = spapr->kernel_size > 0; 216916457e7fSBenjamin Herrenschmidt } 2170a19f7fb0SDavid Gibson if (spapr->kernel_size < 0) { 2171a19f7fb0SDavid Gibson error_report("error loading %s: %s", kernel_filename, 2172a19f7fb0SDavid Gibson load_elf_strerror(spapr->kernel_size)); 217353018216SPaolo Bonzini exit(1); 217453018216SPaolo Bonzini } 217553018216SPaolo Bonzini 217653018216SPaolo Bonzini /* load initrd */ 217753018216SPaolo Bonzini if (initrd_filename) { 217853018216SPaolo Bonzini /* Try to locate the initrd in the gap between the kernel 217953018216SPaolo Bonzini * and the firmware. Add a bit of space just in case 218053018216SPaolo Bonzini */ 2181a19f7fb0SDavid Gibson spapr->initrd_base = (KERNEL_LOAD_ADDR + spapr->kernel_size 2182a19f7fb0SDavid Gibson + 0x1ffff) & ~0xffff; 2183a19f7fb0SDavid Gibson spapr->initrd_size = load_image_targphys(initrd_filename, 2184a19f7fb0SDavid Gibson spapr->initrd_base, 2185a19f7fb0SDavid Gibson load_limit 2186a19f7fb0SDavid Gibson - spapr->initrd_base); 2187a19f7fb0SDavid Gibson if (spapr->initrd_size < 0) { 2188d54e4d76SDavid Gibson error_report("could not load initial ram disk '%s'", 218953018216SPaolo Bonzini initrd_filename); 219053018216SPaolo Bonzini exit(1); 219153018216SPaolo Bonzini } 219253018216SPaolo Bonzini } 219353018216SPaolo Bonzini } 219453018216SPaolo Bonzini 21958e7ea787SAndreas Färber if (bios_name == NULL) { 21968e7ea787SAndreas Färber bios_name = FW_FILE_NAME; 21978e7ea787SAndreas Färber } 21988e7ea787SAndreas Färber filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name); 21994c56440dSStefan Weil if (!filename) { 220068fea5a0SThomas Huth error_report("Could not find LPAR firmware '%s'", bios_name); 22014c56440dSStefan Weil exit(1); 22024c56440dSStefan Weil } 220353018216SPaolo Bonzini fw_size = load_image_targphys(filename, 0, FW_MAX_SIZE); 220468fea5a0SThomas Huth if (fw_size <= 0) { 220568fea5a0SThomas Huth error_report("Could not load LPAR firmware '%s'", filename); 220653018216SPaolo Bonzini exit(1); 220753018216SPaolo Bonzini } 220853018216SPaolo Bonzini g_free(filename); 220953018216SPaolo Bonzini 221028e02042SDavid Gibson /* FIXME: Should register things through the MachineState's qdev 221128e02042SDavid Gibson * interface, this is a legacy from the sPAPREnvironment structure 221228e02042SDavid Gibson * which predated MachineState but had a similar function */ 22134be21d56SDavid Gibson vmstate_register(NULL, 0, &vmstate_spapr, spapr); 22144be21d56SDavid Gibson register_savevm_live(NULL, "spapr/htab", -1, 1, 22154be21d56SDavid Gibson &savevm_htab_handlers, spapr); 22164be21d56SDavid Gibson 221746503c2bSMichael Roth /* used by RTAS */ 221846503c2bSMichael Roth QTAILQ_INIT(&spapr->ccs_list); 221946503c2bSMichael Roth qemu_register_reset(spapr_ccs_reset_hook, spapr); 222046503c2bSMichael Roth 22215b2128d2SAlexander Graf qemu_register_boot_set(spapr_boot_set, spapr); 222242043e4fSLaurent Vivier 222342043e4fSLaurent Vivier /* to stop and start vmclock */ 222442043e4fSLaurent Vivier if (kvm_enabled()) { 222542043e4fSLaurent Vivier qemu_add_vm_change_state_handler(cpu_ppc_clock_vm_state_change, 222642043e4fSLaurent Vivier &spapr->tb); 222742043e4fSLaurent Vivier } 222853018216SPaolo Bonzini } 222953018216SPaolo Bonzini 2230135a129aSAneesh Kumar K.V static int spapr_kvm_type(const char *vm_type) 2231135a129aSAneesh Kumar K.V { 2232135a129aSAneesh Kumar K.V if (!vm_type) { 2233135a129aSAneesh Kumar K.V return 0; 2234135a129aSAneesh Kumar K.V } 2235135a129aSAneesh Kumar K.V 2236135a129aSAneesh Kumar K.V if (!strcmp(vm_type, "HV")) { 2237135a129aSAneesh Kumar K.V return 1; 2238135a129aSAneesh Kumar K.V } 2239135a129aSAneesh Kumar K.V 2240135a129aSAneesh Kumar K.V if (!strcmp(vm_type, "PR")) { 2241135a129aSAneesh Kumar K.V return 2; 2242135a129aSAneesh Kumar K.V } 2243135a129aSAneesh Kumar K.V 2244135a129aSAneesh Kumar K.V error_report("Unknown kvm-type specified '%s'", vm_type); 2245135a129aSAneesh Kumar K.V exit(1); 2246135a129aSAneesh Kumar K.V } 2247135a129aSAneesh Kumar K.V 224871461b0fSAlexey Kardashevskiy /* 2249627b84f4SGonglei * Implementation of an interface to adjust firmware path 225071461b0fSAlexey Kardashevskiy * for the bootindex property handling. 225171461b0fSAlexey Kardashevskiy */ 225271461b0fSAlexey Kardashevskiy static char *spapr_get_fw_dev_path(FWPathProvider *p, BusState *bus, 225371461b0fSAlexey Kardashevskiy DeviceState *dev) 225471461b0fSAlexey Kardashevskiy { 225571461b0fSAlexey Kardashevskiy #define CAST(type, obj, name) \ 225671461b0fSAlexey Kardashevskiy ((type *)object_dynamic_cast(OBJECT(obj), (name))) 225771461b0fSAlexey Kardashevskiy SCSIDevice *d = CAST(SCSIDevice, dev, TYPE_SCSI_DEVICE); 225871461b0fSAlexey Kardashevskiy sPAPRPHBState *phb = CAST(sPAPRPHBState, dev, TYPE_SPAPR_PCI_HOST_BRIDGE); 225971461b0fSAlexey Kardashevskiy 226071461b0fSAlexey Kardashevskiy if (d) { 226171461b0fSAlexey Kardashevskiy void *spapr = CAST(void, bus->parent, "spapr-vscsi"); 226271461b0fSAlexey Kardashevskiy VirtIOSCSI *virtio = CAST(VirtIOSCSI, bus->parent, TYPE_VIRTIO_SCSI); 226371461b0fSAlexey Kardashevskiy USBDevice *usb = CAST(USBDevice, bus->parent, TYPE_USB_DEVICE); 226471461b0fSAlexey Kardashevskiy 226571461b0fSAlexey Kardashevskiy if (spapr) { 226671461b0fSAlexey Kardashevskiy /* 226771461b0fSAlexey Kardashevskiy * Replace "channel@0/disk@0,0" with "disk@8000000000000000": 226871461b0fSAlexey Kardashevskiy * We use SRP luns of the form 8000 | (bus << 8) | (id << 5) | lun 226971461b0fSAlexey Kardashevskiy * in the top 16 bits of the 64-bit LUN 227071461b0fSAlexey Kardashevskiy */ 227171461b0fSAlexey Kardashevskiy unsigned id = 0x8000 | (d->id << 8) | d->lun; 227271461b0fSAlexey Kardashevskiy return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev), 227371461b0fSAlexey Kardashevskiy (uint64_t)id << 48); 227471461b0fSAlexey Kardashevskiy } else if (virtio) { 227571461b0fSAlexey Kardashevskiy /* 227671461b0fSAlexey Kardashevskiy * We use SRP luns of the form 01000000 | (target << 8) | lun 227771461b0fSAlexey Kardashevskiy * in the top 32 bits of the 64-bit LUN 227871461b0fSAlexey Kardashevskiy * Note: the quote above is from SLOF and it is wrong, 227971461b0fSAlexey Kardashevskiy * the actual binding is: 228071461b0fSAlexey Kardashevskiy * swap 0100 or 10 << or 20 << ( target lun-id -- srplun ) 228171461b0fSAlexey Kardashevskiy */ 228271461b0fSAlexey Kardashevskiy unsigned id = 0x1000000 | (d->id << 16) | d->lun; 228371461b0fSAlexey Kardashevskiy return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev), 228471461b0fSAlexey Kardashevskiy (uint64_t)id << 32); 228571461b0fSAlexey Kardashevskiy } else if (usb) { 228671461b0fSAlexey Kardashevskiy /* 228771461b0fSAlexey Kardashevskiy * We use SRP luns of the form 01000000 | (usb-port << 16) | lun 228871461b0fSAlexey Kardashevskiy * in the top 32 bits of the 64-bit LUN 228971461b0fSAlexey Kardashevskiy */ 229071461b0fSAlexey Kardashevskiy unsigned usb_port = atoi(usb->port->path); 229171461b0fSAlexey Kardashevskiy unsigned id = 0x1000000 | (usb_port << 16) | d->lun; 229271461b0fSAlexey Kardashevskiy return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev), 229371461b0fSAlexey Kardashevskiy (uint64_t)id << 32); 229471461b0fSAlexey Kardashevskiy } 229571461b0fSAlexey Kardashevskiy } 229671461b0fSAlexey Kardashevskiy 2297b99260ebSThomas Huth /* 2298b99260ebSThomas Huth * SLOF probes the USB devices, and if it recognizes that the device is a 2299b99260ebSThomas Huth * storage device, it changes its name to "storage" instead of "usb-host", 2300b99260ebSThomas Huth * and additionally adds a child node for the SCSI LUN, so the correct 2301b99260ebSThomas Huth * boot path in SLOF is something like .../storage@1/disk@xxx" instead. 2302b99260ebSThomas Huth */ 2303b99260ebSThomas Huth if (strcmp("usb-host", qdev_fw_name(dev)) == 0) { 2304b99260ebSThomas Huth USBDevice *usbdev = CAST(USBDevice, dev, TYPE_USB_DEVICE); 2305b99260ebSThomas Huth if (usb_host_dev_is_scsi_storage(usbdev)) { 2306b99260ebSThomas Huth return g_strdup_printf("storage@%s/disk", usbdev->port->path); 2307b99260ebSThomas Huth } 2308b99260ebSThomas Huth } 2309b99260ebSThomas Huth 231071461b0fSAlexey Kardashevskiy if (phb) { 231171461b0fSAlexey Kardashevskiy /* Replace "pci" with "pci@800000020000000" */ 231271461b0fSAlexey Kardashevskiy return g_strdup_printf("pci@%"PRIX64, phb->buid); 231371461b0fSAlexey Kardashevskiy } 231471461b0fSAlexey Kardashevskiy 231571461b0fSAlexey Kardashevskiy return NULL; 231671461b0fSAlexey Kardashevskiy } 231771461b0fSAlexey Kardashevskiy 231823825581SEduardo Habkost static char *spapr_get_kvm_type(Object *obj, Error **errp) 231923825581SEduardo Habkost { 232028e02042SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 232123825581SEduardo Habkost 232228e02042SDavid Gibson return g_strdup(spapr->kvm_type); 232323825581SEduardo Habkost } 232423825581SEduardo Habkost 232523825581SEduardo Habkost static void spapr_set_kvm_type(Object *obj, const char *value, Error **errp) 232623825581SEduardo Habkost { 232728e02042SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 232823825581SEduardo Habkost 232928e02042SDavid Gibson g_free(spapr->kvm_type); 233028e02042SDavid Gibson spapr->kvm_type = g_strdup(value); 233123825581SEduardo Habkost } 233223825581SEduardo Habkost 2333f6229214SMichael Roth static bool spapr_get_modern_hotplug_events(Object *obj, Error **errp) 2334f6229214SMichael Roth { 2335f6229214SMichael Roth sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 2336f6229214SMichael Roth 2337f6229214SMichael Roth return spapr->use_hotplug_event_source; 2338f6229214SMichael Roth } 2339f6229214SMichael Roth 2340f6229214SMichael Roth static void spapr_set_modern_hotplug_events(Object *obj, bool value, 2341f6229214SMichael Roth Error **errp) 2342f6229214SMichael Roth { 2343f6229214SMichael Roth sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 2344f6229214SMichael Roth 2345f6229214SMichael Roth spapr->use_hotplug_event_source = value; 2346f6229214SMichael Roth } 2347f6229214SMichael Roth 234823825581SEduardo Habkost static void spapr_machine_initfn(Object *obj) 234923825581SEduardo Habkost { 2350715c5407SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 2351715c5407SDavid Gibson 2352715c5407SDavid Gibson spapr->htab_fd = -1; 2353f6229214SMichael Roth spapr->use_hotplug_event_source = true; 235423825581SEduardo Habkost object_property_add_str(obj, "kvm-type", 235523825581SEduardo Habkost spapr_get_kvm_type, spapr_set_kvm_type, NULL); 235649d2e648SMarcel Apfelbaum object_property_set_description(obj, "kvm-type", 235749d2e648SMarcel Apfelbaum "Specifies the KVM virtualization mode (HV, PR)", 235849d2e648SMarcel Apfelbaum NULL); 2359f6229214SMichael Roth object_property_add_bool(obj, "modern-hotplug-events", 2360f6229214SMichael Roth spapr_get_modern_hotplug_events, 2361f6229214SMichael Roth spapr_set_modern_hotplug_events, 2362f6229214SMichael Roth NULL); 2363f6229214SMichael Roth object_property_set_description(obj, "modern-hotplug-events", 2364f6229214SMichael Roth "Use dedicated hotplug event mechanism in" 2365f6229214SMichael Roth " place of standard EPOW events when possible" 2366f6229214SMichael Roth " (required for memory hot-unplug support)", 2367f6229214SMichael Roth NULL); 236823825581SEduardo Habkost } 236923825581SEduardo Habkost 237087bbdd9cSDavid Gibson static void spapr_machine_finalizefn(Object *obj) 237187bbdd9cSDavid Gibson { 237287bbdd9cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 237387bbdd9cSDavid Gibson 237487bbdd9cSDavid Gibson g_free(spapr->kvm_type); 237587bbdd9cSDavid Gibson } 237687bbdd9cSDavid Gibson 23771c7ad77eSNicholas Piggin void spapr_do_system_reset_on_cpu(CPUState *cs, run_on_cpu_data arg) 237834316482SAlexey Kardashevskiy { 237934316482SAlexey Kardashevskiy cpu_synchronize_state(cs); 238034316482SAlexey Kardashevskiy ppc_cpu_do_system_reset(cs); 238134316482SAlexey Kardashevskiy } 238234316482SAlexey Kardashevskiy 238334316482SAlexey Kardashevskiy static void spapr_nmi(NMIState *n, int cpu_index, Error **errp) 238434316482SAlexey Kardashevskiy { 238534316482SAlexey Kardashevskiy CPUState *cs; 238634316482SAlexey Kardashevskiy 238734316482SAlexey Kardashevskiy CPU_FOREACH(cs) { 23881c7ad77eSNicholas Piggin async_run_on_cpu(cs, spapr_do_system_reset_on_cpu, RUN_ON_CPU_NULL); 238934316482SAlexey Kardashevskiy } 239034316482SAlexey Kardashevskiy } 239134316482SAlexey Kardashevskiy 239279b78a6bSMichael Roth static void spapr_add_lmbs(DeviceState *dev, uint64_t addr_start, uint64_t size, 239379b78a6bSMichael Roth uint32_t node, bool dedicated_hp_event_source, 239479b78a6bSMichael Roth Error **errp) 2395c20d332aSBharata B Rao { 2396c20d332aSBharata B Rao sPAPRDRConnector *drc; 2397c20d332aSBharata B Rao sPAPRDRConnectorClass *drck; 2398c20d332aSBharata B Rao uint32_t nr_lmbs = size/SPAPR_MEMORY_BLOCK_SIZE; 2399c20d332aSBharata B Rao int i, fdt_offset, fdt_size; 2400c20d332aSBharata B Rao void *fdt; 240179b78a6bSMichael Roth uint64_t addr = addr_start; 2402c20d332aSBharata B Rao 2403c20d332aSBharata B Rao for (i = 0; i < nr_lmbs; i++) { 2404c20d332aSBharata B Rao drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_LMB, 2405c20d332aSBharata B Rao addr/SPAPR_MEMORY_BLOCK_SIZE); 2406c20d332aSBharata B Rao g_assert(drc); 2407c20d332aSBharata B Rao 2408c20d332aSBharata B Rao fdt = create_device_tree(&fdt_size); 2409c20d332aSBharata B Rao fdt_offset = spapr_populate_memory_node(fdt, node, addr, 2410c20d332aSBharata B Rao SPAPR_MEMORY_BLOCK_SIZE); 2411c20d332aSBharata B Rao 2412c20d332aSBharata B Rao drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 2413c20d332aSBharata B Rao drck->attach(drc, dev, fdt, fdt_offset, !dev->hotplugged, errp); 2414c20d332aSBharata B Rao addr += SPAPR_MEMORY_BLOCK_SIZE; 24155c0139a8SMichael Roth if (!dev->hotplugged) { 24165c0139a8SMichael Roth /* guests expect coldplugged LMBs to be pre-allocated */ 24175c0139a8SMichael Roth drck->set_allocation_state(drc, SPAPR_DR_ALLOCATION_STATE_USABLE); 24185c0139a8SMichael Roth drck->set_isolation_state(drc, SPAPR_DR_ISOLATION_STATE_UNISOLATED); 24195c0139a8SMichael Roth } 2420c20d332aSBharata B Rao } 24215dd5238cSJianjun Duan /* send hotplug notification to the 24225dd5238cSJianjun Duan * guest only in case of hotplugged memory 24235dd5238cSJianjun Duan */ 24245dd5238cSJianjun Duan if (dev->hotplugged) { 242579b78a6bSMichael Roth if (dedicated_hp_event_source) { 242679b78a6bSMichael Roth drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_LMB, 242779b78a6bSMichael Roth addr_start / SPAPR_MEMORY_BLOCK_SIZE); 242879b78a6bSMichael Roth drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 242979b78a6bSMichael Roth spapr_hotplug_req_add_by_count_indexed(SPAPR_DR_CONNECTOR_TYPE_LMB, 243079b78a6bSMichael Roth nr_lmbs, 243179b78a6bSMichael Roth drck->get_index(drc)); 243279b78a6bSMichael Roth } else { 243379b78a6bSMichael Roth spapr_hotplug_req_add_by_count(SPAPR_DR_CONNECTOR_TYPE_LMB, 243479b78a6bSMichael Roth nr_lmbs); 243579b78a6bSMichael Roth } 2436c20d332aSBharata B Rao } 24375dd5238cSJianjun Duan } 2438c20d332aSBharata B Rao 2439c20d332aSBharata B Rao static void spapr_memory_plug(HotplugHandler *hotplug_dev, DeviceState *dev, 2440c20d332aSBharata B Rao uint32_t node, Error **errp) 2441c20d332aSBharata B Rao { 2442c20d332aSBharata B Rao Error *local_err = NULL; 2443c20d332aSBharata B Rao sPAPRMachineState *ms = SPAPR_MACHINE(hotplug_dev); 2444c20d332aSBharata B Rao PCDIMMDevice *dimm = PC_DIMM(dev); 2445c20d332aSBharata B Rao PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); 2446c20d332aSBharata B Rao MemoryRegion *mr = ddc->get_memory_region(dimm); 2447c20d332aSBharata B Rao uint64_t align = memory_region_get_alignment(mr); 2448c20d332aSBharata B Rao uint64_t size = memory_region_size(mr); 2449c20d332aSBharata B Rao uint64_t addr; 2450df587133SThomas Huth char *mem_dev; 2451c20d332aSBharata B Rao 2452c20d332aSBharata B Rao if (size % SPAPR_MEMORY_BLOCK_SIZE) { 2453c20d332aSBharata B Rao error_setg(&local_err, "Hotplugged memory size must be a multiple of " 2454c20d332aSBharata B Rao "%lld MB", SPAPR_MEMORY_BLOCK_SIZE/M_BYTE); 2455c20d332aSBharata B Rao goto out; 2456c20d332aSBharata B Rao } 2457c20d332aSBharata B Rao 2458df587133SThomas Huth mem_dev = object_property_get_str(OBJECT(dimm), PC_DIMM_MEMDEV_PROP, NULL); 2459df587133SThomas Huth if (mem_dev && !kvmppc_is_mem_backend_page_size_ok(mem_dev)) { 2460df587133SThomas Huth error_setg(&local_err, "Memory backend has bad page size. " 2461df587133SThomas Huth "Use 'memory-backend-file' with correct mem-path."); 2462df587133SThomas Huth goto out; 2463df587133SThomas Huth } 2464df587133SThomas Huth 2465d6a9b0b8SMichael S. Tsirkin pc_dimm_memory_plug(dev, &ms->hotplug_memory, mr, align, &local_err); 2466c20d332aSBharata B Rao if (local_err) { 2467c20d332aSBharata B Rao goto out; 2468c20d332aSBharata B Rao } 2469c20d332aSBharata B Rao 2470c20d332aSBharata B Rao addr = object_property_get_int(OBJECT(dimm), PC_DIMM_ADDR_PROP, &local_err); 2471c20d332aSBharata B Rao if (local_err) { 2472c20d332aSBharata B Rao pc_dimm_memory_unplug(dev, &ms->hotplug_memory, mr); 2473c20d332aSBharata B Rao goto out; 2474c20d332aSBharata B Rao } 2475c20d332aSBharata B Rao 247679b78a6bSMichael Roth spapr_add_lmbs(dev, addr, size, node, 247779b78a6bSMichael Roth spapr_ovec_test(ms->ov5_cas, OV5_HP_EVT), 247879b78a6bSMichael Roth &error_abort); 2479c20d332aSBharata B Rao 2480c20d332aSBharata B Rao out: 2481c20d332aSBharata B Rao error_propagate(errp, local_err); 2482c20d332aSBharata B Rao } 2483c20d332aSBharata B Rao 2484cf632463SBharata B Rao typedef struct sPAPRDIMMState { 2485cf632463SBharata B Rao uint32_t nr_lmbs; 2486cf632463SBharata B Rao } sPAPRDIMMState; 2487cf632463SBharata B Rao 2488cf632463SBharata B Rao static void spapr_lmb_release(DeviceState *dev, void *opaque) 2489cf632463SBharata B Rao { 2490cf632463SBharata B Rao sPAPRDIMMState *ds = (sPAPRDIMMState *)opaque; 2491cf632463SBharata B Rao HotplugHandler *hotplug_ctrl; 2492cf632463SBharata B Rao 2493cf632463SBharata B Rao if (--ds->nr_lmbs) { 2494cf632463SBharata B Rao return; 2495cf632463SBharata B Rao } 2496cf632463SBharata B Rao 2497cf632463SBharata B Rao g_free(ds); 2498cf632463SBharata B Rao 2499cf632463SBharata B Rao /* 2500cf632463SBharata B Rao * Now that all the LMBs have been removed by the guest, call the 2501cf632463SBharata B Rao * pc-dimm unplug handler to cleanup up the pc-dimm device. 2502cf632463SBharata B Rao */ 2503cf632463SBharata B Rao hotplug_ctrl = qdev_get_hotplug_handler(dev); 2504cf632463SBharata B Rao hotplug_handler_unplug(hotplug_ctrl, dev, &error_abort); 2505cf632463SBharata B Rao } 2506cf632463SBharata B Rao 2507cf632463SBharata B Rao static void spapr_del_lmbs(DeviceState *dev, uint64_t addr_start, uint64_t size, 2508cf632463SBharata B Rao Error **errp) 2509cf632463SBharata B Rao { 2510cf632463SBharata B Rao sPAPRDRConnector *drc; 2511cf632463SBharata B Rao sPAPRDRConnectorClass *drck; 2512cf632463SBharata B Rao uint32_t nr_lmbs = size / SPAPR_MEMORY_BLOCK_SIZE; 2513cf632463SBharata B Rao int i; 2514cf632463SBharata B Rao sPAPRDIMMState *ds = g_malloc0(sizeof(sPAPRDIMMState)); 2515cf632463SBharata B Rao uint64_t addr = addr_start; 2516cf632463SBharata B Rao 2517cf632463SBharata B Rao ds->nr_lmbs = nr_lmbs; 2518cf632463SBharata B Rao for (i = 0; i < nr_lmbs; i++) { 2519cf632463SBharata B Rao drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_LMB, 2520cf632463SBharata B Rao addr / SPAPR_MEMORY_BLOCK_SIZE); 2521cf632463SBharata B Rao g_assert(drc); 2522cf632463SBharata B Rao 2523cf632463SBharata B Rao drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 2524cf632463SBharata B Rao drck->detach(drc, dev, spapr_lmb_release, ds, errp); 2525cf632463SBharata B Rao addr += SPAPR_MEMORY_BLOCK_SIZE; 2526cf632463SBharata B Rao } 2527cf632463SBharata B Rao 2528cf632463SBharata B Rao drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_LMB, 2529cf632463SBharata B Rao addr_start / SPAPR_MEMORY_BLOCK_SIZE); 2530cf632463SBharata B Rao drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 2531cf632463SBharata B Rao spapr_hotplug_req_remove_by_count_indexed(SPAPR_DR_CONNECTOR_TYPE_LMB, 2532cf632463SBharata B Rao nr_lmbs, 2533cf632463SBharata B Rao drck->get_index(drc)); 2534cf632463SBharata B Rao } 2535cf632463SBharata B Rao 2536cf632463SBharata B Rao static void spapr_memory_unplug(HotplugHandler *hotplug_dev, DeviceState *dev, 2537cf632463SBharata B Rao Error **errp) 2538cf632463SBharata B Rao { 2539cf632463SBharata B Rao sPAPRMachineState *ms = SPAPR_MACHINE(hotplug_dev); 2540cf632463SBharata B Rao PCDIMMDevice *dimm = PC_DIMM(dev); 2541cf632463SBharata B Rao PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); 2542cf632463SBharata B Rao MemoryRegion *mr = ddc->get_memory_region(dimm); 2543cf632463SBharata B Rao 2544cf632463SBharata B Rao pc_dimm_memory_unplug(dev, &ms->hotplug_memory, mr); 2545cf632463SBharata B Rao object_unparent(OBJECT(dev)); 2546cf632463SBharata B Rao } 2547cf632463SBharata B Rao 2548cf632463SBharata B Rao static void spapr_memory_unplug_request(HotplugHandler *hotplug_dev, 2549cf632463SBharata B Rao DeviceState *dev, Error **errp) 2550cf632463SBharata B Rao { 2551cf632463SBharata B Rao Error *local_err = NULL; 2552cf632463SBharata B Rao PCDIMMDevice *dimm = PC_DIMM(dev); 2553cf632463SBharata B Rao PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); 2554cf632463SBharata B Rao MemoryRegion *mr = ddc->get_memory_region(dimm); 2555cf632463SBharata B Rao uint64_t size = memory_region_size(mr); 2556cf632463SBharata B Rao uint64_t addr; 2557cf632463SBharata B Rao 2558cf632463SBharata B Rao addr = object_property_get_int(OBJECT(dimm), PC_DIMM_ADDR_PROP, &local_err); 2559cf632463SBharata B Rao if (local_err) { 2560cf632463SBharata B Rao goto out; 2561cf632463SBharata B Rao } 2562cf632463SBharata B Rao 2563cf632463SBharata B Rao spapr_del_lmbs(dev, addr, size, &error_abort); 2564cf632463SBharata B Rao out: 2565cf632463SBharata B Rao error_propagate(errp, local_err); 2566cf632463SBharata B Rao } 2567cf632463SBharata B Rao 2568af81cf32SBharata B Rao void *spapr_populate_hotplug_cpu_dt(CPUState *cs, int *fdt_offset, 2569af81cf32SBharata B Rao sPAPRMachineState *spapr) 2570af81cf32SBharata B Rao { 2571af81cf32SBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(cs); 2572af81cf32SBharata B Rao DeviceClass *dc = DEVICE_GET_CLASS(cs); 2573af81cf32SBharata B Rao int id = ppc_get_vcpu_dt_id(cpu); 2574af81cf32SBharata B Rao void *fdt; 2575af81cf32SBharata B Rao int offset, fdt_size; 2576af81cf32SBharata B Rao char *nodename; 2577af81cf32SBharata B Rao 2578af81cf32SBharata B Rao fdt = create_device_tree(&fdt_size); 2579af81cf32SBharata B Rao nodename = g_strdup_printf("%s@%x", dc->fw_name, id); 2580af81cf32SBharata B Rao offset = fdt_add_subnode(fdt, 0, nodename); 2581af81cf32SBharata B Rao 2582af81cf32SBharata B Rao spapr_populate_cpu_dt(cs, fdt, offset, spapr); 2583af81cf32SBharata B Rao g_free(nodename); 2584af81cf32SBharata B Rao 2585af81cf32SBharata B Rao *fdt_offset = offset; 2586af81cf32SBharata B Rao return fdt; 2587af81cf32SBharata B Rao } 2588af81cf32SBharata B Rao 2589115debf2SIgor Mammedov static void spapr_core_unplug(HotplugHandler *hotplug_dev, DeviceState *dev, 2590115debf2SIgor Mammedov Error **errp) 2591ff9006ddSIgor Mammedov { 2592535455fdSIgor Mammedov MachineState *ms = MACHINE(qdev_get_machine()); 2593ff9006ddSIgor Mammedov CPUCore *cc = CPU_CORE(dev); 2594535455fdSIgor Mammedov CPUArchId *core_slot = spapr_find_cpu_slot(ms, cc->core_id, NULL); 2595ff9006ddSIgor Mammedov 2596535455fdSIgor Mammedov core_slot->cpu = NULL; 2597ff9006ddSIgor Mammedov object_unparent(OBJECT(dev)); 2598ff9006ddSIgor Mammedov } 2599ff9006ddSIgor Mammedov 2600115debf2SIgor Mammedov static void spapr_core_release(DeviceState *dev, void *opaque) 2601115debf2SIgor Mammedov { 2602115debf2SIgor Mammedov HotplugHandler *hotplug_ctrl; 2603115debf2SIgor Mammedov 2604115debf2SIgor Mammedov hotplug_ctrl = qdev_get_hotplug_handler(dev); 2605115debf2SIgor Mammedov hotplug_handler_unplug(hotplug_ctrl, dev, &error_abort); 2606115debf2SIgor Mammedov } 2607115debf2SIgor Mammedov 2608115debf2SIgor Mammedov static 2609115debf2SIgor Mammedov void spapr_core_unplug_request(HotplugHandler *hotplug_dev, DeviceState *dev, 2610ff9006ddSIgor Mammedov Error **errp) 2611ff9006ddSIgor Mammedov { 2612535455fdSIgor Mammedov int index; 2613535455fdSIgor Mammedov sPAPRDRConnector *drc; 2614ff9006ddSIgor Mammedov sPAPRDRConnectorClass *drck; 2615ff9006ddSIgor Mammedov Error *local_err = NULL; 2616535455fdSIgor Mammedov CPUCore *cc = CPU_CORE(dev); 2617535455fdSIgor Mammedov int smt = kvmppc_smt_threads(); 2618ff9006ddSIgor Mammedov 2619535455fdSIgor Mammedov if (!spapr_find_cpu_slot(MACHINE(hotplug_dev), cc->core_id, &index)) { 2620535455fdSIgor Mammedov error_setg(errp, "Unable to find CPU core with core-id: %d", 2621535455fdSIgor Mammedov cc->core_id); 2622535455fdSIgor Mammedov return; 2623535455fdSIgor Mammedov } 2624ff9006ddSIgor Mammedov if (index == 0) { 2625ff9006ddSIgor Mammedov error_setg(errp, "Boot CPU core may not be unplugged"); 2626ff9006ddSIgor Mammedov return; 2627ff9006ddSIgor Mammedov } 2628ff9006ddSIgor Mammedov 2629535455fdSIgor Mammedov drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_CPU, index * smt); 2630ff9006ddSIgor Mammedov g_assert(drc); 2631ff9006ddSIgor Mammedov 2632ff9006ddSIgor Mammedov drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 2633ff9006ddSIgor Mammedov drck->detach(drc, dev, spapr_core_release, NULL, &local_err); 2634ff9006ddSIgor Mammedov if (local_err) { 2635ff9006ddSIgor Mammedov error_propagate(errp, local_err); 2636ff9006ddSIgor Mammedov return; 2637ff9006ddSIgor Mammedov } 2638ff9006ddSIgor Mammedov 2639ff9006ddSIgor Mammedov spapr_hotplug_req_remove_by_index(drc); 2640ff9006ddSIgor Mammedov } 2641ff9006ddSIgor Mammedov 2642ff9006ddSIgor Mammedov static void spapr_core_plug(HotplugHandler *hotplug_dev, DeviceState *dev, 2643ff9006ddSIgor Mammedov Error **errp) 2644ff9006ddSIgor Mammedov { 2645ff9006ddSIgor Mammedov sPAPRMachineState *spapr = SPAPR_MACHINE(OBJECT(hotplug_dev)); 2646ff9006ddSIgor Mammedov MachineClass *mc = MACHINE_GET_CLASS(spapr); 2647ff9006ddSIgor Mammedov sPAPRCPUCore *core = SPAPR_CPU_CORE(OBJECT(dev)); 2648ff9006ddSIgor Mammedov CPUCore *cc = CPU_CORE(dev); 2649ff9006ddSIgor Mammedov CPUState *cs = CPU(core->threads); 2650ff9006ddSIgor Mammedov sPAPRDRConnector *drc; 2651ff9006ddSIgor Mammedov Error *local_err = NULL; 2652ff9006ddSIgor Mammedov void *fdt = NULL; 2653ff9006ddSIgor Mammedov int fdt_offset = 0; 2654ff9006ddSIgor Mammedov int smt = kvmppc_smt_threads(); 2655535455fdSIgor Mammedov CPUArchId *core_slot; 2656535455fdSIgor Mammedov int index; 2657ff9006ddSIgor Mammedov 2658535455fdSIgor Mammedov core_slot = spapr_find_cpu_slot(MACHINE(hotplug_dev), cc->core_id, &index); 2659535455fdSIgor Mammedov if (!core_slot) { 2660535455fdSIgor Mammedov error_setg(errp, "Unable to find CPU core with core-id: %d", 2661535455fdSIgor Mammedov cc->core_id); 2662535455fdSIgor Mammedov return; 2663535455fdSIgor Mammedov } 2664ff9006ddSIgor Mammedov drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_CPU, index * smt); 2665ff9006ddSIgor Mammedov 2666c5514d0eSIgor Mammedov g_assert(drc || !mc->has_hotpluggable_cpus); 2667ff9006ddSIgor Mammedov 2668ff9006ddSIgor Mammedov /* 2669ff9006ddSIgor Mammedov * Setup CPU DT entries only for hotplugged CPUs. For boot time or 2670ff9006ddSIgor Mammedov * coldplugged CPUs DT entries are setup in spapr_build_fdt(). 2671ff9006ddSIgor Mammedov */ 2672ff9006ddSIgor Mammedov if (dev->hotplugged) { 2673ff9006ddSIgor Mammedov fdt = spapr_populate_hotplug_cpu_dt(cs, &fdt_offset, spapr); 2674ff9006ddSIgor Mammedov } 2675ff9006ddSIgor Mammedov 2676ff9006ddSIgor Mammedov if (drc) { 2677ff9006ddSIgor Mammedov sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 2678ff9006ddSIgor Mammedov drck->attach(drc, dev, fdt, fdt_offset, !dev->hotplugged, &local_err); 2679ff9006ddSIgor Mammedov if (local_err) { 2680ff9006ddSIgor Mammedov g_free(fdt); 2681ff9006ddSIgor Mammedov error_propagate(errp, local_err); 2682ff9006ddSIgor Mammedov return; 2683ff9006ddSIgor Mammedov } 2684ff9006ddSIgor Mammedov } 2685ff9006ddSIgor Mammedov 2686ff9006ddSIgor Mammedov if (dev->hotplugged) { 2687ff9006ddSIgor Mammedov /* 2688ff9006ddSIgor Mammedov * Send hotplug notification interrupt to the guest only in case 2689ff9006ddSIgor Mammedov * of hotplugged CPUs. 2690ff9006ddSIgor Mammedov */ 2691ff9006ddSIgor Mammedov spapr_hotplug_req_add_by_index(drc); 2692ff9006ddSIgor Mammedov } else { 2693ff9006ddSIgor Mammedov /* 2694ff9006ddSIgor Mammedov * Set the right DRC states for cold plugged CPU. 2695ff9006ddSIgor Mammedov */ 2696ff9006ddSIgor Mammedov if (drc) { 2697ff9006ddSIgor Mammedov sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 2698ff9006ddSIgor Mammedov drck->set_allocation_state(drc, SPAPR_DR_ALLOCATION_STATE_USABLE); 2699ff9006ddSIgor Mammedov drck->set_isolation_state(drc, SPAPR_DR_ISOLATION_STATE_UNISOLATED); 2700ff9006ddSIgor Mammedov } 2701ff9006ddSIgor Mammedov } 2702535455fdSIgor Mammedov core_slot->cpu = OBJECT(dev); 2703ff9006ddSIgor Mammedov } 2704ff9006ddSIgor Mammedov 2705ff9006ddSIgor Mammedov static void spapr_core_pre_plug(HotplugHandler *hotplug_dev, DeviceState *dev, 2706ff9006ddSIgor Mammedov Error **errp) 2707ff9006ddSIgor Mammedov { 2708ff9006ddSIgor Mammedov MachineState *machine = MACHINE(OBJECT(hotplug_dev)); 2709ff9006ddSIgor Mammedov MachineClass *mc = MACHINE_GET_CLASS(hotplug_dev); 2710ff9006ddSIgor Mammedov Error *local_err = NULL; 2711ff9006ddSIgor Mammedov CPUCore *cc = CPU_CORE(dev); 2712ff9006ddSIgor Mammedov char *base_core_type = spapr_get_cpu_core_type(machine->cpu_model); 2713ff9006ddSIgor Mammedov const char *type = object_get_typename(OBJECT(dev)); 2714535455fdSIgor Mammedov CPUArchId *core_slot; 2715535455fdSIgor Mammedov int index; 2716ff9006ddSIgor Mammedov 2717c5514d0eSIgor Mammedov if (dev->hotplugged && !mc->has_hotpluggable_cpus) { 2718ff9006ddSIgor Mammedov error_setg(&local_err, "CPU hotplug not supported for this machine"); 2719ff9006ddSIgor Mammedov goto out; 2720ff9006ddSIgor Mammedov } 2721ff9006ddSIgor Mammedov 2722ff9006ddSIgor Mammedov if (strcmp(base_core_type, type)) { 2723ff9006ddSIgor Mammedov error_setg(&local_err, "CPU core type should be %s", base_core_type); 2724ff9006ddSIgor Mammedov goto out; 2725ff9006ddSIgor Mammedov } 2726ff9006ddSIgor Mammedov 2727ff9006ddSIgor Mammedov if (cc->core_id % smp_threads) { 2728ff9006ddSIgor Mammedov error_setg(&local_err, "invalid core id %d", cc->core_id); 2729ff9006ddSIgor Mammedov goto out; 2730ff9006ddSIgor Mammedov } 2731ff9006ddSIgor Mammedov 2732535455fdSIgor Mammedov core_slot = spapr_find_cpu_slot(MACHINE(hotplug_dev), cc->core_id, &index); 2733535455fdSIgor Mammedov if (!core_slot) { 2734ff9006ddSIgor Mammedov error_setg(&local_err, "core id %d out of range", cc->core_id); 2735ff9006ddSIgor Mammedov goto out; 2736ff9006ddSIgor Mammedov } 2737ff9006ddSIgor Mammedov 2738535455fdSIgor Mammedov if (core_slot->cpu) { 2739ff9006ddSIgor Mammedov error_setg(&local_err, "core %d already populated", cc->core_id); 2740ff9006ddSIgor Mammedov goto out; 2741ff9006ddSIgor Mammedov } 2742ff9006ddSIgor Mammedov 2743ff9006ddSIgor Mammedov out: 2744ff9006ddSIgor Mammedov g_free(base_core_type); 2745ff9006ddSIgor Mammedov error_propagate(errp, local_err); 2746ff9006ddSIgor Mammedov } 2747ff9006ddSIgor Mammedov 2748c20d332aSBharata B Rao static void spapr_machine_device_plug(HotplugHandler *hotplug_dev, 2749c20d332aSBharata B Rao DeviceState *dev, Error **errp) 2750c20d332aSBharata B Rao { 2751c20d332aSBharata B Rao sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(qdev_get_machine()); 2752c20d332aSBharata B Rao 2753c20d332aSBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { 2754b556854bSBharata B Rao int node; 2755c20d332aSBharata B Rao 2756c20d332aSBharata B Rao if (!smc->dr_lmb_enabled) { 2757c20d332aSBharata B Rao error_setg(errp, "Memory hotplug not supported for this machine"); 2758c20d332aSBharata B Rao return; 2759c20d332aSBharata B Rao } 2760c20d332aSBharata B Rao node = object_property_get_int(OBJECT(dev), PC_DIMM_NODE_PROP, errp); 2761c20d332aSBharata B Rao if (*errp) { 2762c20d332aSBharata B Rao return; 2763c20d332aSBharata B Rao } 27641a5512bbSGonglei if (node < 0 || node >= MAX_NODES) { 27651a5512bbSGonglei error_setg(errp, "Invaild node %d", node); 27661a5512bbSGonglei return; 27671a5512bbSGonglei } 2768c20d332aSBharata B Rao 2769b556854bSBharata B Rao /* 2770b556854bSBharata B Rao * Currently PowerPC kernel doesn't allow hot-adding memory to 2771b556854bSBharata B Rao * memory-less node, but instead will silently add the memory 2772b556854bSBharata B Rao * to the first node that has some memory. This causes two 2773b556854bSBharata B Rao * unexpected behaviours for the user. 2774b556854bSBharata B Rao * 2775b556854bSBharata B Rao * - Memory gets hotplugged to a different node than what the user 2776b556854bSBharata B Rao * specified. 2777b556854bSBharata B Rao * - Since pc-dimm subsystem in QEMU still thinks that memory belongs 2778b556854bSBharata B Rao * to memory-less node, a reboot will set things accordingly 2779b556854bSBharata B Rao * and the previously hotplugged memory now ends in the right node. 2780b556854bSBharata B Rao * This appears as if some memory moved from one node to another. 2781b556854bSBharata B Rao * 2782b556854bSBharata B Rao * So until kernel starts supporting memory hotplug to memory-less 2783b556854bSBharata B Rao * nodes, just prevent such attempts upfront in QEMU. 2784b556854bSBharata B Rao */ 2785b556854bSBharata B Rao if (nb_numa_nodes && !numa_info[node].node_mem) { 2786b556854bSBharata B Rao error_setg(errp, "Can't hotplug memory to memory-less node %d", 2787b556854bSBharata B Rao node); 2788b556854bSBharata B Rao return; 2789b556854bSBharata B Rao } 2790b556854bSBharata B Rao 2791c20d332aSBharata B Rao spapr_memory_plug(hotplug_dev, dev, node, errp); 2792af81cf32SBharata B Rao } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 2793af81cf32SBharata B Rao spapr_core_plug(hotplug_dev, dev, errp); 2794c20d332aSBharata B Rao } 2795c20d332aSBharata B Rao } 2796c20d332aSBharata B Rao 2797c20d332aSBharata B Rao static void spapr_machine_device_unplug(HotplugHandler *hotplug_dev, 2798c20d332aSBharata B Rao DeviceState *dev, Error **errp) 2799c20d332aSBharata B Rao { 2800cf632463SBharata B Rao sPAPRMachineState *sms = SPAPR_MACHINE(qdev_get_machine()); 28013c0c47e3SDavid Gibson MachineClass *mc = MACHINE_GET_CLASS(qdev_get_machine()); 28026f4b5c3eSBharata B Rao 2803c20d332aSBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { 2804cf632463SBharata B Rao if (spapr_ovec_test(sms->ov5_cas, OV5_HP_EVT)) { 2805cf632463SBharata B Rao spapr_memory_unplug(hotplug_dev, dev, errp); 2806cf632463SBharata B Rao } else { 2807cf632463SBharata B Rao error_setg(errp, "Memory hot unplug not supported for this guest"); 2808cf632463SBharata B Rao } 2809cf632463SBharata B Rao } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 2810c5514d0eSIgor Mammedov if (!mc->has_hotpluggable_cpus) { 2811cf632463SBharata B Rao error_setg(errp, "CPU hot unplug not supported on this machine"); 2812cf632463SBharata B Rao return; 2813cf632463SBharata B Rao } 2814cf632463SBharata B Rao spapr_core_unplug(hotplug_dev, dev, errp); 2815cf632463SBharata B Rao } 2816cf632463SBharata B Rao } 2817cf632463SBharata B Rao 2818cf632463SBharata B Rao static void spapr_machine_device_unplug_request(HotplugHandler *hotplug_dev, 2819cf632463SBharata B Rao DeviceState *dev, Error **errp) 2820cf632463SBharata B Rao { 2821cf632463SBharata B Rao sPAPRMachineState *sms = SPAPR_MACHINE(qdev_get_machine()); 2822cf632463SBharata B Rao MachineClass *mc = MACHINE_GET_CLASS(qdev_get_machine()); 2823cf632463SBharata B Rao 2824cf632463SBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { 2825cf632463SBharata B Rao if (spapr_ovec_test(sms->ov5_cas, OV5_HP_EVT)) { 2826cf632463SBharata B Rao spapr_memory_unplug_request(hotplug_dev, dev, errp); 2827cf632463SBharata B Rao } else { 2828cf632463SBharata B Rao /* NOTE: this means there is a window after guest reset, prior to 2829cf632463SBharata B Rao * CAS negotiation, where unplug requests will fail due to the 2830cf632463SBharata B Rao * capability not being detected yet. This is a bit different than 2831cf632463SBharata B Rao * the case with PCI unplug, where the events will be queued and 2832cf632463SBharata B Rao * eventually handled by the guest after boot 2833cf632463SBharata B Rao */ 2834cf632463SBharata B Rao error_setg(errp, "Memory hot unplug not supported for this guest"); 2835cf632463SBharata B Rao } 28366f4b5c3eSBharata B Rao } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 2837c5514d0eSIgor Mammedov if (!mc->has_hotpluggable_cpus) { 28386f4b5c3eSBharata B Rao error_setg(errp, "CPU hot unplug not supported on this machine"); 28396f4b5c3eSBharata B Rao return; 28406f4b5c3eSBharata B Rao } 2841115debf2SIgor Mammedov spapr_core_unplug_request(hotplug_dev, dev, errp); 2842c20d332aSBharata B Rao } 2843c20d332aSBharata B Rao } 2844c20d332aSBharata B Rao 284594a94e4cSBharata B Rao static void spapr_machine_device_pre_plug(HotplugHandler *hotplug_dev, 284694a94e4cSBharata B Rao DeviceState *dev, Error **errp) 284794a94e4cSBharata B Rao { 284894a94e4cSBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 284994a94e4cSBharata B Rao spapr_core_pre_plug(hotplug_dev, dev, errp); 285094a94e4cSBharata B Rao } 285194a94e4cSBharata B Rao } 285294a94e4cSBharata B Rao 28537ebaf795SBharata B Rao static HotplugHandler *spapr_get_hotplug_handler(MachineState *machine, 2854c20d332aSBharata B Rao DeviceState *dev) 2855c20d332aSBharata B Rao { 285694a94e4cSBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM) || 285794a94e4cSBharata B Rao object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 2858c20d332aSBharata B Rao return HOTPLUG_HANDLER(machine); 2859c20d332aSBharata B Rao } 2860c20d332aSBharata B Rao return NULL; 2861c20d332aSBharata B Rao } 2862c20d332aSBharata B Rao 286320bb648dSDavid Gibson static unsigned spapr_cpu_index_to_socket_id(unsigned cpu_index) 286420bb648dSDavid Gibson { 286520bb648dSDavid Gibson /* Allocate to NUMA nodes on a "socket" basis (not that concept of 286620bb648dSDavid Gibson * socket means much for the paravirtualized PAPR platform) */ 286720bb648dSDavid Gibson return cpu_index / smp_threads / smp_cores; 286820bb648dSDavid Gibson } 286920bb648dSDavid Gibson 2870535455fdSIgor Mammedov static const CPUArchIdList *spapr_possible_cpu_arch_ids(MachineState *machine) 2871535455fdSIgor Mammedov { 2872535455fdSIgor Mammedov int i; 2873535455fdSIgor Mammedov int spapr_max_cores = max_cpus / smp_threads; 2874535455fdSIgor Mammedov MachineClass *mc = MACHINE_GET_CLASS(machine); 2875535455fdSIgor Mammedov 2876c5514d0eSIgor Mammedov if (!mc->has_hotpluggable_cpus) { 2877535455fdSIgor Mammedov spapr_max_cores = QEMU_ALIGN_UP(smp_cpus, smp_threads) / smp_threads; 2878535455fdSIgor Mammedov } 2879535455fdSIgor Mammedov if (machine->possible_cpus) { 2880535455fdSIgor Mammedov assert(machine->possible_cpus->len == spapr_max_cores); 2881535455fdSIgor Mammedov return machine->possible_cpus; 2882535455fdSIgor Mammedov } 2883535455fdSIgor Mammedov 2884535455fdSIgor Mammedov machine->possible_cpus = g_malloc0(sizeof(CPUArchIdList) + 2885535455fdSIgor Mammedov sizeof(CPUArchId) * spapr_max_cores); 2886535455fdSIgor Mammedov machine->possible_cpus->len = spapr_max_cores; 2887535455fdSIgor Mammedov for (i = 0; i < machine->possible_cpus->len; i++) { 2888535455fdSIgor Mammedov int core_id = i * smp_threads; 2889535455fdSIgor Mammedov 2890f2d672c2SIgor Mammedov machine->possible_cpus->cpus[i].vcpus_count = smp_threads; 2891535455fdSIgor Mammedov machine->possible_cpus->cpus[i].arch_id = core_id; 2892535455fdSIgor Mammedov machine->possible_cpus->cpus[i].props.has_core_id = true; 2893535455fdSIgor Mammedov machine->possible_cpus->cpus[i].props.core_id = core_id; 2894535455fdSIgor Mammedov /* TODO: add 'has_node/node' here to describe 2895535455fdSIgor Mammedov to which node core belongs */ 2896535455fdSIgor Mammedov } 2897535455fdSIgor Mammedov return machine->possible_cpus; 2898535455fdSIgor Mammedov } 2899535455fdSIgor Mammedov 29006737d9adSDavid Gibson static void spapr_phb_placement(sPAPRMachineState *spapr, uint32_t index, 2901daa23699SDavid Gibson uint64_t *buid, hwaddr *pio, 2902daa23699SDavid Gibson hwaddr *mmio32, hwaddr *mmio64, 29036737d9adSDavid Gibson unsigned n_dma, uint32_t *liobns, Error **errp) 29046737d9adSDavid Gibson { 2905357d1e3bSDavid Gibson /* 2906357d1e3bSDavid Gibson * New-style PHB window placement. 2907357d1e3bSDavid Gibson * 2908357d1e3bSDavid Gibson * Goals: Gives large (1TiB), naturally aligned 64-bit MMIO window 2909357d1e3bSDavid Gibson * for each PHB, in addition to 2GiB 32-bit MMIO and 64kiB PIO 2910357d1e3bSDavid Gibson * windows. 2911357d1e3bSDavid Gibson * 2912357d1e3bSDavid Gibson * Some guest kernels can't work with MMIO windows above 1<<46 2913357d1e3bSDavid Gibson * (64TiB), so we place up to 31 PHBs in the area 32TiB..64TiB 2914357d1e3bSDavid Gibson * 2915357d1e3bSDavid Gibson * 32TiB..(33TiB+1984kiB) contains the 64kiB PIO windows for each 2916357d1e3bSDavid Gibson * PHB stacked together. (32TiB+2GiB)..(32TiB+64GiB) contains the 2917357d1e3bSDavid Gibson * 2GiB 32-bit MMIO windows for each PHB. Then 33..64TiB has the 2918357d1e3bSDavid Gibson * 1TiB 64-bit MMIO windows for each PHB. 2919357d1e3bSDavid Gibson */ 29206737d9adSDavid Gibson const uint64_t base_buid = 0x800000020000000ULL; 292125e6a118SMichael S. Tsirkin #define SPAPR_MAX_PHBS ((SPAPR_PCI_LIMIT - SPAPR_PCI_BASE) / \ 292225e6a118SMichael S. Tsirkin SPAPR_PCI_MEM64_WIN_SIZE - 1) 29236737d9adSDavid Gibson int i; 29246737d9adSDavid Gibson 2925357d1e3bSDavid Gibson /* Sanity check natural alignments */ 2926357d1e3bSDavid Gibson QEMU_BUILD_BUG_ON((SPAPR_PCI_BASE % SPAPR_PCI_MEM64_WIN_SIZE) != 0); 2927357d1e3bSDavid Gibson QEMU_BUILD_BUG_ON((SPAPR_PCI_LIMIT % SPAPR_PCI_MEM64_WIN_SIZE) != 0); 2928357d1e3bSDavid Gibson QEMU_BUILD_BUG_ON((SPAPR_PCI_MEM64_WIN_SIZE % SPAPR_PCI_MEM32_WIN_SIZE) != 0); 2929357d1e3bSDavid Gibson QEMU_BUILD_BUG_ON((SPAPR_PCI_MEM32_WIN_SIZE % SPAPR_PCI_IO_WIN_SIZE) != 0); 2930357d1e3bSDavid Gibson /* Sanity check bounds */ 293125e6a118SMichael S. Tsirkin QEMU_BUILD_BUG_ON((SPAPR_MAX_PHBS * SPAPR_PCI_IO_WIN_SIZE) > 293225e6a118SMichael S. Tsirkin SPAPR_PCI_MEM32_WIN_SIZE); 293325e6a118SMichael S. Tsirkin QEMU_BUILD_BUG_ON((SPAPR_MAX_PHBS * SPAPR_PCI_MEM32_WIN_SIZE) > 293425e6a118SMichael S. Tsirkin SPAPR_PCI_MEM64_WIN_SIZE); 29352efff1c0SDavid Gibson 293625e6a118SMichael S. Tsirkin if (index >= SPAPR_MAX_PHBS) { 293725e6a118SMichael S. Tsirkin error_setg(errp, "\"index\" for PAPR PHB is too large (max %llu)", 293825e6a118SMichael S. Tsirkin SPAPR_MAX_PHBS - 1); 29396737d9adSDavid Gibson return; 29406737d9adSDavid Gibson } 29416737d9adSDavid Gibson 29426737d9adSDavid Gibson *buid = base_buid + index; 29436737d9adSDavid Gibson for (i = 0; i < n_dma; ++i) { 29446737d9adSDavid Gibson liobns[i] = SPAPR_PCI_LIOBN(index, i); 29456737d9adSDavid Gibson } 29466737d9adSDavid Gibson 2947357d1e3bSDavid Gibson *pio = SPAPR_PCI_BASE + index * SPAPR_PCI_IO_WIN_SIZE; 2948357d1e3bSDavid Gibson *mmio32 = SPAPR_PCI_BASE + (index + 1) * SPAPR_PCI_MEM32_WIN_SIZE; 2949357d1e3bSDavid Gibson *mmio64 = SPAPR_PCI_BASE + (index + 1) * SPAPR_PCI_MEM64_WIN_SIZE; 29506737d9adSDavid Gibson } 29516737d9adSDavid Gibson 295229ee3247SAlexey Kardashevskiy static void spapr_machine_class_init(ObjectClass *oc, void *data) 295353018216SPaolo Bonzini { 295429ee3247SAlexey Kardashevskiy MachineClass *mc = MACHINE_CLASS(oc); 2955224245bfSDavid Gibson sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(oc); 295671461b0fSAlexey Kardashevskiy FWPathProviderClass *fwc = FW_PATH_PROVIDER_CLASS(oc); 295734316482SAlexey Kardashevskiy NMIClass *nc = NMI_CLASS(oc); 2958c20d332aSBharata B Rao HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(oc); 29591d1be34dSDavid Gibson PPCVirtualHypervisorClass *vhc = PPC_VIRTUAL_HYPERVISOR_CLASS(oc); 296029ee3247SAlexey Kardashevskiy 29610eb9054cSDavid Gibson mc->desc = "pSeries Logical Partition (PAPR compliant)"; 2962fc9f38c3SDavid Gibson 2963fc9f38c3SDavid Gibson /* 2964fc9f38c3SDavid Gibson * We set up the default / latest behaviour here. The class_init 2965fc9f38c3SDavid Gibson * functions for the specific versioned machine types can override 2966fc9f38c3SDavid Gibson * these details for backwards compatibility 2967fc9f38c3SDavid Gibson */ 2968958db90cSMarcel Apfelbaum mc->init = ppc_spapr_init; 2969958db90cSMarcel Apfelbaum mc->reset = ppc_spapr_reset; 2970958db90cSMarcel Apfelbaum mc->block_default_type = IF_SCSI; 29716244bb7eSGreg Kurz mc->max_cpus = 1024; 2972958db90cSMarcel Apfelbaum mc->no_parallel = 1; 29735b2128d2SAlexander Graf mc->default_boot_order = ""; 2974a34944feSNikunj A Dadhania mc->default_ram_size = 512 * M_BYTE; 2975958db90cSMarcel Apfelbaum mc->kvm_type = spapr_kvm_type; 29769e3f9733SAlexander Graf mc->has_dynamic_sysbus = true; 2977e4024630SLaurent Vivier mc->pci_allow_0_address = true; 29787ebaf795SBharata B Rao mc->get_hotplug_handler = spapr_get_hotplug_handler; 297994a94e4cSBharata B Rao hc->pre_plug = spapr_machine_device_pre_plug; 2980c20d332aSBharata B Rao hc->plug = spapr_machine_device_plug; 2981c20d332aSBharata B Rao hc->unplug = spapr_machine_device_unplug; 298220bb648dSDavid Gibson mc->cpu_index_to_socket_id = spapr_cpu_index_to_socket_id; 2983535455fdSIgor Mammedov mc->possible_cpu_arch_ids = spapr_possible_cpu_arch_ids; 2984cf632463SBharata B Rao hc->unplug_request = spapr_machine_device_unplug_request; 298500b4fbe2SMarcel Apfelbaum 2986fc9f38c3SDavid Gibson smc->dr_lmb_enabled = true; 29873daa4a9fSThomas Huth smc->tcg_default_cpu = "POWER8"; 2988c5514d0eSIgor Mammedov mc->has_hotpluggable_cpus = true; 298971461b0fSAlexey Kardashevskiy fwc->get_dev_path = spapr_get_fw_dev_path; 299034316482SAlexey Kardashevskiy nc->nmi_monitor_handler = spapr_nmi; 29916737d9adSDavid Gibson smc->phb_placement = spapr_phb_placement; 29921d1be34dSDavid Gibson vhc->hypercall = emulate_spapr_hypercall; 2993e57ca75cSDavid Gibson vhc->hpt_mask = spapr_hpt_mask; 2994e57ca75cSDavid Gibson vhc->map_hptes = spapr_map_hptes; 2995e57ca75cSDavid Gibson vhc->unmap_hptes = spapr_unmap_hptes; 2996e57ca75cSDavid Gibson vhc->store_hpte = spapr_store_hpte; 299753018216SPaolo Bonzini } 299853018216SPaolo Bonzini 299929ee3247SAlexey Kardashevskiy static const TypeInfo spapr_machine_info = { 300029ee3247SAlexey Kardashevskiy .name = TYPE_SPAPR_MACHINE, 300129ee3247SAlexey Kardashevskiy .parent = TYPE_MACHINE, 30024aee7362SDavid Gibson .abstract = true, 30036ca1502eSAlexey Kardashevskiy .instance_size = sizeof(sPAPRMachineState), 300423825581SEduardo Habkost .instance_init = spapr_machine_initfn, 300587bbdd9cSDavid Gibson .instance_finalize = spapr_machine_finalizefn, 3006183930c0SDavid Gibson .class_size = sizeof(sPAPRMachineClass), 300729ee3247SAlexey Kardashevskiy .class_init = spapr_machine_class_init, 300871461b0fSAlexey Kardashevskiy .interfaces = (InterfaceInfo[]) { 300971461b0fSAlexey Kardashevskiy { TYPE_FW_PATH_PROVIDER }, 301034316482SAlexey Kardashevskiy { TYPE_NMI }, 3011c20d332aSBharata B Rao { TYPE_HOTPLUG_HANDLER }, 30121d1be34dSDavid Gibson { TYPE_PPC_VIRTUAL_HYPERVISOR }, 301371461b0fSAlexey Kardashevskiy { } 301471461b0fSAlexey Kardashevskiy }, 301529ee3247SAlexey Kardashevskiy }; 301629ee3247SAlexey Kardashevskiy 3017fccbc785SDavid Gibson #define DEFINE_SPAPR_MACHINE(suffix, verstr, latest) \ 30185013c547SDavid Gibson static void spapr_machine_##suffix##_class_init(ObjectClass *oc, \ 30195013c547SDavid Gibson void *data) \ 30205013c547SDavid Gibson { \ 30215013c547SDavid Gibson MachineClass *mc = MACHINE_CLASS(oc); \ 30225013c547SDavid Gibson spapr_machine_##suffix##_class_options(mc); \ 3023fccbc785SDavid Gibson if (latest) { \ 3024fccbc785SDavid Gibson mc->alias = "pseries"; \ 3025fccbc785SDavid Gibson mc->is_default = 1; \ 3026fccbc785SDavid Gibson } \ 30275013c547SDavid Gibson } \ 30285013c547SDavid Gibson static void spapr_machine_##suffix##_instance_init(Object *obj) \ 30295013c547SDavid Gibson { \ 30305013c547SDavid Gibson MachineState *machine = MACHINE(obj); \ 30315013c547SDavid Gibson spapr_machine_##suffix##_instance_options(machine); \ 30325013c547SDavid Gibson } \ 30335013c547SDavid Gibson static const TypeInfo spapr_machine_##suffix##_info = { \ 30345013c547SDavid Gibson .name = MACHINE_TYPE_NAME("pseries-" verstr), \ 30355013c547SDavid Gibson .parent = TYPE_SPAPR_MACHINE, \ 30365013c547SDavid Gibson .class_init = spapr_machine_##suffix##_class_init, \ 30375013c547SDavid Gibson .instance_init = spapr_machine_##suffix##_instance_init, \ 30385013c547SDavid Gibson }; \ 30395013c547SDavid Gibson static void spapr_machine_register_##suffix(void) \ 30405013c547SDavid Gibson { \ 30415013c547SDavid Gibson type_register(&spapr_machine_##suffix##_info); \ 30425013c547SDavid Gibson } \ 30430e6aac87SEduardo Habkost type_init(spapr_machine_register_##suffix) 30445013c547SDavid Gibson 30451c5f29bbSDavid Gibson /* 3046fa325e6cSDavid Gibson * pseries-2.9 3047db800b21SDavid Gibson */ 3048fa325e6cSDavid Gibson static void spapr_machine_2_9_instance_options(MachineState *machine) 3049db800b21SDavid Gibson { 3050db800b21SDavid Gibson } 3051db800b21SDavid Gibson 3052fa325e6cSDavid Gibson static void spapr_machine_2_9_class_options(MachineClass *mc) 3053db800b21SDavid Gibson { 3054db800b21SDavid Gibson /* Defaults for the latest behaviour inherited from the base class */ 3055db800b21SDavid Gibson } 3056db800b21SDavid Gibson 3057fa325e6cSDavid Gibson DEFINE_SPAPR_MACHINE(2_9, "2.9", true); 3058fa325e6cSDavid Gibson 3059fa325e6cSDavid Gibson /* 3060fa325e6cSDavid Gibson * pseries-2.8 3061fa325e6cSDavid Gibson */ 3062fa325e6cSDavid Gibson #define SPAPR_COMPAT_2_8 \ 3063fa325e6cSDavid Gibson HW_COMPAT_2_8 3064fa325e6cSDavid Gibson 3065fa325e6cSDavid Gibson static void spapr_machine_2_8_instance_options(MachineState *machine) 3066fa325e6cSDavid Gibson { 3067fa325e6cSDavid Gibson spapr_machine_2_9_instance_options(machine); 3068fa325e6cSDavid Gibson } 3069fa325e6cSDavid Gibson 3070fa325e6cSDavid Gibson static void spapr_machine_2_8_class_options(MachineClass *mc) 3071fa325e6cSDavid Gibson { 3072fa325e6cSDavid Gibson spapr_machine_2_9_class_options(mc); 3073fa325e6cSDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_8); 3074fa325e6cSDavid Gibson } 3075fa325e6cSDavid Gibson 3076fa325e6cSDavid Gibson DEFINE_SPAPR_MACHINE(2_8, "2.8", false); 3077db800b21SDavid Gibson 3078db800b21SDavid Gibson /* 30791ea1eefcSBharata B Rao * pseries-2.7 30801ea1eefcSBharata B Rao */ 3081db800b21SDavid Gibson #define SPAPR_COMPAT_2_7 \ 3082db800b21SDavid Gibson HW_COMPAT_2_7 \ 3083357d1e3bSDavid Gibson { \ 3084357d1e3bSDavid Gibson .driver = TYPE_SPAPR_PCI_HOST_BRIDGE, \ 3085357d1e3bSDavid Gibson .property = "mem_win_size", \ 3086357d1e3bSDavid Gibson .value = stringify(SPAPR_PCI_2_7_MMIO_WIN_SIZE),\ 3087357d1e3bSDavid Gibson }, \ 3088357d1e3bSDavid Gibson { \ 3089357d1e3bSDavid Gibson .driver = TYPE_SPAPR_PCI_HOST_BRIDGE, \ 3090357d1e3bSDavid Gibson .property = "mem64_win_size", \ 3091357d1e3bSDavid Gibson .value = "0", \ 3092146c11f1SDavid Gibson }, \ 3093146c11f1SDavid Gibson { \ 3094146c11f1SDavid Gibson .driver = TYPE_POWERPC_CPU, \ 3095146c11f1SDavid Gibson .property = "pre-2.8-migration", \ 3096146c11f1SDavid Gibson .value = "on", \ 30975c4537bdSDavid Gibson }, \ 30985c4537bdSDavid Gibson { \ 30995c4537bdSDavid Gibson .driver = TYPE_SPAPR_PCI_HOST_BRIDGE, \ 31005c4537bdSDavid Gibson .property = "pre-2.8-migration", \ 31015c4537bdSDavid Gibson .value = "on", \ 3102357d1e3bSDavid Gibson }, 3103357d1e3bSDavid Gibson 3104357d1e3bSDavid Gibson static void phb_placement_2_7(sPAPRMachineState *spapr, uint32_t index, 3105357d1e3bSDavid Gibson uint64_t *buid, hwaddr *pio, 3106357d1e3bSDavid Gibson hwaddr *mmio32, hwaddr *mmio64, 3107357d1e3bSDavid Gibson unsigned n_dma, uint32_t *liobns, Error **errp) 3108357d1e3bSDavid Gibson { 3109357d1e3bSDavid Gibson /* Legacy PHB placement for pseries-2.7 and earlier machine types */ 3110357d1e3bSDavid Gibson const uint64_t base_buid = 0x800000020000000ULL; 3111357d1e3bSDavid Gibson const hwaddr phb_spacing = 0x1000000000ULL; /* 64 GiB */ 3112357d1e3bSDavid Gibson const hwaddr mmio_offset = 0xa0000000; /* 2 GiB + 512 MiB */ 3113357d1e3bSDavid Gibson const hwaddr pio_offset = 0x80000000; /* 2 GiB */ 3114357d1e3bSDavid Gibson const uint32_t max_index = 255; 3115357d1e3bSDavid Gibson const hwaddr phb0_alignment = 0x10000000000ULL; /* 1 TiB */ 3116357d1e3bSDavid Gibson 3117357d1e3bSDavid Gibson uint64_t ram_top = MACHINE(spapr)->ram_size; 3118357d1e3bSDavid Gibson hwaddr phb0_base, phb_base; 3119357d1e3bSDavid Gibson int i; 3120357d1e3bSDavid Gibson 3121357d1e3bSDavid Gibson /* Do we have hotpluggable memory? */ 3122357d1e3bSDavid Gibson if (MACHINE(spapr)->maxram_size > ram_top) { 3123357d1e3bSDavid Gibson /* Can't just use maxram_size, because there may be an 3124357d1e3bSDavid Gibson * alignment gap between normal and hotpluggable memory 3125357d1e3bSDavid Gibson * regions */ 3126357d1e3bSDavid Gibson ram_top = spapr->hotplug_memory.base + 3127357d1e3bSDavid Gibson memory_region_size(&spapr->hotplug_memory.mr); 3128357d1e3bSDavid Gibson } 3129357d1e3bSDavid Gibson 3130357d1e3bSDavid Gibson phb0_base = QEMU_ALIGN_UP(ram_top, phb0_alignment); 3131357d1e3bSDavid Gibson 3132357d1e3bSDavid Gibson if (index > max_index) { 3133357d1e3bSDavid Gibson error_setg(errp, "\"index\" for PAPR PHB is too large (max %u)", 3134357d1e3bSDavid Gibson max_index); 3135357d1e3bSDavid Gibson return; 3136357d1e3bSDavid Gibson } 3137357d1e3bSDavid Gibson 3138357d1e3bSDavid Gibson *buid = base_buid + index; 3139357d1e3bSDavid Gibson for (i = 0; i < n_dma; ++i) { 3140357d1e3bSDavid Gibson liobns[i] = SPAPR_PCI_LIOBN(index, i); 3141357d1e3bSDavid Gibson } 3142357d1e3bSDavid Gibson 3143357d1e3bSDavid Gibson phb_base = phb0_base + index * phb_spacing; 3144357d1e3bSDavid Gibson *pio = phb_base + pio_offset; 3145357d1e3bSDavid Gibson *mmio32 = phb_base + mmio_offset; 3146357d1e3bSDavid Gibson /* 3147357d1e3bSDavid Gibson * We don't set the 64-bit MMIO window, relying on the PHB's 3148357d1e3bSDavid Gibson * fallback behaviour of automatically splitting a large "32-bit" 3149357d1e3bSDavid Gibson * window into contiguous 32-bit and 64-bit windows 3150357d1e3bSDavid Gibson */ 3151357d1e3bSDavid Gibson } 3152db800b21SDavid Gibson 31531ea1eefcSBharata B Rao static void spapr_machine_2_7_instance_options(MachineState *machine) 31541ea1eefcSBharata B Rao { 3155f6229214SMichael Roth sPAPRMachineState *spapr = SPAPR_MACHINE(machine); 3156f6229214SMichael Roth 3157672de881SMichael Roth spapr_machine_2_8_instance_options(machine); 3158f6229214SMichael Roth spapr->use_hotplug_event_source = false; 31591ea1eefcSBharata B Rao } 31601ea1eefcSBharata B Rao 31611ea1eefcSBharata B Rao static void spapr_machine_2_7_class_options(MachineClass *mc) 31621ea1eefcSBharata B Rao { 31633daa4a9fSThomas Huth sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); 31643daa4a9fSThomas Huth 3165db800b21SDavid Gibson spapr_machine_2_8_class_options(mc); 31663daa4a9fSThomas Huth smc->tcg_default_cpu = "POWER7"; 3167db800b21SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_7); 3168357d1e3bSDavid Gibson smc->phb_placement = phb_placement_2_7; 31691ea1eefcSBharata B Rao } 31701ea1eefcSBharata B Rao 3171db800b21SDavid Gibson DEFINE_SPAPR_MACHINE(2_7, "2.7", false); 31721ea1eefcSBharata B Rao 31731ea1eefcSBharata B Rao /* 31744b23699cSDavid Gibson * pseries-2.6 31754b23699cSDavid Gibson */ 31761ea1eefcSBharata B Rao #define SPAPR_COMPAT_2_6 \ 3177ae4de14cSAlexey Kardashevskiy HW_COMPAT_2_6 \ 3178ae4de14cSAlexey Kardashevskiy { \ 3179ae4de14cSAlexey Kardashevskiy .driver = TYPE_SPAPR_PCI_HOST_BRIDGE,\ 3180ae4de14cSAlexey Kardashevskiy .property = "ddw",\ 3181ae4de14cSAlexey Kardashevskiy .value = stringify(off),\ 3182ae4de14cSAlexey Kardashevskiy }, 31831ea1eefcSBharata B Rao 31844b23699cSDavid Gibson static void spapr_machine_2_6_instance_options(MachineState *machine) 31854b23699cSDavid Gibson { 3186672de881SMichael Roth spapr_machine_2_7_instance_options(machine); 31874b23699cSDavid Gibson } 31884b23699cSDavid Gibson 31894b23699cSDavid Gibson static void spapr_machine_2_6_class_options(MachineClass *mc) 31904b23699cSDavid Gibson { 31911ea1eefcSBharata B Rao spapr_machine_2_7_class_options(mc); 3192c5514d0eSIgor Mammedov mc->has_hotpluggable_cpus = false; 31931ea1eefcSBharata B Rao SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_6); 31944b23699cSDavid Gibson } 31954b23699cSDavid Gibson 31961ea1eefcSBharata B Rao DEFINE_SPAPR_MACHINE(2_6, "2.6", false); 31974b23699cSDavid Gibson 31984b23699cSDavid Gibson /* 31991c5f29bbSDavid Gibson * pseries-2.5 32001c5f29bbSDavid Gibson */ 32014b23699cSDavid Gibson #define SPAPR_COMPAT_2_5 \ 320257c522f4SThomas Huth HW_COMPAT_2_5 \ 320357c522f4SThomas Huth { \ 320457c522f4SThomas Huth .driver = "spapr-vlan", \ 320557c522f4SThomas Huth .property = "use-rx-buffer-pools", \ 320657c522f4SThomas Huth .value = "off", \ 320757c522f4SThomas Huth }, 32084b23699cSDavid Gibson 32095013c547SDavid Gibson static void spapr_machine_2_5_instance_options(MachineState *machine) 32101c5f29bbSDavid Gibson { 3211672de881SMichael Roth spapr_machine_2_6_instance_options(machine); 32125013c547SDavid Gibson } 32135013c547SDavid Gibson 32145013c547SDavid Gibson static void spapr_machine_2_5_class_options(MachineClass *mc) 32155013c547SDavid Gibson { 321657040d45SThomas Huth sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); 321757040d45SThomas Huth 32184b23699cSDavid Gibson spapr_machine_2_6_class_options(mc); 321957040d45SThomas Huth smc->use_ohci_by_default = true; 32204b23699cSDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_5); 32211c5f29bbSDavid Gibson } 32221c5f29bbSDavid Gibson 32234b23699cSDavid Gibson DEFINE_SPAPR_MACHINE(2_5, "2.5", false); 32241c5f29bbSDavid Gibson 32251c5f29bbSDavid Gibson /* 32261c5f29bbSDavid Gibson * pseries-2.4 32271c5f29bbSDavid Gibson */ 322880fd50f9SCornelia Huck #define SPAPR_COMPAT_2_4 \ 322980fd50f9SCornelia Huck HW_COMPAT_2_4 323080fd50f9SCornelia Huck 32315013c547SDavid Gibson static void spapr_machine_2_4_instance_options(MachineState *machine) 32321c5f29bbSDavid Gibson { 32335013c547SDavid Gibson spapr_machine_2_5_instance_options(machine); 32345013c547SDavid Gibson } 32351c5f29bbSDavid Gibson 32365013c547SDavid Gibson static void spapr_machine_2_4_class_options(MachineClass *mc) 32375013c547SDavid Gibson { 3238fc9f38c3SDavid Gibson sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); 3239fc9f38c3SDavid Gibson 3240fc9f38c3SDavid Gibson spapr_machine_2_5_class_options(mc); 3241fc9f38c3SDavid Gibson smc->dr_lmb_enabled = false; 3242f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_4); 32431c5f29bbSDavid Gibson } 32441c5f29bbSDavid Gibson 3245fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_4, "2.4", false); 32461c5f29bbSDavid Gibson 32471c5f29bbSDavid Gibson /* 32481c5f29bbSDavid Gibson * pseries-2.3 32491c5f29bbSDavid Gibson */ 325038ff32c6SEduardo Habkost #define SPAPR_COMPAT_2_3 \ 32517619c7b0SMichael Roth HW_COMPAT_2_3 \ 32527619c7b0SMichael Roth {\ 32537619c7b0SMichael Roth .driver = "spapr-pci-host-bridge",\ 32547619c7b0SMichael Roth .property = "dynamic-reconfiguration",\ 32557619c7b0SMichael Roth .value = "off",\ 32567619c7b0SMichael Roth }, 325738ff32c6SEduardo Habkost 32585013c547SDavid Gibson static void spapr_machine_2_3_instance_options(MachineState *machine) 32591c5f29bbSDavid Gibson { 32605013c547SDavid Gibson spapr_machine_2_4_instance_options(machine); 32611c5f29bbSDavid Gibson savevm_skip_section_footers(); 32621c5f29bbSDavid Gibson global_state_set_optional(); 326309b5e30dSGreg Kurz savevm_skip_configuration(); 32641c5f29bbSDavid Gibson } 32651c5f29bbSDavid Gibson 32665013c547SDavid Gibson static void spapr_machine_2_3_class_options(MachineClass *mc) 32671c5f29bbSDavid Gibson { 3268fc9f38c3SDavid Gibson spapr_machine_2_4_class_options(mc); 3269f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_3); 32701c5f29bbSDavid Gibson } 3271fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_3, "2.3", false); 32721c5f29bbSDavid Gibson 32731c5f29bbSDavid Gibson /* 32741c5f29bbSDavid Gibson * pseries-2.2 32751c5f29bbSDavid Gibson */ 32761c5f29bbSDavid Gibson 3277b194df47SAlexey Kardashevskiy #define SPAPR_COMPAT_2_2 \ 32784dfd8eaaSEduardo Habkost HW_COMPAT_2_2 \ 3279b194df47SAlexey Kardashevskiy {\ 3280b194df47SAlexey Kardashevskiy .driver = TYPE_SPAPR_PCI_HOST_BRIDGE,\ 3281b194df47SAlexey Kardashevskiy .property = "mem_win_size",\ 3282b194df47SAlexey Kardashevskiy .value = "0x20000000",\ 3283dd754bafSEduardo Habkost }, 3284b194df47SAlexey Kardashevskiy 32855013c547SDavid Gibson static void spapr_machine_2_2_instance_options(MachineState *machine) 3286b0e966d0SJason Wang { 32875013c547SDavid Gibson spapr_machine_2_3_instance_options(machine); 3288cba0e779SGreg Kurz machine->suppress_vmdesc = true; 3289b0e966d0SJason Wang } 3290b0e966d0SJason Wang 32915013c547SDavid Gibson static void spapr_machine_2_2_class_options(MachineClass *mc) 3292b0e966d0SJason Wang { 3293fc9f38c3SDavid Gibson spapr_machine_2_3_class_options(mc); 3294f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_2); 32951c5f29bbSDavid Gibson } 3296fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_2, "2.2", false); 32971c5f29bbSDavid Gibson 32981c5f29bbSDavid Gibson /* 32991c5f29bbSDavid Gibson * pseries-2.1 33001c5f29bbSDavid Gibson */ 33011c5f29bbSDavid Gibson #define SPAPR_COMPAT_2_1 \ 33021c5f29bbSDavid Gibson HW_COMPAT_2_1 33031c5f29bbSDavid Gibson 33045013c547SDavid Gibson static void spapr_machine_2_1_instance_options(MachineState *machine) 33051c5f29bbSDavid Gibson { 33065013c547SDavid Gibson spapr_machine_2_2_instance_options(machine); 33071c5f29bbSDavid Gibson } 33081c5f29bbSDavid Gibson 33095013c547SDavid Gibson static void spapr_machine_2_1_class_options(MachineClass *mc) 3310b0e966d0SJason Wang { 3311fc9f38c3SDavid Gibson spapr_machine_2_2_class_options(mc); 3312f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_1); 33136026db45SAlexey Kardashevskiy } 3314fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_1, "2.1", false); 33156026db45SAlexey Kardashevskiy 331629ee3247SAlexey Kardashevskiy static void spapr_machine_register_types(void) 331729ee3247SAlexey Kardashevskiy { 331829ee3247SAlexey Kardashevskiy type_register_static(&spapr_machine_info); 331929ee3247SAlexey Kardashevskiy } 332029ee3247SAlexey Kardashevskiy 332129ee3247SAlexey Kardashevskiy type_init(spapr_machine_register_types) 3322