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" 666449da45SCédric Le Goater #include "hw/intc/intc.h" 6753018216SPaolo Bonzini 6868a27b20SMichael S. Tsirkin #include "hw/compat.h" 69f348b6d1SVeronia Bahaa #include "qemu/cutils.h" 7094a94e4cSBharata B Rao #include "hw/ppc/spapr_cpu_core.h" 712474bfd4SIgor Mammedov #include "qmp-commands.h" 7268a27b20SMichael S. Tsirkin 7353018216SPaolo Bonzini #include <libfdt.h> 7453018216SPaolo Bonzini 7553018216SPaolo Bonzini /* SLOF memory layout: 7653018216SPaolo Bonzini * 7753018216SPaolo Bonzini * SLOF raw image loaded at 0, copies its romfs right below the flat 7853018216SPaolo Bonzini * device-tree, then position SLOF itself 31M below that 7953018216SPaolo Bonzini * 8053018216SPaolo Bonzini * So we set FW_OVERHEAD to 40MB which should account for all of that 8153018216SPaolo Bonzini * and more 8253018216SPaolo Bonzini * 8353018216SPaolo Bonzini * We load our kernel at 4M, leaving space for SLOF initial image 8453018216SPaolo Bonzini */ 8538b02bd8SAlexey Kardashevskiy #define FDT_MAX_SIZE 0x100000 8653018216SPaolo Bonzini #define RTAS_MAX_SIZE 0x10000 87b7d1f77aSBenjamin Herrenschmidt #define RTAS_MAX_ADDR 0x80000000 /* RTAS must stay below that */ 8853018216SPaolo Bonzini #define FW_MAX_SIZE 0x400000 8953018216SPaolo Bonzini #define FW_FILE_NAME "slof.bin" 9053018216SPaolo Bonzini #define FW_OVERHEAD 0x2800000 9153018216SPaolo Bonzini #define KERNEL_LOAD_ADDR FW_MAX_SIZE 9253018216SPaolo Bonzini 9353018216SPaolo Bonzini #define MIN_RMA_SLOF 128UL 9453018216SPaolo Bonzini 9553018216SPaolo Bonzini #define PHANDLE_XICP 0x00001111 9653018216SPaolo Bonzini 9753018216SPaolo Bonzini #define HTAB_SIZE(spapr) (1ULL << ((spapr)->htab_shift)) 9853018216SPaolo Bonzini 99e6f7e110SCédric Le Goater static int try_create_xics(sPAPRMachineState *spapr, const char *type_ics, 100817bb6a4SCédric Le Goater const char *type_icp, int nr_servers, 101817bb6a4SCédric Le Goater int nr_irqs, Error **errp) 102c04d6cfaSAnthony Liguori { 1032cd908d0SCédric Le Goater XICSFabric *xi = XICS_FABRIC(spapr); 1044e4169f7SCédric Le Goater Error *err = NULL, *local_err = NULL; 1054e4169f7SCédric Le Goater ICSState *ics = NULL; 106817bb6a4SCédric Le Goater int i; 107c04d6cfaSAnthony Liguori 1084e4169f7SCédric Le Goater ics = ICS_SIMPLE(object_new(type_ics)); 109681bfadeSCédric Le Goater object_property_add_child(OBJECT(spapr), "ics", OBJECT(ics), NULL); 1104e4169f7SCédric Le Goater object_property_set_int(OBJECT(ics), nr_irqs, "nr-irqs", &err); 111b4f27d71SCédric Le Goater object_property_add_const_link(OBJECT(ics), "xics", OBJECT(xi), NULL); 1124e4169f7SCédric Le Goater object_property_set_bool(OBJECT(ics), true, "realized", &local_err); 1134e4169f7SCédric Le Goater error_propagate(&err, local_err); 1144e4169f7SCédric Le Goater if (err) { 1154e4169f7SCédric Le Goater goto error; 1164e4169f7SCédric Le Goater } 1174e4169f7SCédric Le Goater 118852ad27eSCédric Le Goater spapr->icps = g_malloc0(nr_servers * sizeof(ICPState)); 119852ad27eSCédric Le Goater spapr->nr_servers = nr_servers; 120817bb6a4SCédric Le Goater 121817bb6a4SCédric Le Goater for (i = 0; i < nr_servers; i++) { 122852ad27eSCédric Le Goater ICPState *icp = &spapr->icps[i]; 123817bb6a4SCédric Le Goater 124817bb6a4SCédric Le Goater object_initialize(icp, sizeof(*icp), type_icp); 125852ad27eSCédric Le Goater object_property_add_child(OBJECT(spapr), "icp[*]", OBJECT(icp), NULL); 1262cd908d0SCédric Le Goater object_property_add_const_link(OBJECT(icp), "xics", OBJECT(xi), NULL); 127817bb6a4SCédric Le Goater object_property_set_bool(OBJECT(icp), true, "realized", &err); 128817bb6a4SCédric Le Goater if (err) { 129817bb6a4SCédric Le Goater goto error; 130817bb6a4SCédric Le Goater } 131817bb6a4SCédric Le Goater object_unref(OBJECT(icp)); 132817bb6a4SCédric Le Goater } 133817bb6a4SCédric Le Goater 134681bfadeSCédric Le Goater spapr->ics = ics; 135e6f7e110SCédric Le Goater return 0; 1364e4169f7SCédric Le Goater 1374e4169f7SCédric Le Goater error: 1384e4169f7SCédric Le Goater error_propagate(errp, err); 1394e4169f7SCédric Le Goater if (ics) { 1404e4169f7SCédric Le Goater object_unparent(OBJECT(ics)); 1414e4169f7SCédric Le Goater } 142e6f7e110SCédric Le Goater return -1; 143c04d6cfaSAnthony Liguori } 144c04d6cfaSAnthony Liguori 145e6f7e110SCédric Le Goater static int xics_system_init(MachineState *machine, 1461e49182dSDavid Gibson int nr_servers, int nr_irqs, Error **errp) 147c04d6cfaSAnthony Liguori { 148e6f7e110SCédric Le Goater int rc = -1; 149c04d6cfaSAnthony Liguori 15011ad93f6SDavid Gibson if (kvm_enabled()) { 15134f2af3dSMarkus Armbruster Error *err = NULL; 15234f2af3dSMarkus Armbruster 1532192a930SCédric Le Goater if (machine_kernel_irqchip_allowed(machine) && 1542192a930SCédric Le Goater !xics_kvm_init(SPAPR_MACHINE(machine), errp)) { 155e6f7e110SCédric Le Goater rc = try_create_xics(SPAPR_MACHINE(machine), TYPE_ICS_KVM, 156817bb6a4SCédric Le Goater TYPE_KVM_ICP, nr_servers, nr_irqs, &err); 15711ad93f6SDavid Gibson } 158e6f7e110SCédric Le Goater if (machine_kernel_irqchip_required(machine) && rc < 0) { 159b83baa60SMarkus Armbruster error_reportf_err(err, 160b83baa60SMarkus Armbruster "kernel_irqchip requested but unavailable: "); 161b83baa60SMarkus Armbruster } else { 162903a41d3SStefano Dong (董兴水) error_free(err); 16311ad93f6SDavid Gibson } 164b83baa60SMarkus Armbruster } 16511ad93f6SDavid Gibson 166e6f7e110SCédric Le Goater if (rc < 0) { 1672192a930SCédric Le Goater xics_spapr_init(SPAPR_MACHINE(machine), errp); 168e6f7e110SCédric Le Goater rc = try_create_xics(SPAPR_MACHINE(machine), TYPE_ICS_SIMPLE, 169681bfadeSCédric Le Goater TYPE_ICP, nr_servers, nr_irqs, errp); 170c04d6cfaSAnthony Liguori } 171c04d6cfaSAnthony Liguori 172e6f7e110SCédric Le Goater return rc; 173c04d6cfaSAnthony Liguori } 174c04d6cfaSAnthony Liguori 175833d4668SAlexey Kardashevskiy static int spapr_fixup_cpu_smt_dt(void *fdt, int offset, PowerPCCPU *cpu, 176833d4668SAlexey Kardashevskiy int smt_threads) 177833d4668SAlexey Kardashevskiy { 178833d4668SAlexey Kardashevskiy int i, ret = 0; 179833d4668SAlexey Kardashevskiy uint32_t servers_prop[smt_threads]; 180833d4668SAlexey Kardashevskiy uint32_t gservers_prop[smt_threads * 2]; 181833d4668SAlexey Kardashevskiy int index = ppc_get_vcpu_dt_id(cpu); 182833d4668SAlexey Kardashevskiy 183d6e166c0SDavid Gibson if (cpu->compat_pvr) { 184d6e166c0SDavid Gibson ret = fdt_setprop_cell(fdt, offset, "cpu-version", cpu->compat_pvr); 1856d9412eaSAlexey Kardashevskiy if (ret < 0) { 1866d9412eaSAlexey Kardashevskiy return ret; 1876d9412eaSAlexey Kardashevskiy } 1886d9412eaSAlexey Kardashevskiy } 1896d9412eaSAlexey Kardashevskiy 190833d4668SAlexey Kardashevskiy /* Build interrupt servers and gservers properties */ 191833d4668SAlexey Kardashevskiy for (i = 0; i < smt_threads; i++) { 192833d4668SAlexey Kardashevskiy servers_prop[i] = cpu_to_be32(index + i); 193833d4668SAlexey Kardashevskiy /* Hack, direct the group queues back to cpu 0 */ 194833d4668SAlexey Kardashevskiy gservers_prop[i*2] = cpu_to_be32(index + i); 195833d4668SAlexey Kardashevskiy gservers_prop[i*2 + 1] = 0; 196833d4668SAlexey Kardashevskiy } 197833d4668SAlexey Kardashevskiy ret = fdt_setprop(fdt, offset, "ibm,ppc-interrupt-server#s", 198833d4668SAlexey Kardashevskiy servers_prop, sizeof(servers_prop)); 199833d4668SAlexey Kardashevskiy if (ret < 0) { 200833d4668SAlexey Kardashevskiy return ret; 201833d4668SAlexey Kardashevskiy } 202833d4668SAlexey Kardashevskiy ret = fdt_setprop(fdt, offset, "ibm,ppc-interrupt-gserver#s", 203833d4668SAlexey Kardashevskiy gservers_prop, sizeof(gservers_prop)); 204833d4668SAlexey Kardashevskiy 205833d4668SAlexey Kardashevskiy return ret; 206833d4668SAlexey Kardashevskiy } 207833d4668SAlexey Kardashevskiy 2080da6f3feSBharata B Rao static int spapr_fixup_cpu_numa_dt(void *fdt, int offset, CPUState *cs) 2090da6f3feSBharata B Rao { 2100da6f3feSBharata B Rao int ret = 0; 2110da6f3feSBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(cs); 2120da6f3feSBharata B Rao int index = ppc_get_vcpu_dt_id(cpu); 2130da6f3feSBharata B Rao uint32_t associativity[] = {cpu_to_be32(0x5), 2140da6f3feSBharata B Rao cpu_to_be32(0x0), 2150da6f3feSBharata B Rao cpu_to_be32(0x0), 2160da6f3feSBharata B Rao cpu_to_be32(0x0), 2170da6f3feSBharata B Rao cpu_to_be32(cs->numa_node), 2180da6f3feSBharata B Rao cpu_to_be32(index)}; 2190da6f3feSBharata B Rao 2200da6f3feSBharata B Rao /* Advertise NUMA via ibm,associativity */ 2210da6f3feSBharata B Rao if (nb_numa_nodes > 1) { 2220da6f3feSBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,associativity", associativity, 2230da6f3feSBharata B Rao sizeof(associativity)); 2240da6f3feSBharata B Rao } 2250da6f3feSBharata B Rao 2260da6f3feSBharata B Rao return ret; 2270da6f3feSBharata B Rao } 2280da6f3feSBharata B Rao 22928e02042SDavid Gibson static int spapr_fixup_cpu_dt(void *fdt, sPAPRMachineState *spapr) 23053018216SPaolo Bonzini { 23182677ed2SAlexey Kardashevskiy int ret = 0, offset, cpus_offset; 23282677ed2SAlexey Kardashevskiy CPUState *cs; 23353018216SPaolo Bonzini char cpu_model[32]; 23453018216SPaolo Bonzini int smt = kvmppc_smt_threads(); 23553018216SPaolo Bonzini uint32_t pft_size_prop[] = {0, cpu_to_be32(spapr->htab_shift)}; 23653018216SPaolo Bonzini 23782677ed2SAlexey Kardashevskiy CPU_FOREACH(cs) { 23882677ed2SAlexey Kardashevskiy PowerPCCPU *cpu = POWERPC_CPU(cs); 23982677ed2SAlexey Kardashevskiy DeviceClass *dc = DEVICE_GET_CLASS(cs); 24082677ed2SAlexey Kardashevskiy int index = ppc_get_vcpu_dt_id(cpu); 24112dbeb16SDavid Gibson int compat_smt = MIN(smp_threads, ppc_compat_max_threads(cpu)); 24253018216SPaolo Bonzini 2430f20ba62SAlexey Kardashevskiy if ((index % smt) != 0) { 24453018216SPaolo Bonzini continue; 24553018216SPaolo Bonzini } 24653018216SPaolo Bonzini 24782677ed2SAlexey Kardashevskiy snprintf(cpu_model, 32, "%s@%x", dc->fw_name, index); 24853018216SPaolo Bonzini 24982677ed2SAlexey Kardashevskiy cpus_offset = fdt_path_offset(fdt, "/cpus"); 25082677ed2SAlexey Kardashevskiy if (cpus_offset < 0) { 25182677ed2SAlexey Kardashevskiy cpus_offset = fdt_add_subnode(fdt, fdt_path_offset(fdt, "/"), 25282677ed2SAlexey Kardashevskiy "cpus"); 25382677ed2SAlexey Kardashevskiy if (cpus_offset < 0) { 25482677ed2SAlexey Kardashevskiy return cpus_offset; 25582677ed2SAlexey Kardashevskiy } 25682677ed2SAlexey Kardashevskiy } 25782677ed2SAlexey Kardashevskiy offset = fdt_subnode_offset(fdt, cpus_offset, cpu_model); 25882677ed2SAlexey Kardashevskiy if (offset < 0) { 25982677ed2SAlexey Kardashevskiy offset = fdt_add_subnode(fdt, cpus_offset, cpu_model); 26053018216SPaolo Bonzini if (offset < 0) { 26153018216SPaolo Bonzini return offset; 26253018216SPaolo Bonzini } 26382677ed2SAlexey Kardashevskiy } 26453018216SPaolo Bonzini 2650da6f3feSBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,pft-size", 2660da6f3feSBharata B Rao pft_size_prop, sizeof(pft_size_prop)); 26753018216SPaolo Bonzini if (ret < 0) { 26853018216SPaolo Bonzini return ret; 26953018216SPaolo Bonzini } 27053018216SPaolo Bonzini 2710da6f3feSBharata B Rao ret = spapr_fixup_cpu_numa_dt(fdt, offset, cs); 27253018216SPaolo Bonzini if (ret < 0) { 27353018216SPaolo Bonzini return ret; 27453018216SPaolo Bonzini } 275833d4668SAlexey Kardashevskiy 27612dbeb16SDavid Gibson ret = spapr_fixup_cpu_smt_dt(fdt, offset, cpu, compat_smt); 277833d4668SAlexey Kardashevskiy if (ret < 0) { 278833d4668SAlexey Kardashevskiy return ret; 279833d4668SAlexey Kardashevskiy } 28053018216SPaolo Bonzini } 28153018216SPaolo Bonzini return ret; 28253018216SPaolo Bonzini } 28353018216SPaolo Bonzini 284b082d65aSAlexey Kardashevskiy static hwaddr spapr_node0_size(void) 285b082d65aSAlexey Kardashevskiy { 286fb164994SDavid Gibson MachineState *machine = MACHINE(qdev_get_machine()); 287fb164994SDavid Gibson 288b082d65aSAlexey Kardashevskiy if (nb_numa_nodes) { 289b082d65aSAlexey Kardashevskiy int i; 290b082d65aSAlexey Kardashevskiy for (i = 0; i < nb_numa_nodes; ++i) { 291b082d65aSAlexey Kardashevskiy if (numa_info[i].node_mem) { 292fb164994SDavid Gibson return MIN(pow2floor(numa_info[i].node_mem), 293fb164994SDavid Gibson machine->ram_size); 294b082d65aSAlexey Kardashevskiy } 295b082d65aSAlexey Kardashevskiy } 296b082d65aSAlexey Kardashevskiy } 297fb164994SDavid Gibson return machine->ram_size; 298b082d65aSAlexey Kardashevskiy } 299b082d65aSAlexey Kardashevskiy 300a1d59c0fSAlexey Kardashevskiy static void add_str(GString *s, const gchar *s1) 301a1d59c0fSAlexey Kardashevskiy { 302a1d59c0fSAlexey Kardashevskiy g_string_append_len(s, s1, strlen(s1) + 1); 303a1d59c0fSAlexey Kardashevskiy } 30453018216SPaolo Bonzini 30503d196b7SBharata B Rao static int spapr_populate_memory_node(void *fdt, int nodeid, hwaddr start, 30626a8c353SAlexey Kardashevskiy hwaddr size) 30726a8c353SAlexey Kardashevskiy { 30826a8c353SAlexey Kardashevskiy uint32_t associativity[] = { 30926a8c353SAlexey Kardashevskiy cpu_to_be32(0x4), /* length */ 31026a8c353SAlexey Kardashevskiy cpu_to_be32(0x0), cpu_to_be32(0x0), 311c3b4f589SAlexey Kardashevskiy cpu_to_be32(0x0), cpu_to_be32(nodeid) 31226a8c353SAlexey Kardashevskiy }; 31326a8c353SAlexey Kardashevskiy char mem_name[32]; 31426a8c353SAlexey Kardashevskiy uint64_t mem_reg_property[2]; 31526a8c353SAlexey Kardashevskiy int off; 31626a8c353SAlexey Kardashevskiy 31726a8c353SAlexey Kardashevskiy mem_reg_property[0] = cpu_to_be64(start); 31826a8c353SAlexey Kardashevskiy mem_reg_property[1] = cpu_to_be64(size); 31926a8c353SAlexey Kardashevskiy 32026a8c353SAlexey Kardashevskiy sprintf(mem_name, "memory@" TARGET_FMT_lx, start); 32126a8c353SAlexey Kardashevskiy off = fdt_add_subnode(fdt, 0, mem_name); 32226a8c353SAlexey Kardashevskiy _FDT(off); 32326a8c353SAlexey Kardashevskiy _FDT((fdt_setprop_string(fdt, off, "device_type", "memory"))); 32426a8c353SAlexey Kardashevskiy _FDT((fdt_setprop(fdt, off, "reg", mem_reg_property, 32526a8c353SAlexey Kardashevskiy sizeof(mem_reg_property)))); 32626a8c353SAlexey Kardashevskiy _FDT((fdt_setprop(fdt, off, "ibm,associativity", associativity, 32726a8c353SAlexey Kardashevskiy sizeof(associativity)))); 32803d196b7SBharata B Rao return off; 32926a8c353SAlexey Kardashevskiy } 33026a8c353SAlexey Kardashevskiy 33128e02042SDavid Gibson static int spapr_populate_memory(sPAPRMachineState *spapr, void *fdt) 33253018216SPaolo Bonzini { 333fb164994SDavid Gibson MachineState *machine = MACHINE(spapr); 3347db8a127SAlexey Kardashevskiy hwaddr mem_start, node_size; 3357db8a127SAlexey Kardashevskiy int i, nb_nodes = nb_numa_nodes; 3367db8a127SAlexey Kardashevskiy NodeInfo *nodes = numa_info; 3377db8a127SAlexey Kardashevskiy NodeInfo ramnode; 33853018216SPaolo Bonzini 3397db8a127SAlexey Kardashevskiy /* No NUMA nodes, assume there is just one node with whole RAM */ 3407db8a127SAlexey Kardashevskiy if (!nb_numa_nodes) { 3417db8a127SAlexey Kardashevskiy nb_nodes = 1; 342fb164994SDavid Gibson ramnode.node_mem = machine->ram_size; 3437db8a127SAlexey Kardashevskiy nodes = &ramnode; 3445fe269b1SPaul Mackerras } 34553018216SPaolo Bonzini 3467db8a127SAlexey Kardashevskiy for (i = 0, mem_start = 0; i < nb_nodes; ++i) { 3477db8a127SAlexey Kardashevskiy if (!nodes[i].node_mem) { 3487db8a127SAlexey Kardashevskiy continue; 34953018216SPaolo Bonzini } 350fb164994SDavid Gibson if (mem_start >= machine->ram_size) { 3515fe269b1SPaul Mackerras node_size = 0; 3525fe269b1SPaul Mackerras } else { 3537db8a127SAlexey Kardashevskiy node_size = nodes[i].node_mem; 354fb164994SDavid Gibson if (node_size > machine->ram_size - mem_start) { 355fb164994SDavid Gibson node_size = machine->ram_size - mem_start; 3565fe269b1SPaul Mackerras } 3575fe269b1SPaul Mackerras } 3587db8a127SAlexey Kardashevskiy if (!mem_start) { 3597db8a127SAlexey Kardashevskiy /* ppc_spapr_init() checks for rma_size <= node0_size already */ 360e8f986fcSBharata B Rao spapr_populate_memory_node(fdt, i, 0, spapr->rma_size); 3617db8a127SAlexey Kardashevskiy mem_start += spapr->rma_size; 3627db8a127SAlexey Kardashevskiy node_size -= spapr->rma_size; 3637db8a127SAlexey Kardashevskiy } 3646010818cSAlexey Kardashevskiy for ( ; node_size; ) { 3656010818cSAlexey Kardashevskiy hwaddr sizetmp = pow2floor(node_size); 3666010818cSAlexey Kardashevskiy 3676010818cSAlexey Kardashevskiy /* mem_start != 0 here */ 3686010818cSAlexey Kardashevskiy if (ctzl(mem_start) < ctzl(sizetmp)) { 3696010818cSAlexey Kardashevskiy sizetmp = 1ULL << ctzl(mem_start); 3706010818cSAlexey Kardashevskiy } 3716010818cSAlexey Kardashevskiy 3726010818cSAlexey Kardashevskiy spapr_populate_memory_node(fdt, i, mem_start, sizetmp); 3736010818cSAlexey Kardashevskiy node_size -= sizetmp; 3746010818cSAlexey Kardashevskiy mem_start += sizetmp; 3756010818cSAlexey Kardashevskiy } 37653018216SPaolo Bonzini } 37753018216SPaolo Bonzini 37853018216SPaolo Bonzini return 0; 37953018216SPaolo Bonzini } 38053018216SPaolo Bonzini 381230bf719SThomas Huth /* Populate the "ibm,pa-features" property */ 382230bf719SThomas Huth static void spapr_populate_pa_features(CPUPPCState *env, void *fdt, int offset) 383230bf719SThomas Huth { 384230bf719SThomas Huth uint8_t pa_features_206[] = { 6, 0, 385230bf719SThomas Huth 0xf6, 0x1f, 0xc7, 0x00, 0x80, 0xc0 }; 386230bf719SThomas Huth uint8_t pa_features_207[] = { 24, 0, 387230bf719SThomas Huth 0xf6, 0x1f, 0xc7, 0xc0, 0x80, 0xf0, 388230bf719SThomas Huth 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 389230bf719SThomas Huth 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 390bac3bf28SThomas Huth 0x80, 0x00, 0x80, 0x00, 0x00, 0x00 }; 3914975c098SSuraj Jitindar Singh /* Currently we don't advertise any of the "new" ISAv3.00 functionality */ 3924975c098SSuraj Jitindar Singh uint8_t pa_features_300[] = { 64, 0, 3934975c098SSuraj Jitindar Singh 0xf6, 0x1f, 0xc7, 0xc0, 0x80, 0xf0, /* 0 - 5 */ 3944975c098SSuraj Jitindar Singh 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, /* 6 - 11 */ 3954975c098SSuraj Jitindar Singh 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, /* 12 - 17 */ 3964975c098SSuraj Jitindar Singh 0x80, 0x00, 0x80, 0x00, 0x00, 0x00, /* 18 - 23 */ 3974975c098SSuraj Jitindar Singh 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 24 - 29 */ 3984975c098SSuraj Jitindar Singh 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 30 - 35 */ 3994975c098SSuraj Jitindar Singh 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 36 - 41 */ 4004975c098SSuraj Jitindar Singh 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 42 - 47 */ 4014975c098SSuraj Jitindar Singh 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 48 - 53 */ 4024975c098SSuraj Jitindar Singh 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 54 - 59 */ 4034975c098SSuraj Jitindar Singh 0x00, 0x00, 0x00, 0x00 }; /* 60 - 63 */ 4044975c098SSuraj Jitindar Singh 405230bf719SThomas Huth uint8_t *pa_features; 406230bf719SThomas Huth size_t pa_size; 407230bf719SThomas Huth 408ec975e83SSam Bobroff switch (POWERPC_MMU_VER(env->mmu_model)) { 409ec975e83SSam Bobroff case POWERPC_MMU_VER_2_06: 410230bf719SThomas Huth pa_features = pa_features_206; 411230bf719SThomas Huth pa_size = sizeof(pa_features_206); 4124cbec30dSThomas Huth break; 413ec975e83SSam Bobroff case POWERPC_MMU_VER_2_07: 414230bf719SThomas Huth pa_features = pa_features_207; 415230bf719SThomas Huth pa_size = sizeof(pa_features_207); 4164cbec30dSThomas Huth break; 417ec975e83SSam Bobroff case POWERPC_MMU_VER_3_00: 4184975c098SSuraj Jitindar Singh pa_features = pa_features_300; 4194975c098SSuraj Jitindar Singh pa_size = sizeof(pa_features_300); 4204975c098SSuraj Jitindar Singh break; 4214cbec30dSThomas Huth default: 4224cbec30dSThomas Huth return; 423230bf719SThomas Huth } 424230bf719SThomas Huth 425230bf719SThomas Huth if (env->ci_large_pages) { 426230bf719SThomas Huth /* 427230bf719SThomas Huth * Note: we keep CI large pages off by default because a 64K capable 428230bf719SThomas Huth * guest provisioned with large pages might otherwise try to map a qemu 429230bf719SThomas Huth * framebuffer (or other kind of memory mapped PCI BAR) using 64K pages 430230bf719SThomas Huth * even if that qemu runs on a 4k host. 431230bf719SThomas Huth * We dd this bit back here if we are confident this is not an issue 432230bf719SThomas Huth */ 433230bf719SThomas Huth pa_features[3] |= 0x20; 434230bf719SThomas Huth } 435bac3bf28SThomas Huth if (kvmppc_has_cap_htm() && pa_size > 24) { 436bac3bf28SThomas Huth pa_features[24] |= 0x80; /* Transactional memory support */ 437bac3bf28SThomas Huth } 438230bf719SThomas Huth 439230bf719SThomas Huth _FDT((fdt_setprop(fdt, offset, "ibm,pa-features", pa_features, pa_size))); 440230bf719SThomas Huth } 441230bf719SThomas Huth 4420da6f3feSBharata B Rao static void spapr_populate_cpu_dt(CPUState *cs, void *fdt, int offset, 4430da6f3feSBharata B Rao sPAPRMachineState *spapr) 4440da6f3feSBharata B Rao { 4450da6f3feSBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(cs); 4460da6f3feSBharata B Rao CPUPPCState *env = &cpu->env; 4470da6f3feSBharata B Rao PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(cs); 4480da6f3feSBharata B Rao int index = ppc_get_vcpu_dt_id(cpu); 4490da6f3feSBharata B Rao uint32_t segs[] = {cpu_to_be32(28), cpu_to_be32(40), 4500da6f3feSBharata B Rao 0xffffffff, 0xffffffff}; 451afd10a0fSBharata B Rao uint32_t tbfreq = kvm_enabled() ? kvmppc_get_tbfreq() 452afd10a0fSBharata B Rao : SPAPR_TIMEBASE_FREQ; 4530da6f3feSBharata B Rao uint32_t cpufreq = kvm_enabled() ? kvmppc_get_clockfreq() : 1000000000; 4540da6f3feSBharata B Rao uint32_t page_sizes_prop[64]; 4550da6f3feSBharata B Rao size_t page_sizes_prop_size; 45622419c2aSDavid Gibson uint32_t vcpus_per_socket = smp_threads * smp_cores; 4570da6f3feSBharata B Rao uint32_t pft_size_prop[] = {0, cpu_to_be32(spapr->htab_shift)}; 45812dbeb16SDavid Gibson int compat_smt = MIN(smp_threads, ppc_compat_max_threads(cpu)); 459af81cf32SBharata B Rao sPAPRDRConnector *drc; 460af81cf32SBharata B Rao sPAPRDRConnectorClass *drck; 461af81cf32SBharata B Rao int drc_index; 462*c64abd1fSSam Bobroff uint32_t radix_AP_encodings[PPC_PAGE_SIZES_MAX_SZ]; 463*c64abd1fSSam Bobroff int i; 464af81cf32SBharata B Rao 465af81cf32SBharata B Rao drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_CPU, index); 466af81cf32SBharata B Rao if (drc) { 467af81cf32SBharata B Rao drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 468af81cf32SBharata B Rao drc_index = drck->get_index(drc); 469af81cf32SBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,my-drc-index", drc_index))); 470af81cf32SBharata B Rao } 4710da6f3feSBharata B Rao 4720da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "reg", index))); 4730da6f3feSBharata B Rao _FDT((fdt_setprop_string(fdt, offset, "device_type", "cpu"))); 4740da6f3feSBharata B Rao 4750da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "cpu-version", env->spr[SPR_PVR]))); 4760da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "d-cache-block-size", 4770da6f3feSBharata B Rao env->dcache_line_size))); 4780da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "d-cache-line-size", 4790da6f3feSBharata B Rao env->dcache_line_size))); 4800da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "i-cache-block-size", 4810da6f3feSBharata B Rao env->icache_line_size))); 4820da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "i-cache-line-size", 4830da6f3feSBharata B Rao env->icache_line_size))); 4840da6f3feSBharata B Rao 4850da6f3feSBharata B Rao if (pcc->l1_dcache_size) { 4860da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "d-cache-size", 4870da6f3feSBharata B Rao pcc->l1_dcache_size))); 4880da6f3feSBharata B Rao } else { 489ce9863b7SCédric Le Goater error_report("Warning: Unknown L1 dcache size for cpu"); 4900da6f3feSBharata B Rao } 4910da6f3feSBharata B Rao if (pcc->l1_icache_size) { 4920da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "i-cache-size", 4930da6f3feSBharata B Rao pcc->l1_icache_size))); 4940da6f3feSBharata B Rao } else { 495ce9863b7SCédric Le Goater error_report("Warning: Unknown L1 icache size for cpu"); 4960da6f3feSBharata B Rao } 4970da6f3feSBharata B Rao 4980da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "timebase-frequency", tbfreq))); 4990da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "clock-frequency", cpufreq))); 500fd5da5c4SThomas Huth _FDT((fdt_setprop_cell(fdt, offset, "slb-size", env->slb_nr))); 5010da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,slb-size", env->slb_nr))); 5020da6f3feSBharata B Rao _FDT((fdt_setprop_string(fdt, offset, "status", "okay"))); 5030da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "64-bit", NULL, 0))); 5040da6f3feSBharata B Rao 5050da6f3feSBharata B Rao if (env->spr_cb[SPR_PURR].oea_read) { 5060da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,purr", NULL, 0))); 5070da6f3feSBharata B Rao } 5080da6f3feSBharata B Rao 5090da6f3feSBharata B Rao if (env->mmu_model & POWERPC_MMU_1TSEG) { 5100da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,processor-segment-sizes", 5110da6f3feSBharata B Rao segs, sizeof(segs)))); 5120da6f3feSBharata B Rao } 5130da6f3feSBharata B Rao 5140da6f3feSBharata B Rao /* Advertise VMX/VSX (vector extensions) if available 5150da6f3feSBharata B Rao * 0 / no property == no vector extensions 5160da6f3feSBharata B Rao * 1 == VMX / Altivec available 5170da6f3feSBharata B Rao * 2 == VSX available */ 5180da6f3feSBharata B Rao if (env->insns_flags & PPC_ALTIVEC) { 5190da6f3feSBharata B Rao uint32_t vmx = (env->insns_flags2 & PPC2_VSX) ? 2 : 1; 5200da6f3feSBharata B Rao 5210da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,vmx", vmx))); 5220da6f3feSBharata B Rao } 5230da6f3feSBharata B Rao 5240da6f3feSBharata B Rao /* Advertise DFP (Decimal Floating Point) if available 5250da6f3feSBharata B Rao * 0 / no property == no DFP 5260da6f3feSBharata B Rao * 1 == DFP available */ 5270da6f3feSBharata B Rao if (env->insns_flags2 & PPC2_DFP) { 5280da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,dfp", 1))); 5290da6f3feSBharata B Rao } 5300da6f3feSBharata B Rao 5313654fa95SCédric Le Goater page_sizes_prop_size = ppc_create_page_sizes_prop(env, page_sizes_prop, 5320da6f3feSBharata B Rao sizeof(page_sizes_prop)); 5330da6f3feSBharata B Rao if (page_sizes_prop_size) { 5340da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,segment-page-sizes", 5350da6f3feSBharata B Rao page_sizes_prop, page_sizes_prop_size))); 5360da6f3feSBharata B Rao } 5370da6f3feSBharata B Rao 538230bf719SThomas Huth spapr_populate_pa_features(env, fdt, offset); 53990da0d5aSBenjamin Herrenschmidt 5400da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,chip-id", 54122419c2aSDavid Gibson cs->cpu_index / vcpus_per_socket))); 5420da6f3feSBharata B Rao 5430da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,pft-size", 5440da6f3feSBharata B Rao pft_size_prop, sizeof(pft_size_prop)))); 5450da6f3feSBharata B Rao 5460da6f3feSBharata B Rao _FDT(spapr_fixup_cpu_numa_dt(fdt, offset, cs)); 5470da6f3feSBharata B Rao 54812dbeb16SDavid Gibson _FDT(spapr_fixup_cpu_smt_dt(fdt, offset, cpu, compat_smt)); 549*c64abd1fSSam Bobroff 550*c64abd1fSSam Bobroff if (pcc->radix_page_info) { 551*c64abd1fSSam Bobroff for (i = 0; i < pcc->radix_page_info->count; i++) { 552*c64abd1fSSam Bobroff radix_AP_encodings[i] = 553*c64abd1fSSam Bobroff cpu_to_be32(pcc->radix_page_info->entries[i]); 554*c64abd1fSSam Bobroff } 555*c64abd1fSSam Bobroff _FDT((fdt_setprop(fdt, offset, "ibm,processor-radix-AP-encodings", 556*c64abd1fSSam Bobroff radix_AP_encodings, 557*c64abd1fSSam Bobroff pcc->radix_page_info->count * 558*c64abd1fSSam Bobroff sizeof(radix_AP_encodings[0])))); 559*c64abd1fSSam Bobroff } 5600da6f3feSBharata B Rao } 5610da6f3feSBharata B Rao 5620da6f3feSBharata B Rao static void spapr_populate_cpus_dt_node(void *fdt, sPAPRMachineState *spapr) 5630da6f3feSBharata B Rao { 5640da6f3feSBharata B Rao CPUState *cs; 5650da6f3feSBharata B Rao int cpus_offset; 5660da6f3feSBharata B Rao char *nodename; 5670da6f3feSBharata B Rao int smt = kvmppc_smt_threads(); 5680da6f3feSBharata B Rao 5690da6f3feSBharata B Rao cpus_offset = fdt_add_subnode(fdt, 0, "cpus"); 5700da6f3feSBharata B Rao _FDT(cpus_offset); 5710da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, cpus_offset, "#address-cells", 0x1))); 5720da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, cpus_offset, "#size-cells", 0x0))); 5730da6f3feSBharata B Rao 5740da6f3feSBharata B Rao /* 5750da6f3feSBharata B Rao * We walk the CPUs in reverse order to ensure that CPU DT nodes 5760da6f3feSBharata B Rao * created by fdt_add_subnode() end up in the right order in FDT 5770da6f3feSBharata B Rao * for the guest kernel the enumerate the CPUs correctly. 5780da6f3feSBharata B Rao */ 5790da6f3feSBharata B Rao CPU_FOREACH_REVERSE(cs) { 5800da6f3feSBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(cs); 5810da6f3feSBharata B Rao int index = ppc_get_vcpu_dt_id(cpu); 5820da6f3feSBharata B Rao DeviceClass *dc = DEVICE_GET_CLASS(cs); 5830da6f3feSBharata B Rao int offset; 5840da6f3feSBharata B Rao 5850da6f3feSBharata B Rao if ((index % smt) != 0) { 5860da6f3feSBharata B Rao continue; 5870da6f3feSBharata B Rao } 5880da6f3feSBharata B Rao 5890da6f3feSBharata B Rao nodename = g_strdup_printf("%s@%x", dc->fw_name, index); 5900da6f3feSBharata B Rao offset = fdt_add_subnode(fdt, cpus_offset, nodename); 5910da6f3feSBharata B Rao g_free(nodename); 5920da6f3feSBharata B Rao _FDT(offset); 5930da6f3feSBharata B Rao spapr_populate_cpu_dt(cs, fdt, offset, spapr); 5940da6f3feSBharata B Rao } 5950da6f3feSBharata B Rao 5960da6f3feSBharata B Rao } 5970da6f3feSBharata B Rao 59803d196b7SBharata B Rao /* 59903d196b7SBharata B Rao * Adds ibm,dynamic-reconfiguration-memory node. 60003d196b7SBharata B Rao * Refer to docs/specs/ppc-spapr-hotplug.txt for the documentation 60103d196b7SBharata B Rao * of this device tree node. 60203d196b7SBharata B Rao */ 60303d196b7SBharata B Rao static int spapr_populate_drconf_memory(sPAPRMachineState *spapr, void *fdt) 60403d196b7SBharata B Rao { 60503d196b7SBharata B Rao MachineState *machine = MACHINE(spapr); 60603d196b7SBharata B Rao int ret, i, offset; 60703d196b7SBharata B Rao uint64_t lmb_size = SPAPR_MEMORY_BLOCK_SIZE; 60803d196b7SBharata B Rao uint32_t prop_lmb_size[] = {0, cpu_to_be32(lmb_size)}; 609d0e5a8f2SBharata B Rao uint32_t hotplug_lmb_start = spapr->hotplug_memory.base / lmb_size; 610d0e5a8f2SBharata B Rao uint32_t nr_lmbs = (spapr->hotplug_memory.base + 611d0e5a8f2SBharata B Rao memory_region_size(&spapr->hotplug_memory.mr)) / 612d0e5a8f2SBharata B Rao lmb_size; 61303d196b7SBharata B Rao uint32_t *int_buf, *cur_index, buf_len; 6146663864eSBharata B Rao int nr_nodes = nb_numa_nodes ? nb_numa_nodes : 1; 61503d196b7SBharata B Rao 616ef001f06SThomas Huth /* 617d0e5a8f2SBharata B Rao * Don't create the node if there is no hotpluggable memory 61816c25aefSBharata B Rao */ 619d0e5a8f2SBharata B Rao if (machine->ram_size == machine->maxram_size) { 62016c25aefSBharata B Rao return 0; 62116c25aefSBharata B Rao } 62216c25aefSBharata B Rao 62316c25aefSBharata B Rao /* 624ef001f06SThomas Huth * Allocate enough buffer size to fit in ibm,dynamic-memory 625ef001f06SThomas Huth * or ibm,associativity-lookup-arrays 626ef001f06SThomas Huth */ 627ef001f06SThomas Huth buf_len = MAX(nr_lmbs * SPAPR_DR_LMB_LIST_ENTRY_SIZE + 1, nr_nodes * 4 + 2) 628ef001f06SThomas Huth * sizeof(uint32_t); 62903d196b7SBharata B Rao cur_index = int_buf = g_malloc0(buf_len); 63003d196b7SBharata B Rao 63103d196b7SBharata B Rao offset = fdt_add_subnode(fdt, 0, "ibm,dynamic-reconfiguration-memory"); 63203d196b7SBharata B Rao 63303d196b7SBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,lmb-size", prop_lmb_size, 63403d196b7SBharata B Rao sizeof(prop_lmb_size)); 63503d196b7SBharata B Rao if (ret < 0) { 63603d196b7SBharata B Rao goto out; 63703d196b7SBharata B Rao } 63803d196b7SBharata B Rao 63903d196b7SBharata B Rao ret = fdt_setprop_cell(fdt, offset, "ibm,memory-flags-mask", 0xff); 64003d196b7SBharata B Rao if (ret < 0) { 64103d196b7SBharata B Rao goto out; 64203d196b7SBharata B Rao } 64303d196b7SBharata B Rao 64403d196b7SBharata B Rao ret = fdt_setprop_cell(fdt, offset, "ibm,memory-preservation-time", 0x0); 64503d196b7SBharata B Rao if (ret < 0) { 64603d196b7SBharata B Rao goto out; 64703d196b7SBharata B Rao } 64803d196b7SBharata B Rao 64903d196b7SBharata B Rao /* ibm,dynamic-memory */ 65003d196b7SBharata B Rao int_buf[0] = cpu_to_be32(nr_lmbs); 65103d196b7SBharata B Rao cur_index++; 65203d196b7SBharata B Rao for (i = 0; i < nr_lmbs; i++) { 653d0e5a8f2SBharata B Rao uint64_t addr = i * lmb_size; 65403d196b7SBharata B Rao uint32_t *dynamic_memory = cur_index; 65503d196b7SBharata B Rao 656d0e5a8f2SBharata B Rao if (i >= hotplug_lmb_start) { 657d0e5a8f2SBharata B Rao sPAPRDRConnector *drc; 658d0e5a8f2SBharata B Rao sPAPRDRConnectorClass *drck; 659d0e5a8f2SBharata B Rao 660d0e5a8f2SBharata B Rao drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_LMB, i); 66103d196b7SBharata B Rao g_assert(drc); 66203d196b7SBharata B Rao drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 66303d196b7SBharata B Rao 66403d196b7SBharata B Rao dynamic_memory[0] = cpu_to_be32(addr >> 32); 66503d196b7SBharata B Rao dynamic_memory[1] = cpu_to_be32(addr & 0xffffffff); 66603d196b7SBharata B Rao dynamic_memory[2] = cpu_to_be32(drck->get_index(drc)); 66703d196b7SBharata B Rao dynamic_memory[3] = cpu_to_be32(0); /* reserved */ 66803d196b7SBharata B Rao dynamic_memory[4] = cpu_to_be32(numa_get_node(addr, NULL)); 669d0e5a8f2SBharata B Rao if (memory_region_present(get_system_memory(), addr)) { 67003d196b7SBharata B Rao dynamic_memory[5] = cpu_to_be32(SPAPR_LMB_FLAGS_ASSIGNED); 67103d196b7SBharata B Rao } else { 67203d196b7SBharata B Rao dynamic_memory[5] = cpu_to_be32(0); 67303d196b7SBharata B Rao } 674d0e5a8f2SBharata B Rao } else { 675d0e5a8f2SBharata B Rao /* 676d0e5a8f2SBharata B Rao * LMB information for RMA, boot time RAM and gap b/n RAM and 677d0e5a8f2SBharata B Rao * hotplug memory region -- all these are marked as reserved 678d0e5a8f2SBharata B Rao * and as having no valid DRC. 679d0e5a8f2SBharata B Rao */ 680d0e5a8f2SBharata B Rao dynamic_memory[0] = cpu_to_be32(addr >> 32); 681d0e5a8f2SBharata B Rao dynamic_memory[1] = cpu_to_be32(addr & 0xffffffff); 682d0e5a8f2SBharata B Rao dynamic_memory[2] = cpu_to_be32(0); 683d0e5a8f2SBharata B Rao dynamic_memory[3] = cpu_to_be32(0); /* reserved */ 684d0e5a8f2SBharata B Rao dynamic_memory[4] = cpu_to_be32(-1); 685d0e5a8f2SBharata B Rao dynamic_memory[5] = cpu_to_be32(SPAPR_LMB_FLAGS_RESERVED | 686d0e5a8f2SBharata B Rao SPAPR_LMB_FLAGS_DRC_INVALID); 687d0e5a8f2SBharata B Rao } 68803d196b7SBharata B Rao 68903d196b7SBharata B Rao cur_index += SPAPR_DR_LMB_LIST_ENTRY_SIZE; 69003d196b7SBharata B Rao } 69103d196b7SBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,dynamic-memory", int_buf, buf_len); 69203d196b7SBharata B Rao if (ret < 0) { 69303d196b7SBharata B Rao goto out; 69403d196b7SBharata B Rao } 69503d196b7SBharata B Rao 69603d196b7SBharata B Rao /* ibm,associativity-lookup-arrays */ 69703d196b7SBharata B Rao cur_index = int_buf; 6986663864eSBharata B Rao int_buf[0] = cpu_to_be32(nr_nodes); 69903d196b7SBharata B Rao int_buf[1] = cpu_to_be32(4); /* Number of entries per associativity list */ 70003d196b7SBharata B Rao cur_index += 2; 7016663864eSBharata B Rao for (i = 0; i < nr_nodes; i++) { 70203d196b7SBharata B Rao uint32_t associativity[] = { 70303d196b7SBharata B Rao cpu_to_be32(0x0), 70403d196b7SBharata B Rao cpu_to_be32(0x0), 70503d196b7SBharata B Rao cpu_to_be32(0x0), 70603d196b7SBharata B Rao cpu_to_be32(i) 70703d196b7SBharata B Rao }; 70803d196b7SBharata B Rao memcpy(cur_index, associativity, sizeof(associativity)); 70903d196b7SBharata B Rao cur_index += 4; 71003d196b7SBharata B Rao } 71103d196b7SBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,associativity-lookup-arrays", int_buf, 71203d196b7SBharata B Rao (cur_index - int_buf) * sizeof(uint32_t)); 71303d196b7SBharata B Rao out: 71403d196b7SBharata B Rao g_free(int_buf); 71503d196b7SBharata B Rao return ret; 71603d196b7SBharata B Rao } 71703d196b7SBharata B Rao 7186787d27bSMichael Roth static int spapr_dt_cas_updates(sPAPRMachineState *spapr, void *fdt, 7196787d27bSMichael Roth sPAPROptionVector *ov5_updates) 7206787d27bSMichael Roth { 7216787d27bSMichael Roth sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(spapr); 722417ece33SMichael Roth int ret = 0, offset; 7236787d27bSMichael Roth 7246787d27bSMichael Roth /* Generate ibm,dynamic-reconfiguration-memory node if required */ 7256787d27bSMichael Roth if (spapr_ovec_test(ov5_updates, OV5_DRCONF_MEMORY)) { 7266787d27bSMichael Roth g_assert(smc->dr_lmb_enabled); 7276787d27bSMichael Roth ret = spapr_populate_drconf_memory(spapr, fdt); 728417ece33SMichael Roth if (ret) { 729417ece33SMichael Roth goto out; 730417ece33SMichael Roth } 7316787d27bSMichael Roth } 7326787d27bSMichael Roth 733417ece33SMichael Roth offset = fdt_path_offset(fdt, "/chosen"); 734417ece33SMichael Roth if (offset < 0) { 735417ece33SMichael Roth offset = fdt_add_subnode(fdt, 0, "chosen"); 736417ece33SMichael Roth if (offset < 0) { 737417ece33SMichael Roth return offset; 738417ece33SMichael Roth } 739417ece33SMichael Roth } 740417ece33SMichael Roth ret = spapr_ovec_populate_dt(fdt, offset, spapr->ov5_cas, 741417ece33SMichael Roth "ibm,architecture-vec-5"); 742417ece33SMichael Roth 743417ece33SMichael Roth out: 7446787d27bSMichael Roth return ret; 7456787d27bSMichael Roth } 7466787d27bSMichael Roth 74703d196b7SBharata B Rao int spapr_h_cas_compose_response(sPAPRMachineState *spapr, 74803d196b7SBharata B Rao target_ulong addr, target_ulong size, 7496787d27bSMichael Roth sPAPROptionVector *ov5_updates) 75003d196b7SBharata B Rao { 75103d196b7SBharata B Rao void *fdt, *fdt_skel; 75203d196b7SBharata B Rao sPAPRDeviceTreeUpdateHeader hdr = { .version_id = 1 }; 75303d196b7SBharata B Rao 75403d196b7SBharata B Rao size -= sizeof(hdr); 75503d196b7SBharata B Rao 75603d196b7SBharata B Rao /* Create sceleton */ 75703d196b7SBharata B Rao fdt_skel = g_malloc0(size); 75803d196b7SBharata B Rao _FDT((fdt_create(fdt_skel, size))); 75903d196b7SBharata B Rao _FDT((fdt_begin_node(fdt_skel, ""))); 76003d196b7SBharata B Rao _FDT((fdt_end_node(fdt_skel))); 76103d196b7SBharata B Rao _FDT((fdt_finish(fdt_skel))); 76203d196b7SBharata B Rao fdt = g_malloc0(size); 76303d196b7SBharata B Rao _FDT((fdt_open_into(fdt_skel, fdt, size))); 76403d196b7SBharata B Rao g_free(fdt_skel); 76503d196b7SBharata B Rao 76603d196b7SBharata B Rao /* Fixup cpu nodes */ 76703d196b7SBharata B Rao _FDT((spapr_fixup_cpu_dt(fdt, spapr))); 76803d196b7SBharata B Rao 7696787d27bSMichael Roth if (spapr_dt_cas_updates(spapr, fdt, ov5_updates)) { 7706787d27bSMichael Roth return -1; 77103d196b7SBharata B Rao } 77203d196b7SBharata B Rao 77303d196b7SBharata B Rao /* Pack resulting tree */ 77403d196b7SBharata B Rao _FDT((fdt_pack(fdt))); 77503d196b7SBharata B Rao 77603d196b7SBharata B Rao if (fdt_totalsize(fdt) + sizeof(hdr) > size) { 77703d196b7SBharata B Rao trace_spapr_cas_failed(size); 77803d196b7SBharata B Rao return -1; 77903d196b7SBharata B Rao } 78003d196b7SBharata B Rao 78103d196b7SBharata B Rao cpu_physical_memory_write(addr, &hdr, sizeof(hdr)); 78203d196b7SBharata B Rao cpu_physical_memory_write(addr + sizeof(hdr), fdt, fdt_totalsize(fdt)); 78303d196b7SBharata B Rao trace_spapr_cas_continue(fdt_totalsize(fdt) + sizeof(hdr)); 78403d196b7SBharata B Rao g_free(fdt); 78503d196b7SBharata B Rao 78603d196b7SBharata B Rao return 0; 78703d196b7SBharata B Rao } 78803d196b7SBharata B Rao 7893f5dabceSDavid Gibson static void spapr_dt_rtas(sPAPRMachineState *spapr, void *fdt) 7903f5dabceSDavid Gibson { 7913f5dabceSDavid Gibson int rtas; 7923f5dabceSDavid Gibson GString *hypertas = g_string_sized_new(256); 7933f5dabceSDavid Gibson GString *qemu_hypertas = g_string_sized_new(256); 7943f5dabceSDavid Gibson uint32_t refpoints[] = { cpu_to_be32(0x4), cpu_to_be32(0x4) }; 7953f5dabceSDavid Gibson uint64_t max_hotplug_addr = spapr->hotplug_memory.base + 7963f5dabceSDavid Gibson memory_region_size(&spapr->hotplug_memory.mr); 7973f5dabceSDavid Gibson uint32_t lrdr_capacity[] = { 7983f5dabceSDavid Gibson cpu_to_be32(max_hotplug_addr >> 32), 7993f5dabceSDavid Gibson cpu_to_be32(max_hotplug_addr & 0xffffffff), 8003f5dabceSDavid Gibson 0, cpu_to_be32(SPAPR_MEMORY_BLOCK_SIZE), 8013f5dabceSDavid Gibson cpu_to_be32(max_cpus / smp_threads), 8023f5dabceSDavid Gibson }; 8033f5dabceSDavid Gibson 8043f5dabceSDavid Gibson _FDT(rtas = fdt_add_subnode(fdt, 0, "rtas")); 8053f5dabceSDavid Gibson 8063f5dabceSDavid Gibson /* hypertas */ 8073f5dabceSDavid Gibson add_str(hypertas, "hcall-pft"); 8083f5dabceSDavid Gibson add_str(hypertas, "hcall-term"); 8093f5dabceSDavid Gibson add_str(hypertas, "hcall-dabr"); 8103f5dabceSDavid Gibson add_str(hypertas, "hcall-interrupt"); 8113f5dabceSDavid Gibson add_str(hypertas, "hcall-tce"); 8123f5dabceSDavid Gibson add_str(hypertas, "hcall-vio"); 8133f5dabceSDavid Gibson add_str(hypertas, "hcall-splpar"); 8143f5dabceSDavid Gibson add_str(hypertas, "hcall-bulk"); 8153f5dabceSDavid Gibson add_str(hypertas, "hcall-set-mode"); 8163f5dabceSDavid Gibson add_str(hypertas, "hcall-sprg0"); 8173f5dabceSDavid Gibson add_str(hypertas, "hcall-copy"); 8183f5dabceSDavid Gibson add_str(hypertas, "hcall-debug"); 8193f5dabceSDavid Gibson add_str(qemu_hypertas, "hcall-memop1"); 8203f5dabceSDavid Gibson 8213f5dabceSDavid Gibson if (!kvm_enabled() || kvmppc_spapr_use_multitce()) { 8223f5dabceSDavid Gibson add_str(hypertas, "hcall-multi-tce"); 8233f5dabceSDavid Gibson } 8243f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,hypertas-functions", 8253f5dabceSDavid Gibson hypertas->str, hypertas->len)); 8263f5dabceSDavid Gibson g_string_free(hypertas, TRUE); 8273f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "qemu,hypertas-functions", 8283f5dabceSDavid Gibson qemu_hypertas->str, qemu_hypertas->len)); 8293f5dabceSDavid Gibson g_string_free(qemu_hypertas, TRUE); 8303f5dabceSDavid Gibson 8313f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,associativity-reference-points", 8323f5dabceSDavid Gibson refpoints, sizeof(refpoints))); 8333f5dabceSDavid Gibson 8343f5dabceSDavid Gibson _FDT(fdt_setprop_cell(fdt, rtas, "rtas-error-log-max", 8353f5dabceSDavid Gibson RTAS_ERROR_LOG_MAX)); 8363f5dabceSDavid Gibson _FDT(fdt_setprop_cell(fdt, rtas, "rtas-event-scan-rate", 8373f5dabceSDavid Gibson RTAS_EVENT_SCAN_RATE)); 8383f5dabceSDavid Gibson 8393f5dabceSDavid Gibson if (msi_nonbroken) { 8403f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,change-msix-capable", NULL, 0)); 8413f5dabceSDavid Gibson } 8423f5dabceSDavid Gibson 8433f5dabceSDavid Gibson /* 8443f5dabceSDavid Gibson * According to PAPR, rtas ibm,os-term does not guarantee a return 8453f5dabceSDavid Gibson * back to the guest cpu. 8463f5dabceSDavid Gibson * 8473f5dabceSDavid Gibson * While an additional ibm,extended-os-term property indicates 8483f5dabceSDavid Gibson * that rtas call return will always occur. Set this property. 8493f5dabceSDavid Gibson */ 8503f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,extended-os-term", NULL, 0)); 8513f5dabceSDavid Gibson 8523f5dabceSDavid Gibson _FDT(fdt_setprop(fdt, rtas, "ibm,lrdr-capacity", 8533f5dabceSDavid Gibson lrdr_capacity, sizeof(lrdr_capacity))); 8543f5dabceSDavid Gibson 8553f5dabceSDavid Gibson spapr_dt_rtas_tokens(fdt, rtas); 8563f5dabceSDavid Gibson } 8573f5dabceSDavid Gibson 8587c866c6aSDavid Gibson static void spapr_dt_chosen(sPAPRMachineState *spapr, void *fdt) 8597c866c6aSDavid Gibson { 8607c866c6aSDavid Gibson MachineState *machine = MACHINE(spapr); 8617c866c6aSDavid Gibson int chosen; 8627c866c6aSDavid Gibson const char *boot_device = machine->boot_order; 8637c866c6aSDavid Gibson char *stdout_path = spapr_vio_stdout_path(spapr->vio_bus); 8647c866c6aSDavid Gibson size_t cb = 0; 8657c866c6aSDavid Gibson char *bootlist = get_boot_devices_list(&cb, true); 8667c866c6aSDavid Gibson 8677c866c6aSDavid Gibson _FDT(chosen = fdt_add_subnode(fdt, 0, "chosen")); 8687c866c6aSDavid Gibson 8697c866c6aSDavid Gibson _FDT(fdt_setprop_string(fdt, chosen, "bootargs", machine->kernel_cmdline)); 8707c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "linux,initrd-start", 8717c866c6aSDavid Gibson spapr->initrd_base)); 8727c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "linux,initrd-end", 8737c866c6aSDavid Gibson spapr->initrd_base + spapr->initrd_size)); 8747c866c6aSDavid Gibson 8757c866c6aSDavid Gibson if (spapr->kernel_size) { 8767c866c6aSDavid Gibson uint64_t kprop[2] = { cpu_to_be64(KERNEL_LOAD_ADDR), 8777c866c6aSDavid Gibson cpu_to_be64(spapr->kernel_size) }; 8787c866c6aSDavid Gibson 8797c866c6aSDavid Gibson _FDT(fdt_setprop(fdt, chosen, "qemu,boot-kernel", 8807c866c6aSDavid Gibson &kprop, sizeof(kprop))); 8817c866c6aSDavid Gibson if (spapr->kernel_le) { 8827c866c6aSDavid Gibson _FDT(fdt_setprop(fdt, chosen, "qemu,boot-kernel-le", NULL, 0)); 8837c866c6aSDavid Gibson } 8847c866c6aSDavid Gibson } 8857c866c6aSDavid Gibson if (boot_menu) { 8867c866c6aSDavid Gibson _FDT((fdt_setprop_cell(fdt, chosen, "qemu,boot-menu", boot_menu))); 8877c866c6aSDavid Gibson } 8887c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "qemu,graphic-width", graphic_width)); 8897c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "qemu,graphic-height", graphic_height)); 8907c866c6aSDavid Gibson _FDT(fdt_setprop_cell(fdt, chosen, "qemu,graphic-depth", graphic_depth)); 8917c866c6aSDavid Gibson 8927c866c6aSDavid Gibson if (cb && bootlist) { 8937c866c6aSDavid Gibson int i; 8947c866c6aSDavid Gibson 8957c866c6aSDavid Gibson for (i = 0; i < cb; i++) { 8967c866c6aSDavid Gibson if (bootlist[i] == '\n') { 8977c866c6aSDavid Gibson bootlist[i] = ' '; 8987c866c6aSDavid Gibson } 8997c866c6aSDavid Gibson } 9007c866c6aSDavid Gibson _FDT(fdt_setprop_string(fdt, chosen, "qemu,boot-list", bootlist)); 9017c866c6aSDavid Gibson } 9027c866c6aSDavid Gibson 9037c866c6aSDavid Gibson if (boot_device && strlen(boot_device)) { 9047c866c6aSDavid Gibson _FDT(fdt_setprop_string(fdt, chosen, "qemu,boot-device", boot_device)); 9057c866c6aSDavid Gibson } 9067c866c6aSDavid Gibson 9077c866c6aSDavid Gibson if (!spapr->has_graphics && stdout_path) { 9087c866c6aSDavid Gibson _FDT(fdt_setprop_string(fdt, chosen, "linux,stdout-path", stdout_path)); 9097c866c6aSDavid Gibson } 9107c866c6aSDavid Gibson 9117c866c6aSDavid Gibson g_free(stdout_path); 9127c866c6aSDavid Gibson g_free(bootlist); 9137c866c6aSDavid Gibson } 9147c866c6aSDavid Gibson 915fca5f2dcSDavid Gibson static void spapr_dt_hypervisor(sPAPRMachineState *spapr, void *fdt) 916fca5f2dcSDavid Gibson { 917fca5f2dcSDavid Gibson /* The /hypervisor node isn't in PAPR - this is a hack to allow PR 918fca5f2dcSDavid Gibson * KVM to work under pHyp with some guest co-operation */ 919fca5f2dcSDavid Gibson int hypervisor; 920fca5f2dcSDavid Gibson uint8_t hypercall[16]; 921fca5f2dcSDavid Gibson 922fca5f2dcSDavid Gibson _FDT(hypervisor = fdt_add_subnode(fdt, 0, "hypervisor")); 923fca5f2dcSDavid Gibson /* indicate KVM hypercall interface */ 924fca5f2dcSDavid Gibson _FDT(fdt_setprop_string(fdt, hypervisor, "compatible", "linux,kvm")); 925fca5f2dcSDavid Gibson if (kvmppc_has_cap_fixup_hcalls()) { 926fca5f2dcSDavid Gibson /* 927fca5f2dcSDavid Gibson * Older KVM versions with older guest kernels were broken 928fca5f2dcSDavid Gibson * with the magic page, don't allow the guest to map it. 929fca5f2dcSDavid Gibson */ 930fca5f2dcSDavid Gibson if (!kvmppc_get_hypercall(first_cpu->env_ptr, hypercall, 931fca5f2dcSDavid Gibson sizeof(hypercall))) { 932fca5f2dcSDavid Gibson _FDT(fdt_setprop(fdt, hypervisor, "hcall-instructions", 933fca5f2dcSDavid Gibson hypercall, sizeof(hypercall))); 934fca5f2dcSDavid Gibson } 935fca5f2dcSDavid Gibson } 936fca5f2dcSDavid Gibson } 937fca5f2dcSDavid Gibson 938997b6cfcSDavid Gibson static void *spapr_build_fdt(sPAPRMachineState *spapr, 93953018216SPaolo Bonzini hwaddr rtas_addr, 94053018216SPaolo Bonzini hwaddr rtas_size) 94153018216SPaolo Bonzini { 9425b2128d2SAlexander Graf MachineState *machine = MACHINE(qdev_get_machine()); 9433c0c47e3SDavid Gibson MachineClass *mc = MACHINE_GET_CLASS(machine); 944c20d332aSBharata B Rao sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(machine); 9457c866c6aSDavid Gibson int ret; 94653018216SPaolo Bonzini void *fdt; 94753018216SPaolo Bonzini sPAPRPHBState *phb; 948398a0bd5SDavid Gibson char *buf; 94953018216SPaolo Bonzini 950398a0bd5SDavid Gibson fdt = g_malloc0(FDT_MAX_SIZE); 951398a0bd5SDavid Gibson _FDT((fdt_create_empty_tree(fdt, FDT_MAX_SIZE))); 95253018216SPaolo Bonzini 953398a0bd5SDavid Gibson /* Root node */ 954398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "device_type", "chrp")); 955398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "model", "IBM pSeries (emulated by qemu)")); 956398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "compatible", "qemu,pseries")); 957398a0bd5SDavid Gibson 958398a0bd5SDavid Gibson /* 959398a0bd5SDavid Gibson * Add info to guest to indentify which host is it being run on 960398a0bd5SDavid Gibson * and what is the uuid of the guest 961398a0bd5SDavid Gibson */ 962398a0bd5SDavid Gibson if (kvmppc_get_host_model(&buf)) { 963398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "host-model", buf)); 964398a0bd5SDavid Gibson g_free(buf); 965398a0bd5SDavid Gibson } 966398a0bd5SDavid Gibson if (kvmppc_get_host_serial(&buf)) { 967398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "host-serial", buf)); 968398a0bd5SDavid Gibson g_free(buf); 969398a0bd5SDavid Gibson } 970398a0bd5SDavid Gibson 971398a0bd5SDavid Gibson buf = qemu_uuid_unparse_strdup(&qemu_uuid); 972398a0bd5SDavid Gibson 973398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "vm,uuid", buf)); 974398a0bd5SDavid Gibson if (qemu_uuid_set) { 975398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "system-id", buf)); 976398a0bd5SDavid Gibson } 977398a0bd5SDavid Gibson g_free(buf); 978398a0bd5SDavid Gibson 979398a0bd5SDavid Gibson if (qemu_get_vm_name()) { 980398a0bd5SDavid Gibson _FDT(fdt_setprop_string(fdt, 0, "ibm,partition-name", 981398a0bd5SDavid Gibson qemu_get_vm_name())); 982398a0bd5SDavid Gibson } 983398a0bd5SDavid Gibson 984398a0bd5SDavid Gibson _FDT(fdt_setprop_cell(fdt, 0, "#address-cells", 2)); 985398a0bd5SDavid Gibson _FDT(fdt_setprop_cell(fdt, 0, "#size-cells", 2)); 98653018216SPaolo Bonzini 9879b9a1908SDavid Gibson /* /interrupt controller */ 988852ad27eSCédric Le Goater spapr_dt_xics(spapr->nr_servers, fdt, PHANDLE_XICP); 9899b9a1908SDavid Gibson 990e8f986fcSBharata B Rao ret = spapr_populate_memory(spapr, fdt); 991e8f986fcSBharata B Rao if (ret < 0) { 992ce9863b7SCédric Le Goater error_report("couldn't setup memory nodes in fdt"); 993e8f986fcSBharata B Rao exit(1); 99453018216SPaolo Bonzini } 99553018216SPaolo Bonzini 996bf5a6696SDavid Gibson /* /vdevice */ 997bf5a6696SDavid Gibson spapr_dt_vdevice(spapr->vio_bus, fdt); 99853018216SPaolo Bonzini 9994d9392beSThomas Huth if (object_resolve_path_type("", TYPE_SPAPR_RNG, NULL)) { 10004d9392beSThomas Huth ret = spapr_rng_populate_dt(fdt); 10014d9392beSThomas Huth if (ret < 0) { 1002ce9863b7SCédric Le Goater error_report("could not set up rng device in the fdt"); 10034d9392beSThomas Huth exit(1); 10044d9392beSThomas Huth } 10054d9392beSThomas Huth } 10064d9392beSThomas Huth 100753018216SPaolo Bonzini QLIST_FOREACH(phb, &spapr->phbs, list) { 100853018216SPaolo Bonzini ret = spapr_populate_pci_dt(phb, PHANDLE_XICP, fdt); 100953018216SPaolo Bonzini if (ret < 0) { 1010da34fed7SThomas Huth error_report("couldn't setup PCI devices in fdt"); 101153018216SPaolo Bonzini exit(1); 101253018216SPaolo Bonzini } 1013da34fed7SThomas Huth } 101453018216SPaolo Bonzini 10150da6f3feSBharata B Rao /* cpus */ 10160da6f3feSBharata B Rao spapr_populate_cpus_dt_node(fdt, spapr); 101753018216SPaolo Bonzini 1018c20d332aSBharata B Rao if (smc->dr_lmb_enabled) { 1019c20d332aSBharata B Rao _FDT(spapr_drc_populate_dt(fdt, 0, NULL, SPAPR_DR_CONNECTOR_TYPE_LMB)); 1020c20d332aSBharata B Rao } 1021c20d332aSBharata B Rao 1022c5514d0eSIgor Mammedov if (mc->has_hotpluggable_cpus) { 1023af81cf32SBharata B Rao int offset = fdt_path_offset(fdt, "/cpus"); 1024af81cf32SBharata B Rao ret = spapr_drc_populate_dt(fdt, offset, NULL, 1025af81cf32SBharata B Rao SPAPR_DR_CONNECTOR_TYPE_CPU); 1026af81cf32SBharata B Rao if (ret < 0) { 1027af81cf32SBharata B Rao error_report("Couldn't set up CPU DR device tree properties"); 1028af81cf32SBharata B Rao exit(1); 1029af81cf32SBharata B Rao } 1030af81cf32SBharata B Rao } 1031af81cf32SBharata B Rao 1032ffb1e275SDavid Gibson /* /event-sources */ 1033ffbb1705SMichael Roth spapr_dt_events(spapr, fdt); 1034ffb1e275SDavid Gibson 10353f5dabceSDavid Gibson /* /rtas */ 10363f5dabceSDavid Gibson spapr_dt_rtas(spapr, fdt); 10373f5dabceSDavid Gibson 10387c866c6aSDavid Gibson /* /chosen */ 10397c866c6aSDavid Gibson spapr_dt_chosen(spapr, fdt); 1040cf6e5223SDavid Gibson 1041fca5f2dcSDavid Gibson /* /hypervisor */ 1042fca5f2dcSDavid Gibson if (kvm_enabled()) { 1043fca5f2dcSDavid Gibson spapr_dt_hypervisor(spapr, fdt); 1044fca5f2dcSDavid Gibson } 1045fca5f2dcSDavid Gibson 1046cf6e5223SDavid Gibson /* Build memory reserve map */ 1047cf6e5223SDavid Gibson if (spapr->kernel_size) { 1048cf6e5223SDavid Gibson _FDT((fdt_add_mem_rsv(fdt, KERNEL_LOAD_ADDR, spapr->kernel_size))); 1049cf6e5223SDavid Gibson } 1050cf6e5223SDavid Gibson if (spapr->initrd_size) { 1051cf6e5223SDavid Gibson _FDT((fdt_add_mem_rsv(fdt, spapr->initrd_base, spapr->initrd_size))); 1052cf6e5223SDavid Gibson } 1053cf6e5223SDavid Gibson 10546787d27bSMichael Roth /* ibm,client-architecture-support updates */ 10556787d27bSMichael Roth ret = spapr_dt_cas_updates(spapr, fdt, spapr->ov5_cas); 10566787d27bSMichael Roth if (ret < 0) { 10576787d27bSMichael Roth error_report("couldn't setup CAS properties fdt"); 10586787d27bSMichael Roth exit(1); 10596787d27bSMichael Roth } 10606787d27bSMichael Roth 1061997b6cfcSDavid Gibson return fdt; 106253018216SPaolo Bonzini } 106353018216SPaolo Bonzini 106453018216SPaolo Bonzini static uint64_t translate_kernel_address(void *opaque, uint64_t addr) 106553018216SPaolo Bonzini { 106653018216SPaolo Bonzini return (addr & 0x0fffffff) + KERNEL_LOAD_ADDR; 106753018216SPaolo Bonzini } 106853018216SPaolo Bonzini 10691d1be34dSDavid Gibson static void emulate_spapr_hypercall(PPCVirtualHypervisor *vhyp, 10701d1be34dSDavid Gibson PowerPCCPU *cpu) 107153018216SPaolo Bonzini { 107253018216SPaolo Bonzini CPUPPCState *env = &cpu->env; 107353018216SPaolo Bonzini 10748d04fb55SJan Kiszka /* The TCG path should also be holding the BQL at this point */ 10758d04fb55SJan Kiszka g_assert(qemu_mutex_iothread_locked()); 10768d04fb55SJan Kiszka 107753018216SPaolo Bonzini if (msr_pr) { 107853018216SPaolo Bonzini hcall_dprintf("Hypercall made with MSR[PR]=1\n"); 107953018216SPaolo Bonzini env->gpr[3] = H_PRIVILEGE; 108053018216SPaolo Bonzini } else { 108153018216SPaolo Bonzini env->gpr[3] = spapr_hypercall(cpu, env->gpr[3], &env->gpr[4]); 108253018216SPaolo Bonzini } 108353018216SPaolo Bonzini } 108453018216SPaolo Bonzini 10859861bb3eSSuraj Jitindar Singh static uint64_t spapr_get_patbe(PPCVirtualHypervisor *vhyp) 10869861bb3eSSuraj Jitindar Singh { 10879861bb3eSSuraj Jitindar Singh sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 10889861bb3eSSuraj Jitindar Singh 10899861bb3eSSuraj Jitindar Singh return spapr->patb_entry; 10909861bb3eSSuraj Jitindar Singh } 10919861bb3eSSuraj Jitindar Singh 1092e6b8fd24SSamuel Mendoza-Jonas #define HPTE(_table, _i) (void *)(((uint64_t *)(_table)) + ((_i) * 2)) 1093e6b8fd24SSamuel Mendoza-Jonas #define HPTE_VALID(_hpte) (tswap64(*((uint64_t *)(_hpte))) & HPTE64_V_VALID) 1094e6b8fd24SSamuel Mendoza-Jonas #define HPTE_DIRTY(_hpte) (tswap64(*((uint64_t *)(_hpte))) & HPTE64_V_HPTE_DIRTY) 1095e6b8fd24SSamuel Mendoza-Jonas #define CLEAN_HPTE(_hpte) ((*(uint64_t *)(_hpte)) &= tswap64(~HPTE64_V_HPTE_DIRTY)) 1096e6b8fd24SSamuel Mendoza-Jonas #define DIRTY_HPTE(_hpte) ((*(uint64_t *)(_hpte)) |= tswap64(HPTE64_V_HPTE_DIRTY)) 1097e6b8fd24SSamuel Mendoza-Jonas 1098715c5407SDavid Gibson /* 1099715c5407SDavid Gibson * Get the fd to access the kernel htab, re-opening it if necessary 1100715c5407SDavid Gibson */ 1101715c5407SDavid Gibson static int get_htab_fd(sPAPRMachineState *spapr) 1102715c5407SDavid Gibson { 1103715c5407SDavid Gibson if (spapr->htab_fd >= 0) { 1104715c5407SDavid Gibson return spapr->htab_fd; 1105715c5407SDavid Gibson } 1106715c5407SDavid Gibson 1107715c5407SDavid Gibson spapr->htab_fd = kvmppc_get_htab_fd(false); 1108715c5407SDavid Gibson if (spapr->htab_fd < 0) { 1109715c5407SDavid Gibson error_report("Unable to open fd for reading hash table from KVM: %s", 1110715c5407SDavid Gibson strerror(errno)); 1111715c5407SDavid Gibson } 1112715c5407SDavid Gibson 1113715c5407SDavid Gibson return spapr->htab_fd; 1114715c5407SDavid Gibson } 1115715c5407SDavid Gibson 1116715c5407SDavid Gibson static void close_htab_fd(sPAPRMachineState *spapr) 1117715c5407SDavid Gibson { 1118715c5407SDavid Gibson if (spapr->htab_fd >= 0) { 1119715c5407SDavid Gibson close(spapr->htab_fd); 1120715c5407SDavid Gibson } 1121715c5407SDavid Gibson spapr->htab_fd = -1; 1122715c5407SDavid Gibson } 1123715c5407SDavid Gibson 1124e57ca75cSDavid Gibson static hwaddr spapr_hpt_mask(PPCVirtualHypervisor *vhyp) 1125e57ca75cSDavid Gibson { 1126e57ca75cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 1127e57ca75cSDavid Gibson 1128e57ca75cSDavid Gibson return HTAB_SIZE(spapr) / HASH_PTEG_SIZE_64 - 1; 1129e57ca75cSDavid Gibson } 1130e57ca75cSDavid Gibson 1131e57ca75cSDavid Gibson static const ppc_hash_pte64_t *spapr_map_hptes(PPCVirtualHypervisor *vhyp, 1132e57ca75cSDavid Gibson hwaddr ptex, int n) 1133e57ca75cSDavid Gibson { 1134e57ca75cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 1135e57ca75cSDavid Gibson hwaddr pte_offset = ptex * HASH_PTE_SIZE_64; 1136e57ca75cSDavid Gibson 1137e57ca75cSDavid Gibson if (!spapr->htab) { 1138e57ca75cSDavid Gibson /* 1139e57ca75cSDavid Gibson * HTAB is controlled by KVM. Fetch into temporary buffer 1140e57ca75cSDavid Gibson */ 1141e57ca75cSDavid Gibson ppc_hash_pte64_t *hptes = g_malloc(n * HASH_PTE_SIZE_64); 1142e57ca75cSDavid Gibson kvmppc_read_hptes(hptes, ptex, n); 1143e57ca75cSDavid Gibson return hptes; 1144e57ca75cSDavid Gibson } 1145e57ca75cSDavid Gibson 1146e57ca75cSDavid Gibson /* 1147e57ca75cSDavid Gibson * HTAB is controlled by QEMU. Just point to the internally 1148e57ca75cSDavid Gibson * accessible PTEG. 1149e57ca75cSDavid Gibson */ 1150e57ca75cSDavid Gibson return (const ppc_hash_pte64_t *)(spapr->htab + pte_offset); 1151e57ca75cSDavid Gibson } 1152e57ca75cSDavid Gibson 1153e57ca75cSDavid Gibson static void spapr_unmap_hptes(PPCVirtualHypervisor *vhyp, 1154e57ca75cSDavid Gibson const ppc_hash_pte64_t *hptes, 1155e57ca75cSDavid Gibson hwaddr ptex, int n) 1156e57ca75cSDavid Gibson { 1157e57ca75cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 1158e57ca75cSDavid Gibson 1159e57ca75cSDavid Gibson if (!spapr->htab) { 1160e57ca75cSDavid Gibson g_free((void *)hptes); 1161e57ca75cSDavid Gibson } 1162e57ca75cSDavid Gibson 1163e57ca75cSDavid Gibson /* Nothing to do for qemu managed HPT */ 1164e57ca75cSDavid Gibson } 1165e57ca75cSDavid Gibson 1166e57ca75cSDavid Gibson static void spapr_store_hpte(PPCVirtualHypervisor *vhyp, hwaddr ptex, 1167e57ca75cSDavid Gibson uint64_t pte0, uint64_t pte1) 1168e57ca75cSDavid Gibson { 1169e57ca75cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(vhyp); 1170e57ca75cSDavid Gibson hwaddr offset = ptex * HASH_PTE_SIZE_64; 1171e57ca75cSDavid Gibson 1172e57ca75cSDavid Gibson if (!spapr->htab) { 1173e57ca75cSDavid Gibson kvmppc_write_hpte(ptex, pte0, pte1); 1174e57ca75cSDavid Gibson } else { 1175e57ca75cSDavid Gibson stq_p(spapr->htab + offset, pte0); 1176e57ca75cSDavid Gibson stq_p(spapr->htab + offset + HASH_PTE_SIZE_64 / 2, pte1); 1177e57ca75cSDavid Gibson } 1178e57ca75cSDavid Gibson } 1179e57ca75cSDavid Gibson 11808dfe8e7fSDavid Gibson static int spapr_hpt_shift_for_ramsize(uint64_t ramsize) 11818dfe8e7fSDavid Gibson { 11828dfe8e7fSDavid Gibson int shift; 11838dfe8e7fSDavid Gibson 11848dfe8e7fSDavid Gibson /* We aim for a hash table of size 1/128 the size of RAM (rounded 11858dfe8e7fSDavid Gibson * up). The PAPR recommendation is actually 1/64 of RAM size, but 11868dfe8e7fSDavid Gibson * that's much more than is needed for Linux guests */ 11878dfe8e7fSDavid Gibson shift = ctz64(pow2ceil(ramsize)) - 7; 11888dfe8e7fSDavid Gibson shift = MAX(shift, 18); /* Minimum architected size */ 11898dfe8e7fSDavid Gibson shift = MIN(shift, 46); /* Maximum architected size */ 11908dfe8e7fSDavid Gibson return shift; 11918dfe8e7fSDavid Gibson } 11928dfe8e7fSDavid Gibson 1193c5f54f3eSDavid Gibson static void spapr_reallocate_hpt(sPAPRMachineState *spapr, int shift, 1194c5f54f3eSDavid Gibson Error **errp) 119553018216SPaolo Bonzini { 1196c5f54f3eSDavid Gibson long rc; 119753018216SPaolo Bonzini 1198c5f54f3eSDavid Gibson /* Clean up any HPT info from a previous boot */ 1199c5f54f3eSDavid Gibson g_free(spapr->htab); 1200c5f54f3eSDavid Gibson spapr->htab = NULL; 1201c5f54f3eSDavid Gibson spapr->htab_shift = 0; 1202c5f54f3eSDavid Gibson close_htab_fd(spapr); 120353018216SPaolo Bonzini 1204c5f54f3eSDavid Gibson rc = kvmppc_reset_htab(shift); 1205c5f54f3eSDavid Gibson if (rc < 0) { 1206c5f54f3eSDavid Gibson /* kernel-side HPT needed, but couldn't allocate one */ 1207c5f54f3eSDavid Gibson error_setg_errno(errp, errno, 1208c5f54f3eSDavid Gibson "Failed to allocate KVM HPT of order %d (try smaller maxmem?)", 1209c5f54f3eSDavid Gibson shift); 1210c5f54f3eSDavid Gibson /* This is almost certainly fatal, but if the caller really 1211c5f54f3eSDavid Gibson * wants to carry on with shift == 0, it's welcome to try */ 1212c5f54f3eSDavid Gibson } else if (rc > 0) { 1213c5f54f3eSDavid Gibson /* kernel-side HPT allocated */ 1214c5f54f3eSDavid Gibson if (rc != shift) { 1215c5f54f3eSDavid Gibson error_setg(errp, 1216c5f54f3eSDavid Gibson "Requested order %d HPT, but kernel allocated order %ld (try smaller maxmem?)", 1217c5f54f3eSDavid Gibson shift, rc); 12187735fedaSBharata B Rao } 12197735fedaSBharata B Rao 122053018216SPaolo Bonzini spapr->htab_shift = shift; 1221c18ad9a5SDavid Gibson spapr->htab = NULL; 1222b817772aSBharata B Rao } else { 1223c5f54f3eSDavid Gibson /* kernel-side HPT not needed, allocate in userspace instead */ 1224c5f54f3eSDavid Gibson size_t size = 1ULL << shift; 1225c5f54f3eSDavid Gibson int i; 122601a57972SSamuel Mendoza-Jonas 1227c5f54f3eSDavid Gibson spapr->htab = qemu_memalign(size, size); 1228c5f54f3eSDavid Gibson if (!spapr->htab) { 1229c5f54f3eSDavid Gibson error_setg_errno(errp, errno, 1230c5f54f3eSDavid Gibson "Could not allocate HPT of order %d", shift); 1231c5f54f3eSDavid Gibson return; 1232b817772aSBharata B Rao } 1233b817772aSBharata B Rao 1234c5f54f3eSDavid Gibson memset(spapr->htab, 0, size); 1235c5f54f3eSDavid Gibson spapr->htab_shift = shift; 1236b817772aSBharata B Rao 1237c5f54f3eSDavid Gibson for (i = 0; i < size / HASH_PTE_SIZE_64; i++) { 1238c5f54f3eSDavid Gibson DIRTY_HPTE(HPTE(spapr->htab, i)); 12397735fedaSBharata B Rao } 124053018216SPaolo Bonzini } 124153018216SPaolo Bonzini } 124253018216SPaolo Bonzini 12434f01a637SDavid Gibson static void find_unknown_sysbus_device(SysBusDevice *sbdev, void *opaque) 12449e3f9733SAlexander Graf { 12459e3f9733SAlexander Graf bool matched = false; 12469e3f9733SAlexander Graf 12479e3f9733SAlexander Graf if (object_dynamic_cast(OBJECT(sbdev), TYPE_SPAPR_PCI_HOST_BRIDGE)) { 12489e3f9733SAlexander Graf matched = true; 12499e3f9733SAlexander Graf } 12509e3f9733SAlexander Graf 12519e3f9733SAlexander Graf if (!matched) { 12529e3f9733SAlexander Graf error_report("Device %s is not supported by this machine yet.", 12539e3f9733SAlexander Graf qdev_fw_name(DEVICE(sbdev))); 12549e3f9733SAlexander Graf exit(1); 12559e3f9733SAlexander Graf } 12569e3f9733SAlexander Graf } 12579e3f9733SAlexander Graf 125853018216SPaolo Bonzini static void ppc_spapr_reset(void) 125953018216SPaolo Bonzini { 1260c5f54f3eSDavid Gibson MachineState *machine = MACHINE(qdev_get_machine()); 1261c5f54f3eSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(machine); 1262182735efSAndreas Färber PowerPCCPU *first_ppc_cpu; 1263b7d1f77aSBenjamin Herrenschmidt uint32_t rtas_limit; 1264cae172abSDavid Gibson hwaddr rtas_addr, fdt_addr; 1265997b6cfcSDavid Gibson void *fdt; 1266997b6cfcSDavid Gibson int rc; 1267259186a7SAndreas Färber 12689e3f9733SAlexander Graf /* Check for unknown sysbus devices */ 12699e3f9733SAlexander Graf foreach_dynamic_sysbus_device(find_unknown_sysbus_device, NULL); 12709e3f9733SAlexander Graf 12719861bb3eSSuraj Jitindar Singh spapr->patb_entry = 0; 12729861bb3eSSuraj Jitindar Singh 1273c5f54f3eSDavid Gibson /* Allocate and/or reset the hash page table */ 1274c5f54f3eSDavid Gibson spapr_reallocate_hpt(spapr, 1275c5f54f3eSDavid Gibson spapr_hpt_shift_for_ramsize(machine->maxram_size), 1276c5f54f3eSDavid Gibson &error_fatal); 1277c5f54f3eSDavid Gibson 1278c5f54f3eSDavid Gibson /* Update the RMA size if necessary */ 1279c5f54f3eSDavid Gibson if (spapr->vrma_adjust) { 1280c5f54f3eSDavid Gibson spapr->rma_size = kvmppc_rma_size(spapr_node0_size(), 1281c5f54f3eSDavid Gibson spapr->htab_shift); 1282c5f54f3eSDavid Gibson } 128353018216SPaolo Bonzini 128453018216SPaolo Bonzini qemu_devices_reset(); 128553018216SPaolo Bonzini 1286b7d1f77aSBenjamin Herrenschmidt /* 1287b7d1f77aSBenjamin Herrenschmidt * We place the device tree and RTAS just below either the top of the RMA, 1288b7d1f77aSBenjamin Herrenschmidt * or just below 2GB, whichever is lowere, so that it can be 1289b7d1f77aSBenjamin Herrenschmidt * processed with 32-bit real mode code if necessary 1290b7d1f77aSBenjamin Herrenschmidt */ 1291b7d1f77aSBenjamin Herrenschmidt rtas_limit = MIN(spapr->rma_size, RTAS_MAX_ADDR); 1292cae172abSDavid Gibson rtas_addr = rtas_limit - RTAS_MAX_SIZE; 1293cae172abSDavid Gibson fdt_addr = rtas_addr - FDT_MAX_SIZE; 1294b7d1f77aSBenjamin Herrenschmidt 12956787d27bSMichael Roth /* if this reset wasn't generated by CAS, we should reset our 12966787d27bSMichael Roth * negotiated options and start from scratch */ 12976787d27bSMichael Roth if (!spapr->cas_reboot) { 12986787d27bSMichael Roth spapr_ovec_cleanup(spapr->ov5_cas); 12996787d27bSMichael Roth spapr->ov5_cas = spapr_ovec_new(); 13006787d27bSMichael Roth } 13016787d27bSMichael Roth 1302cae172abSDavid Gibson fdt = spapr_build_fdt(spapr, rtas_addr, spapr->rtas_size); 130353018216SPaolo Bonzini 13042cac78c1SDavid Gibson spapr_load_rtas(spapr, fdt, rtas_addr); 1305b7d1f77aSBenjamin Herrenschmidt 1306997b6cfcSDavid Gibson rc = fdt_pack(fdt); 1307997b6cfcSDavid Gibson 1308997b6cfcSDavid Gibson /* Should only fail if we've built a corrupted tree */ 1309997b6cfcSDavid Gibson assert(rc == 0); 1310997b6cfcSDavid Gibson 1311997b6cfcSDavid Gibson if (fdt_totalsize(fdt) > FDT_MAX_SIZE) { 1312997b6cfcSDavid Gibson error_report("FDT too big ! 0x%x bytes (max is 0x%x)", 1313997b6cfcSDavid Gibson fdt_totalsize(fdt), FDT_MAX_SIZE); 1314997b6cfcSDavid Gibson exit(1); 1315997b6cfcSDavid Gibson } 1316997b6cfcSDavid Gibson 1317997b6cfcSDavid Gibson /* Load the fdt */ 1318997b6cfcSDavid Gibson qemu_fdt_dumpdtb(fdt, fdt_totalsize(fdt)); 1319cae172abSDavid Gibson cpu_physical_memory_write(fdt_addr, fdt, fdt_totalsize(fdt)); 1320997b6cfcSDavid Gibson g_free(fdt); 1321997b6cfcSDavid Gibson 132253018216SPaolo Bonzini /* Set up the entry state */ 1323182735efSAndreas Färber first_ppc_cpu = POWERPC_CPU(first_cpu); 1324cae172abSDavid Gibson first_ppc_cpu->env.gpr[3] = fdt_addr; 1325182735efSAndreas Färber first_ppc_cpu->env.gpr[5] = 0; 1326182735efSAndreas Färber first_cpu->halted = 0; 13271b718907SDavid Gibson first_ppc_cpu->env.nip = SPAPR_ENTRY_POINT; 132853018216SPaolo Bonzini 13296787d27bSMichael Roth spapr->cas_reboot = false; 133053018216SPaolo Bonzini } 133153018216SPaolo Bonzini 133228e02042SDavid Gibson static void spapr_create_nvram(sPAPRMachineState *spapr) 133353018216SPaolo Bonzini { 13342ff3de68SMarkus Armbruster DeviceState *dev = qdev_create(&spapr->vio_bus->bus, "spapr-nvram"); 13353978b863SPaolo Bonzini DriveInfo *dinfo = drive_get(IF_PFLASH, 0, 0); 133653018216SPaolo Bonzini 13373978b863SPaolo Bonzini if (dinfo) { 13386231a6daSMarkus Armbruster qdev_prop_set_drive(dev, "drive", blk_by_legacy_dinfo(dinfo), 13396231a6daSMarkus Armbruster &error_fatal); 134053018216SPaolo Bonzini } 134153018216SPaolo Bonzini 134253018216SPaolo Bonzini qdev_init_nofail(dev); 134353018216SPaolo Bonzini 134453018216SPaolo Bonzini spapr->nvram = (struct sPAPRNVRAM *)dev; 134553018216SPaolo Bonzini } 134653018216SPaolo Bonzini 134728e02042SDavid Gibson static void spapr_rtc_create(sPAPRMachineState *spapr) 134828df36a1SDavid Gibson { 1349147ff807SCédric Le Goater object_initialize(&spapr->rtc, sizeof(spapr->rtc), TYPE_SPAPR_RTC); 1350147ff807SCédric Le Goater object_property_add_child(OBJECT(spapr), "rtc", OBJECT(&spapr->rtc), 1351147ff807SCédric Le Goater &error_fatal); 1352147ff807SCédric Le Goater object_property_set_bool(OBJECT(&spapr->rtc), true, "realized", 1353147ff807SCédric Le Goater &error_fatal); 1354147ff807SCédric Le Goater object_property_add_alias(OBJECT(spapr), "rtc-time", OBJECT(&spapr->rtc), 1355147ff807SCédric Le Goater "date", &error_fatal); 135628df36a1SDavid Gibson } 135728df36a1SDavid Gibson 135853018216SPaolo Bonzini /* Returns whether we want to use VGA or not */ 135914c6a894SDavid Gibson static bool spapr_vga_init(PCIBus *pci_bus, Error **errp) 136053018216SPaolo Bonzini { 136153018216SPaolo Bonzini switch (vga_interface_type) { 136253018216SPaolo Bonzini case VGA_NONE: 13637effdaa3SMark Wu return false; 13647effdaa3SMark Wu case VGA_DEVICE: 13657effdaa3SMark Wu return true; 136653018216SPaolo Bonzini case VGA_STD: 1367b798c190SBenjamin Herrenschmidt case VGA_VIRTIO: 136853018216SPaolo Bonzini return pci_vga_init(pci_bus) != NULL; 136953018216SPaolo Bonzini default: 137014c6a894SDavid Gibson error_setg(errp, 137114c6a894SDavid Gibson "Unsupported VGA mode, only -vga std or -vga virtio is supported"); 137214c6a894SDavid Gibson return false; 137353018216SPaolo Bonzini } 137453018216SPaolo Bonzini } 137553018216SPaolo Bonzini 1376880ae7deSDavid Gibson static int spapr_post_load(void *opaque, int version_id) 1377880ae7deSDavid Gibson { 137828e02042SDavid Gibson sPAPRMachineState *spapr = (sPAPRMachineState *)opaque; 1379880ae7deSDavid Gibson int err = 0; 1380880ae7deSDavid Gibson 1381a7ff1212SCédric Le Goater if (!object_dynamic_cast(OBJECT(spapr->ics), TYPE_ICS_KVM)) { 1382a7ff1212SCédric Le Goater int i; 1383a7ff1212SCédric Le Goater for (i = 0; i < spapr->nr_servers; i++) { 1384a7ff1212SCédric Le Goater icp_resend(&spapr->icps[i]); 1385a7ff1212SCédric Le Goater } 1386a7ff1212SCédric Le Goater } 1387a7ff1212SCédric Le Goater 1388631b22eaSStefan Weil /* In earlier versions, there was no separate qdev for the PAPR 1389880ae7deSDavid Gibson * RTC, so the RTC offset was stored directly in sPAPREnvironment. 1390880ae7deSDavid Gibson * So when migrating from those versions, poke the incoming offset 1391880ae7deSDavid Gibson * value into the RTC device */ 1392880ae7deSDavid Gibson if (version_id < 3) { 1393147ff807SCédric Le Goater err = spapr_rtc_import_offset(&spapr->rtc, spapr->rtc_offset); 1394880ae7deSDavid Gibson } 1395880ae7deSDavid Gibson 1396880ae7deSDavid Gibson return err; 1397880ae7deSDavid Gibson } 1398880ae7deSDavid Gibson 1399880ae7deSDavid Gibson static bool version_before_3(void *opaque, int version_id) 1400880ae7deSDavid Gibson { 1401880ae7deSDavid Gibson return version_id < 3; 1402880ae7deSDavid Gibson } 1403880ae7deSDavid Gibson 140462ef3760SMichael Roth static bool spapr_ov5_cas_needed(void *opaque) 140562ef3760SMichael Roth { 140662ef3760SMichael Roth sPAPRMachineState *spapr = opaque; 140762ef3760SMichael Roth sPAPROptionVector *ov5_mask = spapr_ovec_new(); 140862ef3760SMichael Roth sPAPROptionVector *ov5_legacy = spapr_ovec_new(); 140962ef3760SMichael Roth sPAPROptionVector *ov5_removed = spapr_ovec_new(); 141062ef3760SMichael Roth bool cas_needed; 141162ef3760SMichael Roth 141262ef3760SMichael Roth /* Prior to the introduction of sPAPROptionVector, we had two option 141362ef3760SMichael Roth * vectors we dealt with: OV5_FORM1_AFFINITY, and OV5_DRCONF_MEMORY. 141462ef3760SMichael Roth * Both of these options encode machine topology into the device-tree 141562ef3760SMichael Roth * in such a way that the now-booted OS should still be able to interact 141662ef3760SMichael Roth * appropriately with QEMU regardless of what options were actually 141762ef3760SMichael Roth * negotiatied on the source side. 141862ef3760SMichael Roth * 141962ef3760SMichael Roth * As such, we can avoid migrating the CAS-negotiated options if these 142062ef3760SMichael Roth * are the only options available on the current machine/platform. 142162ef3760SMichael Roth * Since these are the only options available for pseries-2.7 and 142262ef3760SMichael Roth * earlier, this allows us to maintain old->new/new->old migration 142362ef3760SMichael Roth * compatibility. 142462ef3760SMichael Roth * 142562ef3760SMichael Roth * For QEMU 2.8+, there are additional CAS-negotiatable options available 142662ef3760SMichael Roth * via default pseries-2.8 machines and explicit command-line parameters. 142762ef3760SMichael Roth * Some of these options, like OV5_HP_EVT, *do* require QEMU to be aware 142862ef3760SMichael Roth * of the actual CAS-negotiated values to continue working properly. For 142962ef3760SMichael Roth * example, availability of memory unplug depends on knowing whether 143062ef3760SMichael Roth * OV5_HP_EVT was negotiated via CAS. 143162ef3760SMichael Roth * 143262ef3760SMichael Roth * Thus, for any cases where the set of available CAS-negotiatable 143362ef3760SMichael Roth * options extends beyond OV5_FORM1_AFFINITY and OV5_DRCONF_MEMORY, we 143462ef3760SMichael Roth * include the CAS-negotiated options in the migration stream. 143562ef3760SMichael Roth */ 143662ef3760SMichael Roth spapr_ovec_set(ov5_mask, OV5_FORM1_AFFINITY); 143762ef3760SMichael Roth spapr_ovec_set(ov5_mask, OV5_DRCONF_MEMORY); 143862ef3760SMichael Roth 143962ef3760SMichael Roth /* spapr_ovec_diff returns true if bits were removed. we avoid using 144062ef3760SMichael Roth * the mask itself since in the future it's possible "legacy" bits may be 144162ef3760SMichael Roth * removed via machine options, which could generate a false positive 144262ef3760SMichael Roth * that breaks migration. 144362ef3760SMichael Roth */ 144462ef3760SMichael Roth spapr_ovec_intersect(ov5_legacy, spapr->ov5, ov5_mask); 144562ef3760SMichael Roth cas_needed = spapr_ovec_diff(ov5_removed, spapr->ov5, ov5_legacy); 144662ef3760SMichael Roth 144762ef3760SMichael Roth spapr_ovec_cleanup(ov5_mask); 144862ef3760SMichael Roth spapr_ovec_cleanup(ov5_legacy); 144962ef3760SMichael Roth spapr_ovec_cleanup(ov5_removed); 145062ef3760SMichael Roth 145162ef3760SMichael Roth return cas_needed; 145262ef3760SMichael Roth } 145362ef3760SMichael Roth 145462ef3760SMichael Roth static const VMStateDescription vmstate_spapr_ov5_cas = { 145562ef3760SMichael Roth .name = "spapr_option_vector_ov5_cas", 145662ef3760SMichael Roth .version_id = 1, 145762ef3760SMichael Roth .minimum_version_id = 1, 145862ef3760SMichael Roth .needed = spapr_ov5_cas_needed, 145962ef3760SMichael Roth .fields = (VMStateField[]) { 146062ef3760SMichael Roth VMSTATE_STRUCT_POINTER_V(ov5_cas, sPAPRMachineState, 1, 146162ef3760SMichael Roth vmstate_spapr_ovec, sPAPROptionVector), 146262ef3760SMichael Roth VMSTATE_END_OF_LIST() 146362ef3760SMichael Roth }, 146462ef3760SMichael Roth }; 146562ef3760SMichael Roth 14669861bb3eSSuraj Jitindar Singh static bool spapr_patb_entry_needed(void *opaque) 14679861bb3eSSuraj Jitindar Singh { 14689861bb3eSSuraj Jitindar Singh sPAPRMachineState *spapr = opaque; 14699861bb3eSSuraj Jitindar Singh 14709861bb3eSSuraj Jitindar Singh return !!spapr->patb_entry; 14719861bb3eSSuraj Jitindar Singh } 14729861bb3eSSuraj Jitindar Singh 14739861bb3eSSuraj Jitindar Singh static const VMStateDescription vmstate_spapr_patb_entry = { 14749861bb3eSSuraj Jitindar Singh .name = "spapr_patb_entry", 14759861bb3eSSuraj Jitindar Singh .version_id = 1, 14769861bb3eSSuraj Jitindar Singh .minimum_version_id = 1, 14779861bb3eSSuraj Jitindar Singh .needed = spapr_patb_entry_needed, 14789861bb3eSSuraj Jitindar Singh .fields = (VMStateField[]) { 14799861bb3eSSuraj Jitindar Singh VMSTATE_UINT64(patb_entry, sPAPRMachineState), 14809861bb3eSSuraj Jitindar Singh VMSTATE_END_OF_LIST() 14819861bb3eSSuraj Jitindar Singh }, 14829861bb3eSSuraj Jitindar Singh }; 14839861bb3eSSuraj Jitindar Singh 14844be21d56SDavid Gibson static const VMStateDescription vmstate_spapr = { 14854be21d56SDavid Gibson .name = "spapr", 1486880ae7deSDavid Gibson .version_id = 3, 14874be21d56SDavid Gibson .minimum_version_id = 1, 1488880ae7deSDavid Gibson .post_load = spapr_post_load, 14894be21d56SDavid Gibson .fields = (VMStateField[]) { 1490880ae7deSDavid Gibson /* used to be @next_irq */ 1491880ae7deSDavid Gibson VMSTATE_UNUSED_BUFFER(version_before_3, 0, 4), 14924be21d56SDavid Gibson 14934be21d56SDavid Gibson /* RTC offset */ 149428e02042SDavid Gibson VMSTATE_UINT64_TEST(rtc_offset, sPAPRMachineState, version_before_3), 1495880ae7deSDavid Gibson 149628e02042SDavid Gibson VMSTATE_PPC_TIMEBASE_V(tb, sPAPRMachineState, 2), 14974be21d56SDavid Gibson VMSTATE_END_OF_LIST() 14984be21d56SDavid Gibson }, 149962ef3760SMichael Roth .subsections = (const VMStateDescription*[]) { 150062ef3760SMichael Roth &vmstate_spapr_ov5_cas, 15019861bb3eSSuraj Jitindar Singh &vmstate_spapr_patb_entry, 150262ef3760SMichael Roth NULL 150362ef3760SMichael Roth } 15044be21d56SDavid Gibson }; 15054be21d56SDavid Gibson 15064be21d56SDavid Gibson static int htab_save_setup(QEMUFile *f, void *opaque) 15074be21d56SDavid Gibson { 150828e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 15094be21d56SDavid Gibson 15104be21d56SDavid Gibson /* "Iteration" header */ 15114be21d56SDavid Gibson qemu_put_be32(f, spapr->htab_shift); 15124be21d56SDavid Gibson 1513e68cb8b4SAlexey Kardashevskiy if (spapr->htab) { 1514e68cb8b4SAlexey Kardashevskiy spapr->htab_save_index = 0; 1515e68cb8b4SAlexey Kardashevskiy spapr->htab_first_pass = true; 1516e68cb8b4SAlexey Kardashevskiy } else { 1517e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 15184be21d56SDavid Gibson } 15194be21d56SDavid Gibson 1520e68cb8b4SAlexey Kardashevskiy 1521e68cb8b4SAlexey Kardashevskiy return 0; 1522e68cb8b4SAlexey Kardashevskiy } 15234be21d56SDavid Gibson 152428e02042SDavid Gibson static void htab_save_first_pass(QEMUFile *f, sPAPRMachineState *spapr, 15254be21d56SDavid Gibson int64_t max_ns) 15264be21d56SDavid Gibson { 1527378bc217SDavid Gibson bool has_timeout = max_ns != -1; 15284be21d56SDavid Gibson int htabslots = HTAB_SIZE(spapr) / HASH_PTE_SIZE_64; 15294be21d56SDavid Gibson int index = spapr->htab_save_index; 1530bc72ad67SAlex Bligh int64_t starttime = qemu_clock_get_ns(QEMU_CLOCK_REALTIME); 15314be21d56SDavid Gibson 15324be21d56SDavid Gibson assert(spapr->htab_first_pass); 15334be21d56SDavid Gibson 15344be21d56SDavid Gibson do { 15354be21d56SDavid Gibson int chunkstart; 15364be21d56SDavid Gibson 15374be21d56SDavid Gibson /* Consume invalid HPTEs */ 15384be21d56SDavid Gibson while ((index < htabslots) 15394be21d56SDavid Gibson && !HPTE_VALID(HPTE(spapr->htab, index))) { 15404be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 154124ec2863SMarc-André Lureau index++; 15424be21d56SDavid Gibson } 15434be21d56SDavid Gibson 15444be21d56SDavid Gibson /* Consume valid HPTEs */ 15454be21d56SDavid Gibson chunkstart = index; 1546338c25b6SSamuel Mendoza-Jonas while ((index < htabslots) && (index - chunkstart < USHRT_MAX) 15474be21d56SDavid Gibson && HPTE_VALID(HPTE(spapr->htab, index))) { 15484be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 154924ec2863SMarc-André Lureau index++; 15504be21d56SDavid Gibson } 15514be21d56SDavid Gibson 15524be21d56SDavid Gibson if (index > chunkstart) { 15534be21d56SDavid Gibson int n_valid = index - chunkstart; 15544be21d56SDavid Gibson 15554be21d56SDavid Gibson qemu_put_be32(f, chunkstart); 15564be21d56SDavid Gibson qemu_put_be16(f, n_valid); 15574be21d56SDavid Gibson qemu_put_be16(f, 0); 15584be21d56SDavid Gibson qemu_put_buffer(f, HPTE(spapr->htab, chunkstart), 15594be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_valid); 15604be21d56SDavid Gibson 1561378bc217SDavid Gibson if (has_timeout && 1562378bc217SDavid Gibson (qemu_clock_get_ns(QEMU_CLOCK_REALTIME) - starttime) > max_ns) { 15634be21d56SDavid Gibson break; 15644be21d56SDavid Gibson } 15654be21d56SDavid Gibson } 15664be21d56SDavid Gibson } while ((index < htabslots) && !qemu_file_rate_limit(f)); 15674be21d56SDavid Gibson 15684be21d56SDavid Gibson if (index >= htabslots) { 15694be21d56SDavid Gibson assert(index == htabslots); 15704be21d56SDavid Gibson index = 0; 15714be21d56SDavid Gibson spapr->htab_first_pass = false; 15724be21d56SDavid Gibson } 15734be21d56SDavid Gibson spapr->htab_save_index = index; 15744be21d56SDavid Gibson } 15754be21d56SDavid Gibson 157628e02042SDavid Gibson static int htab_save_later_pass(QEMUFile *f, sPAPRMachineState *spapr, 15774be21d56SDavid Gibson int64_t max_ns) 15784be21d56SDavid Gibson { 15794be21d56SDavid Gibson bool final = max_ns < 0; 15804be21d56SDavid Gibson int htabslots = HTAB_SIZE(spapr) / HASH_PTE_SIZE_64; 15814be21d56SDavid Gibson int examined = 0, sent = 0; 15824be21d56SDavid Gibson int index = spapr->htab_save_index; 1583bc72ad67SAlex Bligh int64_t starttime = qemu_clock_get_ns(QEMU_CLOCK_REALTIME); 15844be21d56SDavid Gibson 15854be21d56SDavid Gibson assert(!spapr->htab_first_pass); 15864be21d56SDavid Gibson 15874be21d56SDavid Gibson do { 15884be21d56SDavid Gibson int chunkstart, invalidstart; 15894be21d56SDavid Gibson 15904be21d56SDavid Gibson /* Consume non-dirty HPTEs */ 15914be21d56SDavid Gibson while ((index < htabslots) 15924be21d56SDavid Gibson && !HPTE_DIRTY(HPTE(spapr->htab, index))) { 15934be21d56SDavid Gibson index++; 15944be21d56SDavid Gibson examined++; 15954be21d56SDavid Gibson } 15964be21d56SDavid Gibson 15974be21d56SDavid Gibson chunkstart = index; 15984be21d56SDavid Gibson /* Consume valid dirty HPTEs */ 1599338c25b6SSamuel Mendoza-Jonas while ((index < htabslots) && (index - chunkstart < USHRT_MAX) 16004be21d56SDavid Gibson && HPTE_DIRTY(HPTE(spapr->htab, index)) 16014be21d56SDavid Gibson && HPTE_VALID(HPTE(spapr->htab, index))) { 16024be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 16034be21d56SDavid Gibson index++; 16044be21d56SDavid Gibson examined++; 16054be21d56SDavid Gibson } 16064be21d56SDavid Gibson 16074be21d56SDavid Gibson invalidstart = index; 16084be21d56SDavid Gibson /* Consume invalid dirty HPTEs */ 1609338c25b6SSamuel Mendoza-Jonas while ((index < htabslots) && (index - invalidstart < USHRT_MAX) 16104be21d56SDavid Gibson && HPTE_DIRTY(HPTE(spapr->htab, index)) 16114be21d56SDavid Gibson && !HPTE_VALID(HPTE(spapr->htab, index))) { 16124be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 16134be21d56SDavid Gibson index++; 16144be21d56SDavid Gibson examined++; 16154be21d56SDavid Gibson } 16164be21d56SDavid Gibson 16174be21d56SDavid Gibson if (index > chunkstart) { 16184be21d56SDavid Gibson int n_valid = invalidstart - chunkstart; 16194be21d56SDavid Gibson int n_invalid = index - invalidstart; 16204be21d56SDavid Gibson 16214be21d56SDavid Gibson qemu_put_be32(f, chunkstart); 16224be21d56SDavid Gibson qemu_put_be16(f, n_valid); 16234be21d56SDavid Gibson qemu_put_be16(f, n_invalid); 16244be21d56SDavid Gibson qemu_put_buffer(f, HPTE(spapr->htab, chunkstart), 16254be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_valid); 16264be21d56SDavid Gibson sent += index - chunkstart; 16274be21d56SDavid Gibson 1628bc72ad67SAlex Bligh if (!final && (qemu_clock_get_ns(QEMU_CLOCK_REALTIME) - starttime) > max_ns) { 16294be21d56SDavid Gibson break; 16304be21d56SDavid Gibson } 16314be21d56SDavid Gibson } 16324be21d56SDavid Gibson 16334be21d56SDavid Gibson if (examined >= htabslots) { 16344be21d56SDavid Gibson break; 16354be21d56SDavid Gibson } 16364be21d56SDavid Gibson 16374be21d56SDavid Gibson if (index >= htabslots) { 16384be21d56SDavid Gibson assert(index == htabslots); 16394be21d56SDavid Gibson index = 0; 16404be21d56SDavid Gibson } 16414be21d56SDavid Gibson } while ((examined < htabslots) && (!qemu_file_rate_limit(f) || final)); 16424be21d56SDavid Gibson 16434be21d56SDavid Gibson if (index >= htabslots) { 16444be21d56SDavid Gibson assert(index == htabslots); 16454be21d56SDavid Gibson index = 0; 16464be21d56SDavid Gibson } 16474be21d56SDavid Gibson 16484be21d56SDavid Gibson spapr->htab_save_index = index; 16494be21d56SDavid Gibson 1650e68cb8b4SAlexey Kardashevskiy return (examined >= htabslots) && (sent == 0) ? 1 : 0; 16514be21d56SDavid Gibson } 16524be21d56SDavid Gibson 1653e68cb8b4SAlexey Kardashevskiy #define MAX_ITERATION_NS 5000000 /* 5 ms */ 1654e68cb8b4SAlexey Kardashevskiy #define MAX_KVM_BUF_SIZE 2048 1655e68cb8b4SAlexey Kardashevskiy 16564be21d56SDavid Gibson static int htab_save_iterate(QEMUFile *f, void *opaque) 16574be21d56SDavid Gibson { 165828e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 1659715c5407SDavid Gibson int fd; 1660e68cb8b4SAlexey Kardashevskiy int rc = 0; 16614be21d56SDavid Gibson 16624be21d56SDavid Gibson /* Iteration header */ 16634be21d56SDavid Gibson qemu_put_be32(f, 0); 16644be21d56SDavid Gibson 1665e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1666e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 1667e68cb8b4SAlexey Kardashevskiy 1668715c5407SDavid Gibson fd = get_htab_fd(spapr); 1669715c5407SDavid Gibson if (fd < 0) { 1670715c5407SDavid Gibson return fd; 167101a57972SSamuel Mendoza-Jonas } 167201a57972SSamuel Mendoza-Jonas 1673715c5407SDavid Gibson rc = kvmppc_save_htab(f, fd, MAX_KVM_BUF_SIZE, MAX_ITERATION_NS); 1674e68cb8b4SAlexey Kardashevskiy if (rc < 0) { 1675e68cb8b4SAlexey Kardashevskiy return rc; 1676e68cb8b4SAlexey Kardashevskiy } 1677e68cb8b4SAlexey Kardashevskiy } else if (spapr->htab_first_pass) { 16784be21d56SDavid Gibson htab_save_first_pass(f, spapr, MAX_ITERATION_NS); 16794be21d56SDavid Gibson } else { 1680e68cb8b4SAlexey Kardashevskiy rc = htab_save_later_pass(f, spapr, MAX_ITERATION_NS); 16814be21d56SDavid Gibson } 16824be21d56SDavid Gibson 16834be21d56SDavid Gibson /* End marker */ 16844be21d56SDavid Gibson qemu_put_be32(f, 0); 16854be21d56SDavid Gibson qemu_put_be16(f, 0); 16864be21d56SDavid Gibson qemu_put_be16(f, 0); 16874be21d56SDavid Gibson 1688e68cb8b4SAlexey Kardashevskiy return rc; 16894be21d56SDavid Gibson } 16904be21d56SDavid Gibson 16914be21d56SDavid Gibson static int htab_save_complete(QEMUFile *f, void *opaque) 16924be21d56SDavid Gibson { 169328e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 1694715c5407SDavid Gibson int fd; 16954be21d56SDavid Gibson 16964be21d56SDavid Gibson /* Iteration header */ 16974be21d56SDavid Gibson qemu_put_be32(f, 0); 16984be21d56SDavid Gibson 1699e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1700e68cb8b4SAlexey Kardashevskiy int rc; 1701e68cb8b4SAlexey Kardashevskiy 1702e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 1703e68cb8b4SAlexey Kardashevskiy 1704715c5407SDavid Gibson fd = get_htab_fd(spapr); 1705715c5407SDavid Gibson if (fd < 0) { 1706715c5407SDavid Gibson return fd; 170701a57972SSamuel Mendoza-Jonas } 170801a57972SSamuel Mendoza-Jonas 1709715c5407SDavid Gibson rc = kvmppc_save_htab(f, fd, MAX_KVM_BUF_SIZE, -1); 1710e68cb8b4SAlexey Kardashevskiy if (rc < 0) { 1711e68cb8b4SAlexey Kardashevskiy return rc; 1712e68cb8b4SAlexey Kardashevskiy } 1713e68cb8b4SAlexey Kardashevskiy } else { 1714378bc217SDavid Gibson if (spapr->htab_first_pass) { 1715378bc217SDavid Gibson htab_save_first_pass(f, spapr, -1); 1716378bc217SDavid Gibson } 17174be21d56SDavid Gibson htab_save_later_pass(f, spapr, -1); 1718e68cb8b4SAlexey Kardashevskiy } 17194be21d56SDavid Gibson 17204be21d56SDavid Gibson /* End marker */ 17214be21d56SDavid Gibson qemu_put_be32(f, 0); 17224be21d56SDavid Gibson qemu_put_be16(f, 0); 17234be21d56SDavid Gibson qemu_put_be16(f, 0); 17244be21d56SDavid Gibson 17254be21d56SDavid Gibson return 0; 17264be21d56SDavid Gibson } 17274be21d56SDavid Gibson 17284be21d56SDavid Gibson static int htab_load(QEMUFile *f, void *opaque, int version_id) 17294be21d56SDavid Gibson { 173028e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 17314be21d56SDavid Gibson uint32_t section_hdr; 1732e68cb8b4SAlexey Kardashevskiy int fd = -1; 17334be21d56SDavid Gibson 17344be21d56SDavid Gibson if (version_id < 1 || version_id > 1) { 173598a5d100SDavid Gibson error_report("htab_load() bad version"); 17364be21d56SDavid Gibson return -EINVAL; 17374be21d56SDavid Gibson } 17384be21d56SDavid Gibson 17394be21d56SDavid Gibson section_hdr = qemu_get_be32(f); 17404be21d56SDavid Gibson 17414be21d56SDavid Gibson if (section_hdr) { 17429897e462SGreg Kurz Error *local_err = NULL; 1743c5f54f3eSDavid Gibson 1744c5f54f3eSDavid Gibson /* First section gives the htab size */ 1745c5f54f3eSDavid Gibson spapr_reallocate_hpt(spapr, section_hdr, &local_err); 1746c5f54f3eSDavid Gibson if (local_err) { 1747c5f54f3eSDavid Gibson error_report_err(local_err); 17484be21d56SDavid Gibson return -EINVAL; 17494be21d56SDavid Gibson } 17504be21d56SDavid Gibson return 0; 17514be21d56SDavid Gibson } 17524be21d56SDavid Gibson 1753e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1754e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 1755e68cb8b4SAlexey Kardashevskiy 1756e68cb8b4SAlexey Kardashevskiy fd = kvmppc_get_htab_fd(true); 1757e68cb8b4SAlexey Kardashevskiy if (fd < 0) { 175898a5d100SDavid Gibson error_report("Unable to open fd to restore KVM hash table: %s", 1759e68cb8b4SAlexey Kardashevskiy strerror(errno)); 1760e68cb8b4SAlexey Kardashevskiy } 1761e68cb8b4SAlexey Kardashevskiy } 1762e68cb8b4SAlexey Kardashevskiy 17634be21d56SDavid Gibson while (true) { 17644be21d56SDavid Gibson uint32_t index; 17654be21d56SDavid Gibson uint16_t n_valid, n_invalid; 17664be21d56SDavid Gibson 17674be21d56SDavid Gibson index = qemu_get_be32(f); 17684be21d56SDavid Gibson n_valid = qemu_get_be16(f); 17694be21d56SDavid Gibson n_invalid = qemu_get_be16(f); 17704be21d56SDavid Gibson 17714be21d56SDavid Gibson if ((index == 0) && (n_valid == 0) && (n_invalid == 0)) { 17724be21d56SDavid Gibson /* End of Stream */ 17734be21d56SDavid Gibson break; 17744be21d56SDavid Gibson } 17754be21d56SDavid Gibson 1776e68cb8b4SAlexey Kardashevskiy if ((index + n_valid + n_invalid) > 17774be21d56SDavid Gibson (HTAB_SIZE(spapr) / HASH_PTE_SIZE_64)) { 17784be21d56SDavid Gibson /* Bad index in stream */ 177998a5d100SDavid Gibson error_report( 178098a5d100SDavid Gibson "htab_load() bad index %d (%hd+%hd entries) in htab stream (htab_shift=%d)", 178198a5d100SDavid Gibson index, n_valid, n_invalid, spapr->htab_shift); 17824be21d56SDavid Gibson return -EINVAL; 17834be21d56SDavid Gibson } 17844be21d56SDavid Gibson 1785e68cb8b4SAlexey Kardashevskiy if (spapr->htab) { 17864be21d56SDavid Gibson if (n_valid) { 17874be21d56SDavid Gibson qemu_get_buffer(f, HPTE(spapr->htab, index), 17884be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_valid); 17894be21d56SDavid Gibson } 17904be21d56SDavid Gibson if (n_invalid) { 17914be21d56SDavid Gibson memset(HPTE(spapr->htab, index + n_valid), 0, 17924be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_invalid); 17934be21d56SDavid Gibson } 1794e68cb8b4SAlexey Kardashevskiy } else { 1795e68cb8b4SAlexey Kardashevskiy int rc; 1796e68cb8b4SAlexey Kardashevskiy 1797e68cb8b4SAlexey Kardashevskiy assert(fd >= 0); 1798e68cb8b4SAlexey Kardashevskiy 1799e68cb8b4SAlexey Kardashevskiy rc = kvmppc_load_htab_chunk(f, fd, index, n_valid, n_invalid); 1800e68cb8b4SAlexey Kardashevskiy if (rc < 0) { 1801e68cb8b4SAlexey Kardashevskiy return rc; 1802e68cb8b4SAlexey Kardashevskiy } 1803e68cb8b4SAlexey Kardashevskiy } 1804e68cb8b4SAlexey Kardashevskiy } 1805e68cb8b4SAlexey Kardashevskiy 1806e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1807e68cb8b4SAlexey Kardashevskiy assert(fd >= 0); 1808e68cb8b4SAlexey Kardashevskiy close(fd); 18094be21d56SDavid Gibson } 18104be21d56SDavid Gibson 18114be21d56SDavid Gibson return 0; 18124be21d56SDavid Gibson } 18134be21d56SDavid Gibson 1814c573fc03SThomas Huth static void htab_cleanup(void *opaque) 1815c573fc03SThomas Huth { 1816c573fc03SThomas Huth sPAPRMachineState *spapr = opaque; 1817c573fc03SThomas Huth 1818c573fc03SThomas Huth close_htab_fd(spapr); 1819c573fc03SThomas Huth } 1820c573fc03SThomas Huth 18214be21d56SDavid Gibson static SaveVMHandlers savevm_htab_handlers = { 18224be21d56SDavid Gibson .save_live_setup = htab_save_setup, 18234be21d56SDavid Gibson .save_live_iterate = htab_save_iterate, 1824a3e06c3dSDr. David Alan Gilbert .save_live_complete_precopy = htab_save_complete, 1825c573fc03SThomas Huth .cleanup = htab_cleanup, 18264be21d56SDavid Gibson .load_state = htab_load, 18274be21d56SDavid Gibson }; 18284be21d56SDavid Gibson 18295b2128d2SAlexander Graf static void spapr_boot_set(void *opaque, const char *boot_device, 18305b2128d2SAlexander Graf Error **errp) 18315b2128d2SAlexander Graf { 18325b2128d2SAlexander Graf MachineState *machine = MACHINE(qdev_get_machine()); 18335b2128d2SAlexander Graf machine->boot_order = g_strdup(boot_device); 18345b2128d2SAlexander Graf } 18355b2128d2SAlexander Graf 1836224245bfSDavid Gibson /* 1837224245bfSDavid Gibson * Reset routine for LMB DR devices. 1838224245bfSDavid Gibson * 1839224245bfSDavid Gibson * Unlike PCI DR devices, LMB DR devices explicitly register this reset 1840224245bfSDavid Gibson * routine. Reset for PCI DR devices will be handled by PHB reset routine 1841224245bfSDavid Gibson * when it walks all its children devices. LMB devices reset occurs 1842224245bfSDavid Gibson * as part of spapr_ppc_reset(). 1843224245bfSDavid Gibson */ 1844224245bfSDavid Gibson static void spapr_drc_reset(void *opaque) 1845224245bfSDavid Gibson { 1846224245bfSDavid Gibson sPAPRDRConnector *drc = opaque; 1847224245bfSDavid Gibson DeviceState *d = DEVICE(drc); 1848224245bfSDavid Gibson 1849224245bfSDavid Gibson if (d) { 1850224245bfSDavid Gibson device_reset(d); 1851224245bfSDavid Gibson } 1852224245bfSDavid Gibson } 1853224245bfSDavid Gibson 1854224245bfSDavid Gibson static void spapr_create_lmb_dr_connectors(sPAPRMachineState *spapr) 1855224245bfSDavid Gibson { 1856224245bfSDavid Gibson MachineState *machine = MACHINE(spapr); 1857224245bfSDavid Gibson uint64_t lmb_size = SPAPR_MEMORY_BLOCK_SIZE; 1858e8f986fcSBharata B Rao uint32_t nr_lmbs = (machine->maxram_size - machine->ram_size)/lmb_size; 1859224245bfSDavid Gibson int i; 1860224245bfSDavid Gibson 1861224245bfSDavid Gibson for (i = 0; i < nr_lmbs; i++) { 1862224245bfSDavid Gibson sPAPRDRConnector *drc; 1863224245bfSDavid Gibson uint64_t addr; 1864224245bfSDavid Gibson 1865e8f986fcSBharata B Rao addr = i * lmb_size + spapr->hotplug_memory.base; 1866224245bfSDavid Gibson drc = spapr_dr_connector_new(OBJECT(spapr), SPAPR_DR_CONNECTOR_TYPE_LMB, 1867224245bfSDavid Gibson addr/lmb_size); 1868224245bfSDavid Gibson qemu_register_reset(spapr_drc_reset, drc); 1869224245bfSDavid Gibson } 1870224245bfSDavid Gibson } 1871224245bfSDavid Gibson 1872224245bfSDavid Gibson /* 1873224245bfSDavid Gibson * If RAM size, maxmem size and individual node mem sizes aren't aligned 1874224245bfSDavid Gibson * to SPAPR_MEMORY_BLOCK_SIZE(256MB), then refuse to start the guest 1875224245bfSDavid Gibson * since we can't support such unaligned sizes with DRCONF_MEMORY. 1876224245bfSDavid Gibson */ 18777c150d6fSDavid Gibson static void spapr_validate_node_memory(MachineState *machine, Error **errp) 1878224245bfSDavid Gibson { 1879224245bfSDavid Gibson int i; 1880224245bfSDavid Gibson 18817c150d6fSDavid Gibson if (machine->ram_size % SPAPR_MEMORY_BLOCK_SIZE) { 18827c150d6fSDavid Gibson error_setg(errp, "Memory size 0x" RAM_ADDR_FMT 18837c150d6fSDavid Gibson " is not aligned to %llu MiB", 18847c150d6fSDavid Gibson machine->ram_size, 1885224245bfSDavid Gibson SPAPR_MEMORY_BLOCK_SIZE / M_BYTE); 18867c150d6fSDavid Gibson return; 18877c150d6fSDavid Gibson } 18887c150d6fSDavid Gibson 18897c150d6fSDavid Gibson if (machine->maxram_size % SPAPR_MEMORY_BLOCK_SIZE) { 18907c150d6fSDavid Gibson error_setg(errp, "Maximum memory size 0x" RAM_ADDR_FMT 18917c150d6fSDavid Gibson " is not aligned to %llu MiB", 18927c150d6fSDavid Gibson machine->ram_size, 18937c150d6fSDavid Gibson SPAPR_MEMORY_BLOCK_SIZE / M_BYTE); 18947c150d6fSDavid Gibson return; 1895224245bfSDavid Gibson } 1896224245bfSDavid Gibson 1897224245bfSDavid Gibson for (i = 0; i < nb_numa_nodes; i++) { 1898224245bfSDavid Gibson if (numa_info[i].node_mem % SPAPR_MEMORY_BLOCK_SIZE) { 18997c150d6fSDavid Gibson error_setg(errp, 19007c150d6fSDavid Gibson "Node %d memory size 0x%" PRIx64 19017c150d6fSDavid Gibson " is not aligned to %llu MiB", 19027c150d6fSDavid Gibson i, numa_info[i].node_mem, 1903224245bfSDavid Gibson SPAPR_MEMORY_BLOCK_SIZE / M_BYTE); 19047c150d6fSDavid Gibson return; 1905224245bfSDavid Gibson } 1906224245bfSDavid Gibson } 1907224245bfSDavid Gibson } 1908224245bfSDavid Gibson 1909535455fdSIgor Mammedov /* find cpu slot in machine->possible_cpus by core_id */ 1910535455fdSIgor Mammedov static CPUArchId *spapr_find_cpu_slot(MachineState *ms, uint32_t id, int *idx) 1911535455fdSIgor Mammedov { 1912535455fdSIgor Mammedov int index = id / smp_threads; 1913535455fdSIgor Mammedov 1914535455fdSIgor Mammedov if (index >= ms->possible_cpus->len) { 1915535455fdSIgor Mammedov return NULL; 1916535455fdSIgor Mammedov } 1917535455fdSIgor Mammedov if (idx) { 1918535455fdSIgor Mammedov *idx = index; 1919535455fdSIgor Mammedov } 1920535455fdSIgor Mammedov return &ms->possible_cpus->cpus[index]; 1921535455fdSIgor Mammedov } 1922535455fdSIgor Mammedov 19230c86d0fdSDavid Gibson static void spapr_init_cpus(sPAPRMachineState *spapr) 19240c86d0fdSDavid Gibson { 19250c86d0fdSDavid Gibson MachineState *machine = MACHINE(spapr); 19260c86d0fdSDavid Gibson MachineClass *mc = MACHINE_GET_CLASS(machine); 19270c86d0fdSDavid Gibson char *type = spapr_get_cpu_core_type(machine->cpu_model); 19280c86d0fdSDavid Gibson int smt = kvmppc_smt_threads(); 1929535455fdSIgor Mammedov const CPUArchIdList *possible_cpus; 1930535455fdSIgor Mammedov int boot_cores_nr = smp_cpus / smp_threads; 19310c86d0fdSDavid Gibson int i; 19320c86d0fdSDavid Gibson 19330c86d0fdSDavid Gibson if (!type) { 19340c86d0fdSDavid Gibson error_report("Unable to find sPAPR CPU Core definition"); 19350c86d0fdSDavid Gibson exit(1); 19360c86d0fdSDavid Gibson } 19370c86d0fdSDavid Gibson 1938535455fdSIgor Mammedov possible_cpus = mc->possible_cpu_arch_ids(machine); 1939c5514d0eSIgor Mammedov if (mc->has_hotpluggable_cpus) { 19400c86d0fdSDavid Gibson if (smp_cpus % smp_threads) { 19410c86d0fdSDavid Gibson error_report("smp_cpus (%u) must be multiple of threads (%u)", 19420c86d0fdSDavid Gibson smp_cpus, smp_threads); 19430c86d0fdSDavid Gibson exit(1); 19440c86d0fdSDavid Gibson } 19450c86d0fdSDavid Gibson if (max_cpus % smp_threads) { 19460c86d0fdSDavid Gibson error_report("max_cpus (%u) must be multiple of threads (%u)", 19470c86d0fdSDavid Gibson max_cpus, smp_threads); 19480c86d0fdSDavid Gibson exit(1); 19490c86d0fdSDavid Gibson } 19500c86d0fdSDavid Gibson } else { 19510c86d0fdSDavid Gibson if (max_cpus != smp_cpus) { 19520c86d0fdSDavid Gibson error_report("This machine version does not support CPU hotplug"); 19530c86d0fdSDavid Gibson exit(1); 19540c86d0fdSDavid Gibson } 1955535455fdSIgor Mammedov boot_cores_nr = possible_cpus->len; 19560c86d0fdSDavid Gibson } 19570c86d0fdSDavid Gibson 1958535455fdSIgor Mammedov for (i = 0; i < possible_cpus->len; i++) { 19590c86d0fdSDavid Gibson int core_id = i * smp_threads; 19600c86d0fdSDavid Gibson 1961c5514d0eSIgor Mammedov if (mc->has_hotpluggable_cpus) { 19620c86d0fdSDavid Gibson sPAPRDRConnector *drc = 19630c86d0fdSDavid Gibson spapr_dr_connector_new(OBJECT(spapr), 19640c86d0fdSDavid Gibson SPAPR_DR_CONNECTOR_TYPE_CPU, 19650c86d0fdSDavid Gibson (core_id / smp_threads) * smt); 19660c86d0fdSDavid Gibson 19670c86d0fdSDavid Gibson qemu_register_reset(spapr_drc_reset, drc); 19680c86d0fdSDavid Gibson } 19690c86d0fdSDavid Gibson 1970535455fdSIgor Mammedov if (i < boot_cores_nr) { 19710c86d0fdSDavid Gibson Object *core = object_new(type); 19720c86d0fdSDavid Gibson int nr_threads = smp_threads; 19730c86d0fdSDavid Gibson 19740c86d0fdSDavid Gibson /* Handle the partially filled core for older machine types */ 19750c86d0fdSDavid Gibson if ((i + 1) * smp_threads >= smp_cpus) { 19760c86d0fdSDavid Gibson nr_threads = smp_cpus - i * smp_threads; 19770c86d0fdSDavid Gibson } 19780c86d0fdSDavid Gibson 19790c86d0fdSDavid Gibson object_property_set_int(core, nr_threads, "nr-threads", 19800c86d0fdSDavid Gibson &error_fatal); 19810c86d0fdSDavid Gibson object_property_set_int(core, core_id, CPU_CORE_PROP_CORE_ID, 19820c86d0fdSDavid Gibson &error_fatal); 19830c86d0fdSDavid Gibson object_property_set_bool(core, true, "realized", &error_fatal); 19840c86d0fdSDavid Gibson } 19850c86d0fdSDavid Gibson } 19860c86d0fdSDavid Gibson g_free(type); 19870c86d0fdSDavid Gibson } 19880c86d0fdSDavid Gibson 198953018216SPaolo Bonzini /* pSeries LPAR / sPAPR hardware init */ 19903ef96221SMarcel Apfelbaum static void ppc_spapr_init(MachineState *machine) 199153018216SPaolo Bonzini { 199228e02042SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(machine); 1993224245bfSDavid Gibson sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(machine); 19943ef96221SMarcel Apfelbaum const char *kernel_filename = machine->kernel_filename; 19953ef96221SMarcel Apfelbaum const char *initrd_filename = machine->initrd_filename; 199653018216SPaolo Bonzini PCIHostState *phb; 199753018216SPaolo Bonzini int i; 199853018216SPaolo Bonzini MemoryRegion *sysmem = get_system_memory(); 199953018216SPaolo Bonzini MemoryRegion *ram = g_new(MemoryRegion, 1); 2000658fa66bSAlexey Kardashevskiy MemoryRegion *rma_region; 2001658fa66bSAlexey Kardashevskiy void *rma = NULL; 200253018216SPaolo Bonzini hwaddr rma_alloc_size; 2003b082d65aSAlexey Kardashevskiy hwaddr node0_size = spapr_node0_size(); 2004b7d1f77aSBenjamin Herrenschmidt long load_limit, fw_size; 200553018216SPaolo Bonzini char *filename; 200694a94e4cSBharata B Rao int smt = kvmppc_smt_threads(); 200753018216SPaolo Bonzini 2008226419d6SMichael S. Tsirkin msi_nonbroken = true; 200953018216SPaolo Bonzini 201053018216SPaolo Bonzini QLIST_INIT(&spapr->phbs); 201153018216SPaolo Bonzini 201253018216SPaolo Bonzini /* Allocate RMA if necessary */ 2013658fa66bSAlexey Kardashevskiy rma_alloc_size = kvmppc_alloc_rma(&rma); 201453018216SPaolo Bonzini 201553018216SPaolo Bonzini if (rma_alloc_size == -1) { 2016730fce59SThomas Huth error_report("Unable to create RMA"); 201753018216SPaolo Bonzini exit(1); 201853018216SPaolo Bonzini } 201953018216SPaolo Bonzini 2020c4177479SAlexey Kardashevskiy if (rma_alloc_size && (rma_alloc_size < node0_size)) { 202153018216SPaolo Bonzini spapr->rma_size = rma_alloc_size; 202253018216SPaolo Bonzini } else { 2023c4177479SAlexey Kardashevskiy spapr->rma_size = node0_size; 202453018216SPaolo Bonzini 202553018216SPaolo Bonzini /* With KVM, we don't actually know whether KVM supports an 202653018216SPaolo Bonzini * unbounded RMA (PR KVM) or is limited by the hash table size 202753018216SPaolo Bonzini * (HV KVM using VRMA), so we always assume the latter 202853018216SPaolo Bonzini * 202953018216SPaolo Bonzini * In that case, we also limit the initial allocations for RTAS 203053018216SPaolo Bonzini * etc... to 256M since we have no way to know what the VRMA size 203153018216SPaolo Bonzini * is going to be as it depends on the size of the hash table 203253018216SPaolo Bonzini * isn't determined yet. 203353018216SPaolo Bonzini */ 203453018216SPaolo Bonzini if (kvm_enabled()) { 203553018216SPaolo Bonzini spapr->vrma_adjust = 1; 203653018216SPaolo Bonzini spapr->rma_size = MIN(spapr->rma_size, 0x10000000); 203753018216SPaolo Bonzini } 2038912acdf4SBenjamin Herrenschmidt 2039912acdf4SBenjamin Herrenschmidt /* Actually we don't support unbounded RMA anymore since we 2040912acdf4SBenjamin Herrenschmidt * added proper emulation of HV mode. The max we can get is 2041912acdf4SBenjamin Herrenschmidt * 16G which also happens to be what we configure for PAPR 2042912acdf4SBenjamin Herrenschmidt * mode so make sure we don't do anything bigger than that 2043912acdf4SBenjamin Herrenschmidt */ 2044912acdf4SBenjamin Herrenschmidt spapr->rma_size = MIN(spapr->rma_size, 0x400000000ull); 204553018216SPaolo Bonzini } 204653018216SPaolo Bonzini 2047c4177479SAlexey Kardashevskiy if (spapr->rma_size > node0_size) { 2048d54e4d76SDavid Gibson error_report("Numa node 0 has to span the RMA (%#08"HWADDR_PRIx")", 2049c4177479SAlexey Kardashevskiy spapr->rma_size); 2050c4177479SAlexey Kardashevskiy exit(1); 2051c4177479SAlexey Kardashevskiy } 2052c4177479SAlexey Kardashevskiy 2053b7d1f77aSBenjamin Herrenschmidt /* Setup a load limit for the ramdisk leaving room for SLOF and FDT */ 2054b7d1f77aSBenjamin Herrenschmidt load_limit = MIN(spapr->rma_size, RTAS_MAX_ADDR) - FW_OVERHEAD; 205553018216SPaolo Bonzini 20567b565160SDavid Gibson /* Set up Interrupt Controller before we create the VCPUs */ 2057e6f7e110SCédric Le Goater xics_system_init(machine, DIV_ROUND_UP(max_cpus * smt, smp_threads), 2058161deaf2SBenjamin Herrenschmidt XICS_IRQS_SPAPR, &error_fatal); 20597b565160SDavid Gibson 2060facdb8b6SMichael Roth /* Set up containers for ibm,client-set-architecture negotiated options */ 2061facdb8b6SMichael Roth spapr->ov5 = spapr_ovec_new(); 2062facdb8b6SMichael Roth spapr->ov5_cas = spapr_ovec_new(); 2063facdb8b6SMichael Roth 2064224245bfSDavid Gibson if (smc->dr_lmb_enabled) { 2065facdb8b6SMichael Roth spapr_ovec_set(spapr->ov5, OV5_DRCONF_MEMORY); 20667c150d6fSDavid Gibson spapr_validate_node_memory(machine, &error_fatal); 2067224245bfSDavid Gibson } 2068224245bfSDavid Gibson 2069417ece33SMichael Roth spapr_ovec_set(spapr->ov5, OV5_FORM1_AFFINITY); 2070417ece33SMichael Roth 2071ffbb1705SMichael Roth /* advertise support for dedicated HP event source to guests */ 2072ffbb1705SMichael Roth if (spapr->use_hotplug_event_source) { 2073ffbb1705SMichael Roth spapr_ovec_set(spapr->ov5, OV5_HP_EVT); 2074ffbb1705SMichael Roth } 2075ffbb1705SMichael Roth 207653018216SPaolo Bonzini /* init CPUs */ 207719fb2c36SBharata B Rao if (machine->cpu_model == NULL) { 20783daa4a9fSThomas Huth machine->cpu_model = kvm_enabled() ? "host" : smc->tcg_default_cpu; 207953018216SPaolo Bonzini } 208094a94e4cSBharata B Rao 2081e703d2f7SGreg Kurz ppc_cpu_parse_features(machine->cpu_model); 2082e703d2f7SGreg Kurz 20830c86d0fdSDavid Gibson spapr_init_cpus(spapr); 208453018216SPaolo Bonzini 2085026bfd89SDavid Gibson if (kvm_enabled()) { 2086026bfd89SDavid Gibson /* Enable H_LOGICAL_CI_* so SLOF can talk to in-kernel devices */ 2087026bfd89SDavid Gibson kvmppc_enable_logical_ci_hcalls(); 2088ef9971ddSAlexey Kardashevskiy kvmppc_enable_set_mode_hcall(); 20895145ad4fSNathan Whitehorn 20905145ad4fSNathan Whitehorn /* H_CLEAR_MOD/_REF are mandatory in PAPR, but off by default */ 20915145ad4fSNathan Whitehorn kvmppc_enable_clear_ref_mod_hcalls(); 2092026bfd89SDavid Gibson } 2093026bfd89SDavid Gibson 209453018216SPaolo Bonzini /* allocate RAM */ 2095f92f5da1SAlexey Kardashevskiy memory_region_allocate_system_memory(ram, NULL, "ppc_spapr.ram", 2096fb164994SDavid Gibson machine->ram_size); 2097f92f5da1SAlexey Kardashevskiy memory_region_add_subregion(sysmem, 0, ram); 209853018216SPaolo Bonzini 2099658fa66bSAlexey Kardashevskiy if (rma_alloc_size && rma) { 2100658fa66bSAlexey Kardashevskiy rma_region = g_new(MemoryRegion, 1); 2101658fa66bSAlexey Kardashevskiy memory_region_init_ram_ptr(rma_region, NULL, "ppc_spapr.rma", 2102658fa66bSAlexey Kardashevskiy rma_alloc_size, rma); 2103658fa66bSAlexey Kardashevskiy vmstate_register_ram_global(rma_region); 2104658fa66bSAlexey Kardashevskiy memory_region_add_subregion(sysmem, 0, rma_region); 2105658fa66bSAlexey Kardashevskiy } 2106658fa66bSAlexey Kardashevskiy 21074a1c9cf0SBharata B Rao /* initialize hotplug memory address space */ 21084a1c9cf0SBharata B Rao if (machine->ram_size < machine->maxram_size) { 21094a1c9cf0SBharata B Rao ram_addr_t hotplug_mem_size = machine->maxram_size - machine->ram_size; 211071c9a3ddSBharata B Rao /* 211171c9a3ddSBharata B Rao * Limit the number of hotpluggable memory slots to half the number 211271c9a3ddSBharata B Rao * slots that KVM supports, leaving the other half for PCI and other 211371c9a3ddSBharata B Rao * devices. However ensure that number of slots doesn't drop below 32. 211471c9a3ddSBharata B Rao */ 211571c9a3ddSBharata B Rao int max_memslots = kvm_enabled() ? kvm_get_max_memslots() / 2 : 211671c9a3ddSBharata B Rao SPAPR_MAX_RAM_SLOTS; 21174a1c9cf0SBharata B Rao 211871c9a3ddSBharata B Rao if (max_memslots < SPAPR_MAX_RAM_SLOTS) { 211971c9a3ddSBharata B Rao max_memslots = SPAPR_MAX_RAM_SLOTS; 212071c9a3ddSBharata B Rao } 212171c9a3ddSBharata B Rao if (machine->ram_slots > max_memslots) { 2122d54e4d76SDavid Gibson error_report("Specified number of memory slots %" 2123d54e4d76SDavid Gibson PRIu64" exceeds max supported %d", 212471c9a3ddSBharata B Rao machine->ram_slots, max_memslots); 2125d54e4d76SDavid Gibson exit(1); 21264a1c9cf0SBharata B Rao } 21274a1c9cf0SBharata B Rao 21284a1c9cf0SBharata B Rao spapr->hotplug_memory.base = ROUND_UP(machine->ram_size, 21294a1c9cf0SBharata B Rao SPAPR_HOTPLUG_MEM_ALIGN); 21304a1c9cf0SBharata B Rao memory_region_init(&spapr->hotplug_memory.mr, OBJECT(spapr), 21314a1c9cf0SBharata B Rao "hotplug-memory", hotplug_mem_size); 21324a1c9cf0SBharata B Rao memory_region_add_subregion(sysmem, spapr->hotplug_memory.base, 21334a1c9cf0SBharata B Rao &spapr->hotplug_memory.mr); 21344a1c9cf0SBharata B Rao } 21354a1c9cf0SBharata B Rao 2136224245bfSDavid Gibson if (smc->dr_lmb_enabled) { 2137224245bfSDavid Gibson spapr_create_lmb_dr_connectors(spapr); 2138224245bfSDavid Gibson } 2139224245bfSDavid Gibson 214053018216SPaolo Bonzini filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, "spapr-rtas.bin"); 21414c56440dSStefan Weil if (!filename) { 2142730fce59SThomas Huth error_report("Could not find LPAR rtas '%s'", "spapr-rtas.bin"); 21434c56440dSStefan Weil exit(1); 21444c56440dSStefan Weil } 2145b7d1f77aSBenjamin Herrenschmidt spapr->rtas_size = get_image_size(filename); 21468afc22a2SZhou Jie if (spapr->rtas_size < 0) { 21478afc22a2SZhou Jie error_report("Could not get size of LPAR rtas '%s'", filename); 21488afc22a2SZhou Jie exit(1); 21498afc22a2SZhou Jie } 2150b7d1f77aSBenjamin Herrenschmidt spapr->rtas_blob = g_malloc(spapr->rtas_size); 2151b7d1f77aSBenjamin Herrenschmidt if (load_image_size(filename, spapr->rtas_blob, spapr->rtas_size) < 0) { 2152730fce59SThomas Huth error_report("Could not load LPAR rtas '%s'", filename); 215353018216SPaolo Bonzini exit(1); 215453018216SPaolo Bonzini } 215553018216SPaolo Bonzini if (spapr->rtas_size > RTAS_MAX_SIZE) { 2156730fce59SThomas Huth error_report("RTAS too big ! 0x%zx bytes (max is 0x%x)", 21572f285bddSPeter Maydell (size_t)spapr->rtas_size, RTAS_MAX_SIZE); 215853018216SPaolo Bonzini exit(1); 215953018216SPaolo Bonzini } 216053018216SPaolo Bonzini g_free(filename); 216153018216SPaolo Bonzini 2162ffbb1705SMichael Roth /* Set up RTAS event infrastructure */ 216353018216SPaolo Bonzini spapr_events_init(spapr); 216453018216SPaolo Bonzini 216512f42174SDavid Gibson /* Set up the RTC RTAS interfaces */ 216628df36a1SDavid Gibson spapr_rtc_create(spapr); 216712f42174SDavid Gibson 216853018216SPaolo Bonzini /* Set up VIO bus */ 216953018216SPaolo Bonzini spapr->vio_bus = spapr_vio_bus_init(); 217053018216SPaolo Bonzini 217153018216SPaolo Bonzini for (i = 0; i < MAX_SERIAL_PORTS; i++) { 217253018216SPaolo Bonzini if (serial_hds[i]) { 217353018216SPaolo Bonzini spapr_vty_create(spapr->vio_bus, serial_hds[i]); 217453018216SPaolo Bonzini } 217553018216SPaolo Bonzini } 217653018216SPaolo Bonzini 217753018216SPaolo Bonzini /* We always have at least the nvram device on VIO */ 217853018216SPaolo Bonzini spapr_create_nvram(spapr); 217953018216SPaolo Bonzini 218053018216SPaolo Bonzini /* Set up PCI */ 218153018216SPaolo Bonzini spapr_pci_rtas_init(); 218253018216SPaolo Bonzini 218389dfd6e1SDavid Gibson phb = spapr_create_phb(spapr, 0); 218453018216SPaolo Bonzini 218553018216SPaolo Bonzini for (i = 0; i < nb_nics; i++) { 218653018216SPaolo Bonzini NICInfo *nd = &nd_table[i]; 218753018216SPaolo Bonzini 218853018216SPaolo Bonzini if (!nd->model) { 218953018216SPaolo Bonzini nd->model = g_strdup("ibmveth"); 219053018216SPaolo Bonzini } 219153018216SPaolo Bonzini 219253018216SPaolo Bonzini if (strcmp(nd->model, "ibmveth") == 0) { 219353018216SPaolo Bonzini spapr_vlan_create(spapr->vio_bus, nd); 219453018216SPaolo Bonzini } else { 219529b358f9SDavid Gibson pci_nic_init_nofail(&nd_table[i], phb->bus, nd->model, NULL); 219653018216SPaolo Bonzini } 219753018216SPaolo Bonzini } 219853018216SPaolo Bonzini 219953018216SPaolo Bonzini for (i = 0; i <= drive_get_max_bus(IF_SCSI); i++) { 220053018216SPaolo Bonzini spapr_vscsi_create(spapr->vio_bus); 220153018216SPaolo Bonzini } 220253018216SPaolo Bonzini 220353018216SPaolo Bonzini /* Graphics */ 220414c6a894SDavid Gibson if (spapr_vga_init(phb->bus, &error_fatal)) { 220553018216SPaolo Bonzini spapr->has_graphics = true; 2206c6e76503SPaolo Bonzini machine->usb |= defaults_enabled() && !machine->usb_disabled; 220753018216SPaolo Bonzini } 220853018216SPaolo Bonzini 22094ee9ced9SMarcel Apfelbaum if (machine->usb) { 221057040d45SThomas Huth if (smc->use_ohci_by_default) { 221153018216SPaolo Bonzini pci_create_simple(phb->bus, -1, "pci-ohci"); 221257040d45SThomas Huth } else { 221357040d45SThomas Huth pci_create_simple(phb->bus, -1, "nec-usb-xhci"); 221457040d45SThomas Huth } 2215c86580b8SMarkus Armbruster 221653018216SPaolo Bonzini if (spapr->has_graphics) { 2217c86580b8SMarkus Armbruster USBBus *usb_bus = usb_bus_find(-1); 2218c86580b8SMarkus Armbruster 2219c86580b8SMarkus Armbruster usb_create_simple(usb_bus, "usb-kbd"); 2220c86580b8SMarkus Armbruster usb_create_simple(usb_bus, "usb-mouse"); 222153018216SPaolo Bonzini } 222253018216SPaolo Bonzini } 222353018216SPaolo Bonzini 222453018216SPaolo Bonzini if (spapr->rma_size < (MIN_RMA_SLOF << 20)) { 2225d54e4d76SDavid Gibson error_report( 2226d54e4d76SDavid Gibson "pSeries SLOF firmware requires >= %ldM guest RMA (Real Mode Area memory)", 2227d54e4d76SDavid Gibson MIN_RMA_SLOF); 222853018216SPaolo Bonzini exit(1); 222953018216SPaolo Bonzini } 223053018216SPaolo Bonzini 223153018216SPaolo Bonzini if (kernel_filename) { 223253018216SPaolo Bonzini uint64_t lowaddr = 0; 223353018216SPaolo Bonzini 2234a19f7fb0SDavid Gibson spapr->kernel_size = load_elf(kernel_filename, translate_kernel_address, 2235a19f7fb0SDavid Gibson NULL, NULL, &lowaddr, NULL, 1, 2236a19f7fb0SDavid Gibson PPC_ELF_MACHINE, 0, 0); 2237a19f7fb0SDavid Gibson if (spapr->kernel_size == ELF_LOAD_WRONG_ENDIAN) { 2238a19f7fb0SDavid Gibson spapr->kernel_size = load_elf(kernel_filename, 2239a19f7fb0SDavid Gibson translate_kernel_address, NULL, NULL, 2240a19f7fb0SDavid Gibson &lowaddr, NULL, 0, PPC_ELF_MACHINE, 22417ef295eaSPeter Crosthwaite 0, 0); 2242a19f7fb0SDavid Gibson spapr->kernel_le = spapr->kernel_size > 0; 224316457e7fSBenjamin Herrenschmidt } 2244a19f7fb0SDavid Gibson if (spapr->kernel_size < 0) { 2245a19f7fb0SDavid Gibson error_report("error loading %s: %s", kernel_filename, 2246a19f7fb0SDavid Gibson load_elf_strerror(spapr->kernel_size)); 224753018216SPaolo Bonzini exit(1); 224853018216SPaolo Bonzini } 224953018216SPaolo Bonzini 225053018216SPaolo Bonzini /* load initrd */ 225153018216SPaolo Bonzini if (initrd_filename) { 225253018216SPaolo Bonzini /* Try to locate the initrd in the gap between the kernel 225353018216SPaolo Bonzini * and the firmware. Add a bit of space just in case 225453018216SPaolo Bonzini */ 2255a19f7fb0SDavid Gibson spapr->initrd_base = (KERNEL_LOAD_ADDR + spapr->kernel_size 2256a19f7fb0SDavid Gibson + 0x1ffff) & ~0xffff; 2257a19f7fb0SDavid Gibson spapr->initrd_size = load_image_targphys(initrd_filename, 2258a19f7fb0SDavid Gibson spapr->initrd_base, 2259a19f7fb0SDavid Gibson load_limit 2260a19f7fb0SDavid Gibson - spapr->initrd_base); 2261a19f7fb0SDavid Gibson if (spapr->initrd_size < 0) { 2262d54e4d76SDavid Gibson error_report("could not load initial ram disk '%s'", 226353018216SPaolo Bonzini initrd_filename); 226453018216SPaolo Bonzini exit(1); 226553018216SPaolo Bonzini } 226653018216SPaolo Bonzini } 226753018216SPaolo Bonzini } 226853018216SPaolo Bonzini 22698e7ea787SAndreas Färber if (bios_name == NULL) { 22708e7ea787SAndreas Färber bios_name = FW_FILE_NAME; 22718e7ea787SAndreas Färber } 22728e7ea787SAndreas Färber filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name); 22734c56440dSStefan Weil if (!filename) { 227468fea5a0SThomas Huth error_report("Could not find LPAR firmware '%s'", bios_name); 22754c56440dSStefan Weil exit(1); 22764c56440dSStefan Weil } 227753018216SPaolo Bonzini fw_size = load_image_targphys(filename, 0, FW_MAX_SIZE); 227868fea5a0SThomas Huth if (fw_size <= 0) { 227968fea5a0SThomas Huth error_report("Could not load LPAR firmware '%s'", filename); 228053018216SPaolo Bonzini exit(1); 228153018216SPaolo Bonzini } 228253018216SPaolo Bonzini g_free(filename); 228353018216SPaolo Bonzini 228428e02042SDavid Gibson /* FIXME: Should register things through the MachineState's qdev 228528e02042SDavid Gibson * interface, this is a legacy from the sPAPREnvironment structure 228628e02042SDavid Gibson * which predated MachineState but had a similar function */ 22874be21d56SDavid Gibson vmstate_register(NULL, 0, &vmstate_spapr, spapr); 22884be21d56SDavid Gibson register_savevm_live(NULL, "spapr/htab", -1, 1, 22894be21d56SDavid Gibson &savevm_htab_handlers, spapr); 22904be21d56SDavid Gibson 229146503c2bSMichael Roth /* used by RTAS */ 229246503c2bSMichael Roth QTAILQ_INIT(&spapr->ccs_list); 229346503c2bSMichael Roth qemu_register_reset(spapr_ccs_reset_hook, spapr); 229446503c2bSMichael Roth 22955b2128d2SAlexander Graf qemu_register_boot_set(spapr_boot_set, spapr); 229642043e4fSLaurent Vivier 229742043e4fSLaurent Vivier /* to stop and start vmclock */ 229842043e4fSLaurent Vivier if (kvm_enabled()) { 229942043e4fSLaurent Vivier qemu_add_vm_change_state_handler(cpu_ppc_clock_vm_state_change, 230042043e4fSLaurent Vivier &spapr->tb); 230142043e4fSLaurent Vivier } 230253018216SPaolo Bonzini } 230353018216SPaolo Bonzini 2304135a129aSAneesh Kumar K.V static int spapr_kvm_type(const char *vm_type) 2305135a129aSAneesh Kumar K.V { 2306135a129aSAneesh Kumar K.V if (!vm_type) { 2307135a129aSAneesh Kumar K.V return 0; 2308135a129aSAneesh Kumar K.V } 2309135a129aSAneesh Kumar K.V 2310135a129aSAneesh Kumar K.V if (!strcmp(vm_type, "HV")) { 2311135a129aSAneesh Kumar K.V return 1; 2312135a129aSAneesh Kumar K.V } 2313135a129aSAneesh Kumar K.V 2314135a129aSAneesh Kumar K.V if (!strcmp(vm_type, "PR")) { 2315135a129aSAneesh Kumar K.V return 2; 2316135a129aSAneesh Kumar K.V } 2317135a129aSAneesh Kumar K.V 2318135a129aSAneesh Kumar K.V error_report("Unknown kvm-type specified '%s'", vm_type); 2319135a129aSAneesh Kumar K.V exit(1); 2320135a129aSAneesh Kumar K.V } 2321135a129aSAneesh Kumar K.V 232271461b0fSAlexey Kardashevskiy /* 2323627b84f4SGonglei * Implementation of an interface to adjust firmware path 232471461b0fSAlexey Kardashevskiy * for the bootindex property handling. 232571461b0fSAlexey Kardashevskiy */ 232671461b0fSAlexey Kardashevskiy static char *spapr_get_fw_dev_path(FWPathProvider *p, BusState *bus, 232771461b0fSAlexey Kardashevskiy DeviceState *dev) 232871461b0fSAlexey Kardashevskiy { 232971461b0fSAlexey Kardashevskiy #define CAST(type, obj, name) \ 233071461b0fSAlexey Kardashevskiy ((type *)object_dynamic_cast(OBJECT(obj), (name))) 233171461b0fSAlexey Kardashevskiy SCSIDevice *d = CAST(SCSIDevice, dev, TYPE_SCSI_DEVICE); 233271461b0fSAlexey Kardashevskiy sPAPRPHBState *phb = CAST(sPAPRPHBState, dev, TYPE_SPAPR_PCI_HOST_BRIDGE); 233371461b0fSAlexey Kardashevskiy 233471461b0fSAlexey Kardashevskiy if (d) { 233571461b0fSAlexey Kardashevskiy void *spapr = CAST(void, bus->parent, "spapr-vscsi"); 233671461b0fSAlexey Kardashevskiy VirtIOSCSI *virtio = CAST(VirtIOSCSI, bus->parent, TYPE_VIRTIO_SCSI); 233771461b0fSAlexey Kardashevskiy USBDevice *usb = CAST(USBDevice, bus->parent, TYPE_USB_DEVICE); 233871461b0fSAlexey Kardashevskiy 233971461b0fSAlexey Kardashevskiy if (spapr) { 234071461b0fSAlexey Kardashevskiy /* 234171461b0fSAlexey Kardashevskiy * Replace "channel@0/disk@0,0" with "disk@8000000000000000": 234271461b0fSAlexey Kardashevskiy * We use SRP luns of the form 8000 | (bus << 8) | (id << 5) | lun 234371461b0fSAlexey Kardashevskiy * in the top 16 bits of the 64-bit LUN 234471461b0fSAlexey Kardashevskiy */ 234571461b0fSAlexey Kardashevskiy unsigned id = 0x8000 | (d->id << 8) | d->lun; 234671461b0fSAlexey Kardashevskiy return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev), 234771461b0fSAlexey Kardashevskiy (uint64_t)id << 48); 234871461b0fSAlexey Kardashevskiy } else if (virtio) { 234971461b0fSAlexey Kardashevskiy /* 235071461b0fSAlexey Kardashevskiy * We use SRP luns of the form 01000000 | (target << 8) | lun 235171461b0fSAlexey Kardashevskiy * in the top 32 bits of the 64-bit LUN 235271461b0fSAlexey Kardashevskiy * Note: the quote above is from SLOF and it is wrong, 235371461b0fSAlexey Kardashevskiy * the actual binding is: 235471461b0fSAlexey Kardashevskiy * swap 0100 or 10 << or 20 << ( target lun-id -- srplun ) 235571461b0fSAlexey Kardashevskiy */ 235671461b0fSAlexey Kardashevskiy unsigned id = 0x1000000 | (d->id << 16) | d->lun; 235771461b0fSAlexey Kardashevskiy return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev), 235871461b0fSAlexey Kardashevskiy (uint64_t)id << 32); 235971461b0fSAlexey Kardashevskiy } else if (usb) { 236071461b0fSAlexey Kardashevskiy /* 236171461b0fSAlexey Kardashevskiy * We use SRP luns of the form 01000000 | (usb-port << 16) | lun 236271461b0fSAlexey Kardashevskiy * in the top 32 bits of the 64-bit LUN 236371461b0fSAlexey Kardashevskiy */ 236471461b0fSAlexey Kardashevskiy unsigned usb_port = atoi(usb->port->path); 236571461b0fSAlexey Kardashevskiy unsigned id = 0x1000000 | (usb_port << 16) | d->lun; 236671461b0fSAlexey Kardashevskiy return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev), 236771461b0fSAlexey Kardashevskiy (uint64_t)id << 32); 236871461b0fSAlexey Kardashevskiy } 236971461b0fSAlexey Kardashevskiy } 237071461b0fSAlexey Kardashevskiy 2371b99260ebSThomas Huth /* 2372b99260ebSThomas Huth * SLOF probes the USB devices, and if it recognizes that the device is a 2373b99260ebSThomas Huth * storage device, it changes its name to "storage" instead of "usb-host", 2374b99260ebSThomas Huth * and additionally adds a child node for the SCSI LUN, so the correct 2375b99260ebSThomas Huth * boot path in SLOF is something like .../storage@1/disk@xxx" instead. 2376b99260ebSThomas Huth */ 2377b99260ebSThomas Huth if (strcmp("usb-host", qdev_fw_name(dev)) == 0) { 2378b99260ebSThomas Huth USBDevice *usbdev = CAST(USBDevice, dev, TYPE_USB_DEVICE); 2379b99260ebSThomas Huth if (usb_host_dev_is_scsi_storage(usbdev)) { 2380b99260ebSThomas Huth return g_strdup_printf("storage@%s/disk", usbdev->port->path); 2381b99260ebSThomas Huth } 2382b99260ebSThomas Huth } 2383b99260ebSThomas Huth 238471461b0fSAlexey Kardashevskiy if (phb) { 238571461b0fSAlexey Kardashevskiy /* Replace "pci" with "pci@800000020000000" */ 238671461b0fSAlexey Kardashevskiy return g_strdup_printf("pci@%"PRIX64, phb->buid); 238771461b0fSAlexey Kardashevskiy } 238871461b0fSAlexey Kardashevskiy 238971461b0fSAlexey Kardashevskiy return NULL; 239071461b0fSAlexey Kardashevskiy } 239171461b0fSAlexey Kardashevskiy 239223825581SEduardo Habkost static char *spapr_get_kvm_type(Object *obj, Error **errp) 239323825581SEduardo Habkost { 239428e02042SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 239523825581SEduardo Habkost 239628e02042SDavid Gibson return g_strdup(spapr->kvm_type); 239723825581SEduardo Habkost } 239823825581SEduardo Habkost 239923825581SEduardo Habkost static void spapr_set_kvm_type(Object *obj, const char *value, Error **errp) 240023825581SEduardo Habkost { 240128e02042SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 240223825581SEduardo Habkost 240328e02042SDavid Gibson g_free(spapr->kvm_type); 240428e02042SDavid Gibson spapr->kvm_type = g_strdup(value); 240523825581SEduardo Habkost } 240623825581SEduardo Habkost 2407f6229214SMichael Roth static bool spapr_get_modern_hotplug_events(Object *obj, Error **errp) 2408f6229214SMichael Roth { 2409f6229214SMichael Roth sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 2410f6229214SMichael Roth 2411f6229214SMichael Roth return spapr->use_hotplug_event_source; 2412f6229214SMichael Roth } 2413f6229214SMichael Roth 2414f6229214SMichael Roth static void spapr_set_modern_hotplug_events(Object *obj, bool value, 2415f6229214SMichael Roth Error **errp) 2416f6229214SMichael Roth { 2417f6229214SMichael Roth sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 2418f6229214SMichael Roth 2419f6229214SMichael Roth spapr->use_hotplug_event_source = value; 2420f6229214SMichael Roth } 2421f6229214SMichael Roth 242223825581SEduardo Habkost static void spapr_machine_initfn(Object *obj) 242323825581SEduardo Habkost { 2424715c5407SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 2425715c5407SDavid Gibson 2426715c5407SDavid Gibson spapr->htab_fd = -1; 2427f6229214SMichael Roth spapr->use_hotplug_event_source = true; 242823825581SEduardo Habkost object_property_add_str(obj, "kvm-type", 242923825581SEduardo Habkost spapr_get_kvm_type, spapr_set_kvm_type, NULL); 243049d2e648SMarcel Apfelbaum object_property_set_description(obj, "kvm-type", 243149d2e648SMarcel Apfelbaum "Specifies the KVM virtualization mode (HV, PR)", 243249d2e648SMarcel Apfelbaum NULL); 2433f6229214SMichael Roth object_property_add_bool(obj, "modern-hotplug-events", 2434f6229214SMichael Roth spapr_get_modern_hotplug_events, 2435f6229214SMichael Roth spapr_set_modern_hotplug_events, 2436f6229214SMichael Roth NULL); 2437f6229214SMichael Roth object_property_set_description(obj, "modern-hotplug-events", 2438f6229214SMichael Roth "Use dedicated hotplug event mechanism in" 2439f6229214SMichael Roth " place of standard EPOW events when possible" 2440f6229214SMichael Roth " (required for memory hot-unplug support)", 2441f6229214SMichael Roth NULL); 244223825581SEduardo Habkost } 244323825581SEduardo Habkost 244487bbdd9cSDavid Gibson static void spapr_machine_finalizefn(Object *obj) 244587bbdd9cSDavid Gibson { 244687bbdd9cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 244787bbdd9cSDavid Gibson 244887bbdd9cSDavid Gibson g_free(spapr->kvm_type); 244987bbdd9cSDavid Gibson } 245087bbdd9cSDavid Gibson 24511c7ad77eSNicholas Piggin void spapr_do_system_reset_on_cpu(CPUState *cs, run_on_cpu_data arg) 245234316482SAlexey Kardashevskiy { 245334316482SAlexey Kardashevskiy cpu_synchronize_state(cs); 245434316482SAlexey Kardashevskiy ppc_cpu_do_system_reset(cs); 245534316482SAlexey Kardashevskiy } 245634316482SAlexey Kardashevskiy 245734316482SAlexey Kardashevskiy static void spapr_nmi(NMIState *n, int cpu_index, Error **errp) 245834316482SAlexey Kardashevskiy { 245934316482SAlexey Kardashevskiy CPUState *cs; 246034316482SAlexey Kardashevskiy 246134316482SAlexey Kardashevskiy CPU_FOREACH(cs) { 24621c7ad77eSNicholas Piggin async_run_on_cpu(cs, spapr_do_system_reset_on_cpu, RUN_ON_CPU_NULL); 246334316482SAlexey Kardashevskiy } 246434316482SAlexey Kardashevskiy } 246534316482SAlexey Kardashevskiy 246679b78a6bSMichael Roth static void spapr_add_lmbs(DeviceState *dev, uint64_t addr_start, uint64_t size, 246779b78a6bSMichael Roth uint32_t node, bool dedicated_hp_event_source, 246879b78a6bSMichael Roth Error **errp) 2469c20d332aSBharata B Rao { 2470c20d332aSBharata B Rao sPAPRDRConnector *drc; 2471c20d332aSBharata B Rao sPAPRDRConnectorClass *drck; 2472c20d332aSBharata B Rao uint32_t nr_lmbs = size/SPAPR_MEMORY_BLOCK_SIZE; 2473c20d332aSBharata B Rao int i, fdt_offset, fdt_size; 2474c20d332aSBharata B Rao void *fdt; 247579b78a6bSMichael Roth uint64_t addr = addr_start; 2476c20d332aSBharata B Rao 2477c20d332aSBharata B Rao for (i = 0; i < nr_lmbs; i++) { 2478c20d332aSBharata B Rao drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_LMB, 2479c20d332aSBharata B Rao addr/SPAPR_MEMORY_BLOCK_SIZE); 2480c20d332aSBharata B Rao g_assert(drc); 2481c20d332aSBharata B Rao 2482c20d332aSBharata B Rao fdt = create_device_tree(&fdt_size); 2483c20d332aSBharata B Rao fdt_offset = spapr_populate_memory_node(fdt, node, addr, 2484c20d332aSBharata B Rao SPAPR_MEMORY_BLOCK_SIZE); 2485c20d332aSBharata B Rao 2486c20d332aSBharata B Rao drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 2487c20d332aSBharata B Rao drck->attach(drc, dev, fdt, fdt_offset, !dev->hotplugged, errp); 2488c20d332aSBharata B Rao addr += SPAPR_MEMORY_BLOCK_SIZE; 24895c0139a8SMichael Roth if (!dev->hotplugged) { 24905c0139a8SMichael Roth /* guests expect coldplugged LMBs to be pre-allocated */ 24915c0139a8SMichael Roth drck->set_allocation_state(drc, SPAPR_DR_ALLOCATION_STATE_USABLE); 24925c0139a8SMichael Roth drck->set_isolation_state(drc, SPAPR_DR_ISOLATION_STATE_UNISOLATED); 24935c0139a8SMichael Roth } 2494c20d332aSBharata B Rao } 24955dd5238cSJianjun Duan /* send hotplug notification to the 24965dd5238cSJianjun Duan * guest only in case of hotplugged memory 24975dd5238cSJianjun Duan */ 24985dd5238cSJianjun Duan if (dev->hotplugged) { 249979b78a6bSMichael Roth if (dedicated_hp_event_source) { 250079b78a6bSMichael Roth drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_LMB, 250179b78a6bSMichael Roth addr_start / SPAPR_MEMORY_BLOCK_SIZE); 250279b78a6bSMichael Roth drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 250379b78a6bSMichael Roth spapr_hotplug_req_add_by_count_indexed(SPAPR_DR_CONNECTOR_TYPE_LMB, 250479b78a6bSMichael Roth nr_lmbs, 250579b78a6bSMichael Roth drck->get_index(drc)); 250679b78a6bSMichael Roth } else { 250779b78a6bSMichael Roth spapr_hotplug_req_add_by_count(SPAPR_DR_CONNECTOR_TYPE_LMB, 250879b78a6bSMichael Roth nr_lmbs); 250979b78a6bSMichael Roth } 2510c20d332aSBharata B Rao } 25115dd5238cSJianjun Duan } 2512c20d332aSBharata B Rao 2513c20d332aSBharata B Rao static void spapr_memory_plug(HotplugHandler *hotplug_dev, DeviceState *dev, 2514c20d332aSBharata B Rao uint32_t node, Error **errp) 2515c20d332aSBharata B Rao { 2516c20d332aSBharata B Rao Error *local_err = NULL; 2517c20d332aSBharata B Rao sPAPRMachineState *ms = SPAPR_MACHINE(hotplug_dev); 2518c20d332aSBharata B Rao PCDIMMDevice *dimm = PC_DIMM(dev); 2519c20d332aSBharata B Rao PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); 2520c20d332aSBharata B Rao MemoryRegion *mr = ddc->get_memory_region(dimm); 2521c20d332aSBharata B Rao uint64_t align = memory_region_get_alignment(mr); 2522c20d332aSBharata B Rao uint64_t size = memory_region_size(mr); 2523c20d332aSBharata B Rao uint64_t addr; 2524df587133SThomas Huth char *mem_dev; 2525c20d332aSBharata B Rao 2526c20d332aSBharata B Rao if (size % SPAPR_MEMORY_BLOCK_SIZE) { 2527c20d332aSBharata B Rao error_setg(&local_err, "Hotplugged memory size must be a multiple of " 2528c20d332aSBharata B Rao "%lld MB", SPAPR_MEMORY_BLOCK_SIZE/M_BYTE); 2529c20d332aSBharata B Rao goto out; 2530c20d332aSBharata B Rao } 2531c20d332aSBharata B Rao 2532df587133SThomas Huth mem_dev = object_property_get_str(OBJECT(dimm), PC_DIMM_MEMDEV_PROP, NULL); 2533df587133SThomas Huth if (mem_dev && !kvmppc_is_mem_backend_page_size_ok(mem_dev)) { 2534df587133SThomas Huth error_setg(&local_err, "Memory backend has bad page size. " 2535df587133SThomas Huth "Use 'memory-backend-file' with correct mem-path."); 2536df587133SThomas Huth goto out; 2537df587133SThomas Huth } 2538df587133SThomas Huth 2539d6a9b0b8SMichael S. Tsirkin pc_dimm_memory_plug(dev, &ms->hotplug_memory, mr, align, &local_err); 2540c20d332aSBharata B Rao if (local_err) { 2541c20d332aSBharata B Rao goto out; 2542c20d332aSBharata B Rao } 2543c20d332aSBharata B Rao 2544c20d332aSBharata B Rao addr = object_property_get_int(OBJECT(dimm), PC_DIMM_ADDR_PROP, &local_err); 2545c20d332aSBharata B Rao if (local_err) { 2546c20d332aSBharata B Rao pc_dimm_memory_unplug(dev, &ms->hotplug_memory, mr); 2547c20d332aSBharata B Rao goto out; 2548c20d332aSBharata B Rao } 2549c20d332aSBharata B Rao 255079b78a6bSMichael Roth spapr_add_lmbs(dev, addr, size, node, 255179b78a6bSMichael Roth spapr_ovec_test(ms->ov5_cas, OV5_HP_EVT), 255279b78a6bSMichael Roth &error_abort); 2553c20d332aSBharata B Rao 2554c20d332aSBharata B Rao out: 2555c20d332aSBharata B Rao error_propagate(errp, local_err); 2556c20d332aSBharata B Rao } 2557c20d332aSBharata B Rao 2558cf632463SBharata B Rao typedef struct sPAPRDIMMState { 2559cf632463SBharata B Rao uint32_t nr_lmbs; 2560cf632463SBharata B Rao } sPAPRDIMMState; 2561cf632463SBharata B Rao 2562cf632463SBharata B Rao static void spapr_lmb_release(DeviceState *dev, void *opaque) 2563cf632463SBharata B Rao { 2564cf632463SBharata B Rao sPAPRDIMMState *ds = (sPAPRDIMMState *)opaque; 2565cf632463SBharata B Rao HotplugHandler *hotplug_ctrl; 2566cf632463SBharata B Rao 2567cf632463SBharata B Rao if (--ds->nr_lmbs) { 2568cf632463SBharata B Rao return; 2569cf632463SBharata B Rao } 2570cf632463SBharata B Rao 2571cf632463SBharata B Rao g_free(ds); 2572cf632463SBharata B Rao 2573cf632463SBharata B Rao /* 2574cf632463SBharata B Rao * Now that all the LMBs have been removed by the guest, call the 2575cf632463SBharata B Rao * pc-dimm unplug handler to cleanup up the pc-dimm device. 2576cf632463SBharata B Rao */ 2577cf632463SBharata B Rao hotplug_ctrl = qdev_get_hotplug_handler(dev); 2578cf632463SBharata B Rao hotplug_handler_unplug(hotplug_ctrl, dev, &error_abort); 2579cf632463SBharata B Rao } 2580cf632463SBharata B Rao 2581cf632463SBharata B Rao static void spapr_del_lmbs(DeviceState *dev, uint64_t addr_start, uint64_t size, 2582cf632463SBharata B Rao Error **errp) 2583cf632463SBharata B Rao { 2584cf632463SBharata B Rao sPAPRDRConnector *drc; 2585cf632463SBharata B Rao sPAPRDRConnectorClass *drck; 2586cf632463SBharata B Rao uint32_t nr_lmbs = size / SPAPR_MEMORY_BLOCK_SIZE; 2587cf632463SBharata B Rao int i; 2588cf632463SBharata B Rao sPAPRDIMMState *ds = g_malloc0(sizeof(sPAPRDIMMState)); 2589cf632463SBharata B Rao uint64_t addr = addr_start; 2590cf632463SBharata B Rao 2591cf632463SBharata B Rao ds->nr_lmbs = nr_lmbs; 2592cf632463SBharata B Rao for (i = 0; i < nr_lmbs; i++) { 2593cf632463SBharata B Rao drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_LMB, 2594cf632463SBharata B Rao addr / SPAPR_MEMORY_BLOCK_SIZE); 2595cf632463SBharata B Rao g_assert(drc); 2596cf632463SBharata B Rao 2597cf632463SBharata B Rao drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 2598cf632463SBharata B Rao drck->detach(drc, dev, spapr_lmb_release, ds, errp); 2599cf632463SBharata B Rao addr += SPAPR_MEMORY_BLOCK_SIZE; 2600cf632463SBharata B Rao } 2601cf632463SBharata B Rao 2602cf632463SBharata B Rao drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_LMB, 2603cf632463SBharata B Rao addr_start / SPAPR_MEMORY_BLOCK_SIZE); 2604cf632463SBharata B Rao drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 2605cf632463SBharata B Rao spapr_hotplug_req_remove_by_count_indexed(SPAPR_DR_CONNECTOR_TYPE_LMB, 2606cf632463SBharata B Rao nr_lmbs, 2607cf632463SBharata B Rao drck->get_index(drc)); 2608cf632463SBharata B Rao } 2609cf632463SBharata B Rao 2610cf632463SBharata B Rao static void spapr_memory_unplug(HotplugHandler *hotplug_dev, DeviceState *dev, 2611cf632463SBharata B Rao Error **errp) 2612cf632463SBharata B Rao { 2613cf632463SBharata B Rao sPAPRMachineState *ms = SPAPR_MACHINE(hotplug_dev); 2614cf632463SBharata B Rao PCDIMMDevice *dimm = PC_DIMM(dev); 2615cf632463SBharata B Rao PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); 2616cf632463SBharata B Rao MemoryRegion *mr = ddc->get_memory_region(dimm); 2617cf632463SBharata B Rao 2618cf632463SBharata B Rao pc_dimm_memory_unplug(dev, &ms->hotplug_memory, mr); 2619cf632463SBharata B Rao object_unparent(OBJECT(dev)); 2620cf632463SBharata B Rao } 2621cf632463SBharata B Rao 2622cf632463SBharata B Rao static void spapr_memory_unplug_request(HotplugHandler *hotplug_dev, 2623cf632463SBharata B Rao DeviceState *dev, Error **errp) 2624cf632463SBharata B Rao { 2625cf632463SBharata B Rao Error *local_err = NULL; 2626cf632463SBharata B Rao PCDIMMDevice *dimm = PC_DIMM(dev); 2627cf632463SBharata B Rao PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); 2628cf632463SBharata B Rao MemoryRegion *mr = ddc->get_memory_region(dimm); 2629cf632463SBharata B Rao uint64_t size = memory_region_size(mr); 2630cf632463SBharata B Rao uint64_t addr; 2631cf632463SBharata B Rao 2632cf632463SBharata B Rao addr = object_property_get_int(OBJECT(dimm), PC_DIMM_ADDR_PROP, &local_err); 2633cf632463SBharata B Rao if (local_err) { 2634cf632463SBharata B Rao goto out; 2635cf632463SBharata B Rao } 2636cf632463SBharata B Rao 2637cf632463SBharata B Rao spapr_del_lmbs(dev, addr, size, &error_abort); 2638cf632463SBharata B Rao out: 2639cf632463SBharata B Rao error_propagate(errp, local_err); 2640cf632463SBharata B Rao } 2641cf632463SBharata B Rao 2642af81cf32SBharata B Rao void *spapr_populate_hotplug_cpu_dt(CPUState *cs, int *fdt_offset, 2643af81cf32SBharata B Rao sPAPRMachineState *spapr) 2644af81cf32SBharata B Rao { 2645af81cf32SBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(cs); 2646af81cf32SBharata B Rao DeviceClass *dc = DEVICE_GET_CLASS(cs); 2647af81cf32SBharata B Rao int id = ppc_get_vcpu_dt_id(cpu); 2648af81cf32SBharata B Rao void *fdt; 2649af81cf32SBharata B Rao int offset, fdt_size; 2650af81cf32SBharata B Rao char *nodename; 2651af81cf32SBharata B Rao 2652af81cf32SBharata B Rao fdt = create_device_tree(&fdt_size); 2653af81cf32SBharata B Rao nodename = g_strdup_printf("%s@%x", dc->fw_name, id); 2654af81cf32SBharata B Rao offset = fdt_add_subnode(fdt, 0, nodename); 2655af81cf32SBharata B Rao 2656af81cf32SBharata B Rao spapr_populate_cpu_dt(cs, fdt, offset, spapr); 2657af81cf32SBharata B Rao g_free(nodename); 2658af81cf32SBharata B Rao 2659af81cf32SBharata B Rao *fdt_offset = offset; 2660af81cf32SBharata B Rao return fdt; 2661af81cf32SBharata B Rao } 2662af81cf32SBharata B Rao 2663115debf2SIgor Mammedov static void spapr_core_unplug(HotplugHandler *hotplug_dev, DeviceState *dev, 2664115debf2SIgor Mammedov Error **errp) 2665ff9006ddSIgor Mammedov { 2666535455fdSIgor Mammedov MachineState *ms = MACHINE(qdev_get_machine()); 2667ff9006ddSIgor Mammedov CPUCore *cc = CPU_CORE(dev); 2668535455fdSIgor Mammedov CPUArchId *core_slot = spapr_find_cpu_slot(ms, cc->core_id, NULL); 2669ff9006ddSIgor Mammedov 2670535455fdSIgor Mammedov core_slot->cpu = NULL; 2671ff9006ddSIgor Mammedov object_unparent(OBJECT(dev)); 2672ff9006ddSIgor Mammedov } 2673ff9006ddSIgor Mammedov 2674115debf2SIgor Mammedov static void spapr_core_release(DeviceState *dev, void *opaque) 2675115debf2SIgor Mammedov { 2676115debf2SIgor Mammedov HotplugHandler *hotplug_ctrl; 2677115debf2SIgor Mammedov 2678115debf2SIgor Mammedov hotplug_ctrl = qdev_get_hotplug_handler(dev); 2679115debf2SIgor Mammedov hotplug_handler_unplug(hotplug_ctrl, dev, &error_abort); 2680115debf2SIgor Mammedov } 2681115debf2SIgor Mammedov 2682115debf2SIgor Mammedov static 2683115debf2SIgor Mammedov void spapr_core_unplug_request(HotplugHandler *hotplug_dev, DeviceState *dev, 2684ff9006ddSIgor Mammedov Error **errp) 2685ff9006ddSIgor Mammedov { 2686535455fdSIgor Mammedov int index; 2687535455fdSIgor Mammedov sPAPRDRConnector *drc; 2688ff9006ddSIgor Mammedov sPAPRDRConnectorClass *drck; 2689ff9006ddSIgor Mammedov Error *local_err = NULL; 2690535455fdSIgor Mammedov CPUCore *cc = CPU_CORE(dev); 2691535455fdSIgor Mammedov int smt = kvmppc_smt_threads(); 2692ff9006ddSIgor Mammedov 2693535455fdSIgor Mammedov if (!spapr_find_cpu_slot(MACHINE(hotplug_dev), cc->core_id, &index)) { 2694535455fdSIgor Mammedov error_setg(errp, "Unable to find CPU core with core-id: %d", 2695535455fdSIgor Mammedov cc->core_id); 2696535455fdSIgor Mammedov return; 2697535455fdSIgor Mammedov } 2698ff9006ddSIgor Mammedov if (index == 0) { 2699ff9006ddSIgor Mammedov error_setg(errp, "Boot CPU core may not be unplugged"); 2700ff9006ddSIgor Mammedov return; 2701ff9006ddSIgor Mammedov } 2702ff9006ddSIgor Mammedov 2703535455fdSIgor Mammedov drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_CPU, index * smt); 2704ff9006ddSIgor Mammedov g_assert(drc); 2705ff9006ddSIgor Mammedov 2706ff9006ddSIgor Mammedov drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 2707ff9006ddSIgor Mammedov drck->detach(drc, dev, spapr_core_release, NULL, &local_err); 2708ff9006ddSIgor Mammedov if (local_err) { 2709ff9006ddSIgor Mammedov error_propagate(errp, local_err); 2710ff9006ddSIgor Mammedov return; 2711ff9006ddSIgor Mammedov } 2712ff9006ddSIgor Mammedov 2713ff9006ddSIgor Mammedov spapr_hotplug_req_remove_by_index(drc); 2714ff9006ddSIgor Mammedov } 2715ff9006ddSIgor Mammedov 2716ff9006ddSIgor Mammedov static void spapr_core_plug(HotplugHandler *hotplug_dev, DeviceState *dev, 2717ff9006ddSIgor Mammedov Error **errp) 2718ff9006ddSIgor Mammedov { 2719ff9006ddSIgor Mammedov sPAPRMachineState *spapr = SPAPR_MACHINE(OBJECT(hotplug_dev)); 2720ff9006ddSIgor Mammedov MachineClass *mc = MACHINE_GET_CLASS(spapr); 2721ff9006ddSIgor Mammedov sPAPRCPUCore *core = SPAPR_CPU_CORE(OBJECT(dev)); 2722ff9006ddSIgor Mammedov CPUCore *cc = CPU_CORE(dev); 2723ff9006ddSIgor Mammedov CPUState *cs = CPU(core->threads); 2724ff9006ddSIgor Mammedov sPAPRDRConnector *drc; 2725ff9006ddSIgor Mammedov Error *local_err = NULL; 2726ff9006ddSIgor Mammedov void *fdt = NULL; 2727ff9006ddSIgor Mammedov int fdt_offset = 0; 2728ff9006ddSIgor Mammedov int smt = kvmppc_smt_threads(); 2729535455fdSIgor Mammedov CPUArchId *core_slot; 2730535455fdSIgor Mammedov int index; 2731ff9006ddSIgor Mammedov 2732535455fdSIgor Mammedov core_slot = spapr_find_cpu_slot(MACHINE(hotplug_dev), cc->core_id, &index); 2733535455fdSIgor Mammedov if (!core_slot) { 2734535455fdSIgor Mammedov error_setg(errp, "Unable to find CPU core with core-id: %d", 2735535455fdSIgor Mammedov cc->core_id); 2736535455fdSIgor Mammedov return; 2737535455fdSIgor Mammedov } 2738ff9006ddSIgor Mammedov drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_CPU, index * smt); 2739ff9006ddSIgor Mammedov 2740c5514d0eSIgor Mammedov g_assert(drc || !mc->has_hotpluggable_cpus); 2741ff9006ddSIgor Mammedov 2742ff9006ddSIgor Mammedov /* 2743ff9006ddSIgor Mammedov * Setup CPU DT entries only for hotplugged CPUs. For boot time or 2744ff9006ddSIgor Mammedov * coldplugged CPUs DT entries are setup in spapr_build_fdt(). 2745ff9006ddSIgor Mammedov */ 2746ff9006ddSIgor Mammedov if (dev->hotplugged) { 2747ff9006ddSIgor Mammedov fdt = spapr_populate_hotplug_cpu_dt(cs, &fdt_offset, spapr); 2748ff9006ddSIgor Mammedov } 2749ff9006ddSIgor Mammedov 2750ff9006ddSIgor Mammedov if (drc) { 2751ff9006ddSIgor Mammedov sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 2752ff9006ddSIgor Mammedov drck->attach(drc, dev, fdt, fdt_offset, !dev->hotplugged, &local_err); 2753ff9006ddSIgor Mammedov if (local_err) { 2754ff9006ddSIgor Mammedov g_free(fdt); 2755ff9006ddSIgor Mammedov error_propagate(errp, local_err); 2756ff9006ddSIgor Mammedov return; 2757ff9006ddSIgor Mammedov } 2758ff9006ddSIgor Mammedov } 2759ff9006ddSIgor Mammedov 2760ff9006ddSIgor Mammedov if (dev->hotplugged) { 2761ff9006ddSIgor Mammedov /* 2762ff9006ddSIgor Mammedov * Send hotplug notification interrupt to the guest only in case 2763ff9006ddSIgor Mammedov * of hotplugged CPUs. 2764ff9006ddSIgor Mammedov */ 2765ff9006ddSIgor Mammedov spapr_hotplug_req_add_by_index(drc); 2766ff9006ddSIgor Mammedov } else { 2767ff9006ddSIgor Mammedov /* 2768ff9006ddSIgor Mammedov * Set the right DRC states for cold plugged CPU. 2769ff9006ddSIgor Mammedov */ 2770ff9006ddSIgor Mammedov if (drc) { 2771ff9006ddSIgor Mammedov sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 2772ff9006ddSIgor Mammedov drck->set_allocation_state(drc, SPAPR_DR_ALLOCATION_STATE_USABLE); 2773ff9006ddSIgor Mammedov drck->set_isolation_state(drc, SPAPR_DR_ISOLATION_STATE_UNISOLATED); 2774ff9006ddSIgor Mammedov } 2775ff9006ddSIgor Mammedov } 2776535455fdSIgor Mammedov core_slot->cpu = OBJECT(dev); 2777ff9006ddSIgor Mammedov } 2778ff9006ddSIgor Mammedov 2779ff9006ddSIgor Mammedov static void spapr_core_pre_plug(HotplugHandler *hotplug_dev, DeviceState *dev, 2780ff9006ddSIgor Mammedov Error **errp) 2781ff9006ddSIgor Mammedov { 2782ff9006ddSIgor Mammedov MachineState *machine = MACHINE(OBJECT(hotplug_dev)); 2783ff9006ddSIgor Mammedov MachineClass *mc = MACHINE_GET_CLASS(hotplug_dev); 2784ff9006ddSIgor Mammedov Error *local_err = NULL; 2785ff9006ddSIgor Mammedov CPUCore *cc = CPU_CORE(dev); 2786ff9006ddSIgor Mammedov char *base_core_type = spapr_get_cpu_core_type(machine->cpu_model); 2787ff9006ddSIgor Mammedov const char *type = object_get_typename(OBJECT(dev)); 2788535455fdSIgor Mammedov CPUArchId *core_slot; 2789535455fdSIgor Mammedov int index; 2790ff9006ddSIgor Mammedov 2791c5514d0eSIgor Mammedov if (dev->hotplugged && !mc->has_hotpluggable_cpus) { 2792ff9006ddSIgor Mammedov error_setg(&local_err, "CPU hotplug not supported for this machine"); 2793ff9006ddSIgor Mammedov goto out; 2794ff9006ddSIgor Mammedov } 2795ff9006ddSIgor Mammedov 2796ff9006ddSIgor Mammedov if (strcmp(base_core_type, type)) { 2797ff9006ddSIgor Mammedov error_setg(&local_err, "CPU core type should be %s", base_core_type); 2798ff9006ddSIgor Mammedov goto out; 2799ff9006ddSIgor Mammedov } 2800ff9006ddSIgor Mammedov 2801ff9006ddSIgor Mammedov if (cc->core_id % smp_threads) { 2802ff9006ddSIgor Mammedov error_setg(&local_err, "invalid core id %d", cc->core_id); 2803ff9006ddSIgor Mammedov goto out; 2804ff9006ddSIgor Mammedov } 2805ff9006ddSIgor Mammedov 28068149e299SDavid Gibson if (cc->nr_threads != smp_threads) { 28078149e299SDavid Gibson error_setg(errp, "invalid nr-threads %d, must be %d", 28088149e299SDavid Gibson cc->nr_threads, smp_threads); 28098149e299SDavid Gibson return; 28108149e299SDavid Gibson } 28118149e299SDavid Gibson 2812535455fdSIgor Mammedov core_slot = spapr_find_cpu_slot(MACHINE(hotplug_dev), cc->core_id, &index); 2813535455fdSIgor Mammedov if (!core_slot) { 2814ff9006ddSIgor Mammedov error_setg(&local_err, "core id %d out of range", cc->core_id); 2815ff9006ddSIgor Mammedov goto out; 2816ff9006ddSIgor Mammedov } 2817ff9006ddSIgor Mammedov 2818535455fdSIgor Mammedov if (core_slot->cpu) { 2819ff9006ddSIgor Mammedov error_setg(&local_err, "core %d already populated", cc->core_id); 2820ff9006ddSIgor Mammedov goto out; 2821ff9006ddSIgor Mammedov } 2822ff9006ddSIgor Mammedov 2823ff9006ddSIgor Mammedov out: 2824ff9006ddSIgor Mammedov g_free(base_core_type); 2825ff9006ddSIgor Mammedov error_propagate(errp, local_err); 2826ff9006ddSIgor Mammedov } 2827ff9006ddSIgor Mammedov 2828c20d332aSBharata B Rao static void spapr_machine_device_plug(HotplugHandler *hotplug_dev, 2829c20d332aSBharata B Rao DeviceState *dev, Error **errp) 2830c20d332aSBharata B Rao { 2831c20d332aSBharata B Rao sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(qdev_get_machine()); 2832c20d332aSBharata B Rao 2833c20d332aSBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { 2834b556854bSBharata B Rao int node; 2835c20d332aSBharata B Rao 2836c20d332aSBharata B Rao if (!smc->dr_lmb_enabled) { 2837c20d332aSBharata B Rao error_setg(errp, "Memory hotplug not supported for this machine"); 2838c20d332aSBharata B Rao return; 2839c20d332aSBharata B Rao } 2840c20d332aSBharata B Rao node = object_property_get_int(OBJECT(dev), PC_DIMM_NODE_PROP, errp); 2841c20d332aSBharata B Rao if (*errp) { 2842c20d332aSBharata B Rao return; 2843c20d332aSBharata B Rao } 28441a5512bbSGonglei if (node < 0 || node >= MAX_NODES) { 28451a5512bbSGonglei error_setg(errp, "Invaild node %d", node); 28461a5512bbSGonglei return; 28471a5512bbSGonglei } 2848c20d332aSBharata B Rao 2849b556854bSBharata B Rao /* 2850b556854bSBharata B Rao * Currently PowerPC kernel doesn't allow hot-adding memory to 2851b556854bSBharata B Rao * memory-less node, but instead will silently add the memory 2852b556854bSBharata B Rao * to the first node that has some memory. This causes two 2853b556854bSBharata B Rao * unexpected behaviours for the user. 2854b556854bSBharata B Rao * 2855b556854bSBharata B Rao * - Memory gets hotplugged to a different node than what the user 2856b556854bSBharata B Rao * specified. 2857b556854bSBharata B Rao * - Since pc-dimm subsystem in QEMU still thinks that memory belongs 2858b556854bSBharata B Rao * to memory-less node, a reboot will set things accordingly 2859b556854bSBharata B Rao * and the previously hotplugged memory now ends in the right node. 2860b556854bSBharata B Rao * This appears as if some memory moved from one node to another. 2861b556854bSBharata B Rao * 2862b556854bSBharata B Rao * So until kernel starts supporting memory hotplug to memory-less 2863b556854bSBharata B Rao * nodes, just prevent such attempts upfront in QEMU. 2864b556854bSBharata B Rao */ 2865b556854bSBharata B Rao if (nb_numa_nodes && !numa_info[node].node_mem) { 2866b556854bSBharata B Rao error_setg(errp, "Can't hotplug memory to memory-less node %d", 2867b556854bSBharata B Rao node); 2868b556854bSBharata B Rao return; 2869b556854bSBharata B Rao } 2870b556854bSBharata B Rao 2871c20d332aSBharata B Rao spapr_memory_plug(hotplug_dev, dev, node, errp); 2872af81cf32SBharata B Rao } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 2873af81cf32SBharata B Rao spapr_core_plug(hotplug_dev, dev, errp); 2874c20d332aSBharata B Rao } 2875c20d332aSBharata B Rao } 2876c20d332aSBharata B Rao 2877c20d332aSBharata B Rao static void spapr_machine_device_unplug(HotplugHandler *hotplug_dev, 2878c20d332aSBharata B Rao DeviceState *dev, Error **errp) 2879c20d332aSBharata B Rao { 2880cf632463SBharata B Rao sPAPRMachineState *sms = SPAPR_MACHINE(qdev_get_machine()); 28813c0c47e3SDavid Gibson MachineClass *mc = MACHINE_GET_CLASS(qdev_get_machine()); 28826f4b5c3eSBharata B Rao 2883c20d332aSBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { 2884cf632463SBharata B Rao if (spapr_ovec_test(sms->ov5_cas, OV5_HP_EVT)) { 2885cf632463SBharata B Rao spapr_memory_unplug(hotplug_dev, dev, errp); 2886cf632463SBharata B Rao } else { 2887cf632463SBharata B Rao error_setg(errp, "Memory hot unplug not supported for this guest"); 2888cf632463SBharata B Rao } 2889cf632463SBharata B Rao } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 2890c5514d0eSIgor Mammedov if (!mc->has_hotpluggable_cpus) { 2891cf632463SBharata B Rao error_setg(errp, "CPU hot unplug not supported on this machine"); 2892cf632463SBharata B Rao return; 2893cf632463SBharata B Rao } 2894cf632463SBharata B Rao spapr_core_unplug(hotplug_dev, dev, errp); 2895cf632463SBharata B Rao } 2896cf632463SBharata B Rao } 2897cf632463SBharata B Rao 2898cf632463SBharata B Rao static void spapr_machine_device_unplug_request(HotplugHandler *hotplug_dev, 2899cf632463SBharata B Rao DeviceState *dev, Error **errp) 2900cf632463SBharata B Rao { 2901cf632463SBharata B Rao sPAPRMachineState *sms = SPAPR_MACHINE(qdev_get_machine()); 2902cf632463SBharata B Rao MachineClass *mc = MACHINE_GET_CLASS(qdev_get_machine()); 2903cf632463SBharata B Rao 2904cf632463SBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { 2905cf632463SBharata B Rao if (spapr_ovec_test(sms->ov5_cas, OV5_HP_EVT)) { 2906cf632463SBharata B Rao spapr_memory_unplug_request(hotplug_dev, dev, errp); 2907cf632463SBharata B Rao } else { 2908cf632463SBharata B Rao /* NOTE: this means there is a window after guest reset, prior to 2909cf632463SBharata B Rao * CAS negotiation, where unplug requests will fail due to the 2910cf632463SBharata B Rao * capability not being detected yet. This is a bit different than 2911cf632463SBharata B Rao * the case with PCI unplug, where the events will be queued and 2912cf632463SBharata B Rao * eventually handled by the guest after boot 2913cf632463SBharata B Rao */ 2914cf632463SBharata B Rao error_setg(errp, "Memory hot unplug not supported for this guest"); 2915cf632463SBharata B Rao } 29166f4b5c3eSBharata B Rao } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 2917c5514d0eSIgor Mammedov if (!mc->has_hotpluggable_cpus) { 29186f4b5c3eSBharata B Rao error_setg(errp, "CPU hot unplug not supported on this machine"); 29196f4b5c3eSBharata B Rao return; 29206f4b5c3eSBharata B Rao } 2921115debf2SIgor Mammedov spapr_core_unplug_request(hotplug_dev, dev, errp); 2922c20d332aSBharata B Rao } 2923c20d332aSBharata B Rao } 2924c20d332aSBharata B Rao 292594a94e4cSBharata B Rao static void spapr_machine_device_pre_plug(HotplugHandler *hotplug_dev, 292694a94e4cSBharata B Rao DeviceState *dev, Error **errp) 292794a94e4cSBharata B Rao { 292894a94e4cSBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 292994a94e4cSBharata B Rao spapr_core_pre_plug(hotplug_dev, dev, errp); 293094a94e4cSBharata B Rao } 293194a94e4cSBharata B Rao } 293294a94e4cSBharata B Rao 29337ebaf795SBharata B Rao static HotplugHandler *spapr_get_hotplug_handler(MachineState *machine, 2934c20d332aSBharata B Rao DeviceState *dev) 2935c20d332aSBharata B Rao { 293694a94e4cSBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM) || 293794a94e4cSBharata B Rao object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 2938c20d332aSBharata B Rao return HOTPLUG_HANDLER(machine); 2939c20d332aSBharata B Rao } 2940c20d332aSBharata B Rao return NULL; 2941c20d332aSBharata B Rao } 2942c20d332aSBharata B Rao 294320bb648dSDavid Gibson static unsigned spapr_cpu_index_to_socket_id(unsigned cpu_index) 294420bb648dSDavid Gibson { 294520bb648dSDavid Gibson /* Allocate to NUMA nodes on a "socket" basis (not that concept of 294620bb648dSDavid Gibson * socket means much for the paravirtualized PAPR platform) */ 294720bb648dSDavid Gibson return cpu_index / smp_threads / smp_cores; 294820bb648dSDavid Gibson } 294920bb648dSDavid Gibson 2950535455fdSIgor Mammedov static const CPUArchIdList *spapr_possible_cpu_arch_ids(MachineState *machine) 2951535455fdSIgor Mammedov { 2952535455fdSIgor Mammedov int i; 2953535455fdSIgor Mammedov int spapr_max_cores = max_cpus / smp_threads; 2954535455fdSIgor Mammedov MachineClass *mc = MACHINE_GET_CLASS(machine); 2955535455fdSIgor Mammedov 2956c5514d0eSIgor Mammedov if (!mc->has_hotpluggable_cpus) { 2957535455fdSIgor Mammedov spapr_max_cores = QEMU_ALIGN_UP(smp_cpus, smp_threads) / smp_threads; 2958535455fdSIgor Mammedov } 2959535455fdSIgor Mammedov if (machine->possible_cpus) { 2960535455fdSIgor Mammedov assert(machine->possible_cpus->len == spapr_max_cores); 2961535455fdSIgor Mammedov return machine->possible_cpus; 2962535455fdSIgor Mammedov } 2963535455fdSIgor Mammedov 2964535455fdSIgor Mammedov machine->possible_cpus = g_malloc0(sizeof(CPUArchIdList) + 2965535455fdSIgor Mammedov sizeof(CPUArchId) * spapr_max_cores); 2966535455fdSIgor Mammedov machine->possible_cpus->len = spapr_max_cores; 2967535455fdSIgor Mammedov for (i = 0; i < machine->possible_cpus->len; i++) { 2968535455fdSIgor Mammedov int core_id = i * smp_threads; 2969535455fdSIgor Mammedov 2970f2d672c2SIgor Mammedov machine->possible_cpus->cpus[i].vcpus_count = smp_threads; 2971535455fdSIgor Mammedov machine->possible_cpus->cpus[i].arch_id = core_id; 2972535455fdSIgor Mammedov machine->possible_cpus->cpus[i].props.has_core_id = true; 2973535455fdSIgor Mammedov machine->possible_cpus->cpus[i].props.core_id = core_id; 2974535455fdSIgor Mammedov /* TODO: add 'has_node/node' here to describe 2975535455fdSIgor Mammedov to which node core belongs */ 2976535455fdSIgor Mammedov } 2977535455fdSIgor Mammedov return machine->possible_cpus; 2978535455fdSIgor Mammedov } 2979535455fdSIgor Mammedov 29806737d9adSDavid Gibson static void spapr_phb_placement(sPAPRMachineState *spapr, uint32_t index, 2981daa23699SDavid Gibson uint64_t *buid, hwaddr *pio, 2982daa23699SDavid Gibson hwaddr *mmio32, hwaddr *mmio64, 29836737d9adSDavid Gibson unsigned n_dma, uint32_t *liobns, Error **errp) 29846737d9adSDavid Gibson { 2985357d1e3bSDavid Gibson /* 2986357d1e3bSDavid Gibson * New-style PHB window placement. 2987357d1e3bSDavid Gibson * 2988357d1e3bSDavid Gibson * Goals: Gives large (1TiB), naturally aligned 64-bit MMIO window 2989357d1e3bSDavid Gibson * for each PHB, in addition to 2GiB 32-bit MMIO and 64kiB PIO 2990357d1e3bSDavid Gibson * windows. 2991357d1e3bSDavid Gibson * 2992357d1e3bSDavid Gibson * Some guest kernels can't work with MMIO windows above 1<<46 2993357d1e3bSDavid Gibson * (64TiB), so we place up to 31 PHBs in the area 32TiB..64TiB 2994357d1e3bSDavid Gibson * 2995357d1e3bSDavid Gibson * 32TiB..(33TiB+1984kiB) contains the 64kiB PIO windows for each 2996357d1e3bSDavid Gibson * PHB stacked together. (32TiB+2GiB)..(32TiB+64GiB) contains the 2997357d1e3bSDavid Gibson * 2GiB 32-bit MMIO windows for each PHB. Then 33..64TiB has the 2998357d1e3bSDavid Gibson * 1TiB 64-bit MMIO windows for each PHB. 2999357d1e3bSDavid Gibson */ 30006737d9adSDavid Gibson const uint64_t base_buid = 0x800000020000000ULL; 300125e6a118SMichael S. Tsirkin #define SPAPR_MAX_PHBS ((SPAPR_PCI_LIMIT - SPAPR_PCI_BASE) / \ 300225e6a118SMichael S. Tsirkin SPAPR_PCI_MEM64_WIN_SIZE - 1) 30036737d9adSDavid Gibson int i; 30046737d9adSDavid Gibson 3005357d1e3bSDavid Gibson /* Sanity check natural alignments */ 3006357d1e3bSDavid Gibson QEMU_BUILD_BUG_ON((SPAPR_PCI_BASE % SPAPR_PCI_MEM64_WIN_SIZE) != 0); 3007357d1e3bSDavid Gibson QEMU_BUILD_BUG_ON((SPAPR_PCI_LIMIT % SPAPR_PCI_MEM64_WIN_SIZE) != 0); 3008357d1e3bSDavid Gibson QEMU_BUILD_BUG_ON((SPAPR_PCI_MEM64_WIN_SIZE % SPAPR_PCI_MEM32_WIN_SIZE) != 0); 3009357d1e3bSDavid Gibson QEMU_BUILD_BUG_ON((SPAPR_PCI_MEM32_WIN_SIZE % SPAPR_PCI_IO_WIN_SIZE) != 0); 3010357d1e3bSDavid Gibson /* Sanity check bounds */ 301125e6a118SMichael S. Tsirkin QEMU_BUILD_BUG_ON((SPAPR_MAX_PHBS * SPAPR_PCI_IO_WIN_SIZE) > 301225e6a118SMichael S. Tsirkin SPAPR_PCI_MEM32_WIN_SIZE); 301325e6a118SMichael S. Tsirkin QEMU_BUILD_BUG_ON((SPAPR_MAX_PHBS * SPAPR_PCI_MEM32_WIN_SIZE) > 301425e6a118SMichael S. Tsirkin SPAPR_PCI_MEM64_WIN_SIZE); 30152efff1c0SDavid Gibson 301625e6a118SMichael S. Tsirkin if (index >= SPAPR_MAX_PHBS) { 301725e6a118SMichael S. Tsirkin error_setg(errp, "\"index\" for PAPR PHB is too large (max %llu)", 301825e6a118SMichael S. Tsirkin SPAPR_MAX_PHBS - 1); 30196737d9adSDavid Gibson return; 30206737d9adSDavid Gibson } 30216737d9adSDavid Gibson 30226737d9adSDavid Gibson *buid = base_buid + index; 30236737d9adSDavid Gibson for (i = 0; i < n_dma; ++i) { 30246737d9adSDavid Gibson liobns[i] = SPAPR_PCI_LIOBN(index, i); 30256737d9adSDavid Gibson } 30266737d9adSDavid Gibson 3027357d1e3bSDavid Gibson *pio = SPAPR_PCI_BASE + index * SPAPR_PCI_IO_WIN_SIZE; 3028357d1e3bSDavid Gibson *mmio32 = SPAPR_PCI_BASE + (index + 1) * SPAPR_PCI_MEM32_WIN_SIZE; 3029357d1e3bSDavid Gibson *mmio64 = SPAPR_PCI_BASE + (index + 1) * SPAPR_PCI_MEM64_WIN_SIZE; 30306737d9adSDavid Gibson } 30316737d9adSDavid Gibson 30327844e12bSCédric Le Goater static ICSState *spapr_ics_get(XICSFabric *dev, int irq) 30337844e12bSCédric Le Goater { 30347844e12bSCédric Le Goater sPAPRMachineState *spapr = SPAPR_MACHINE(dev); 30357844e12bSCédric Le Goater 30367844e12bSCédric Le Goater return ics_valid_irq(spapr->ics, irq) ? spapr->ics : NULL; 30377844e12bSCédric Le Goater } 30387844e12bSCédric Le Goater 30397844e12bSCédric Le Goater static void spapr_ics_resend(XICSFabric *dev) 30407844e12bSCédric Le Goater { 30417844e12bSCédric Le Goater sPAPRMachineState *spapr = SPAPR_MACHINE(dev); 30427844e12bSCédric Le Goater 30437844e12bSCédric Le Goater ics_resend(spapr->ics); 30447844e12bSCédric Le Goater } 30457844e12bSCédric Le Goater 3046b2fc59aaSCédric Le Goater static ICPState *spapr_icp_get(XICSFabric *xi, int server) 3047b2fc59aaSCédric Le Goater { 3048b2fc59aaSCédric Le Goater sPAPRMachineState *spapr = SPAPR_MACHINE(xi); 3049b2fc59aaSCédric Le Goater 3050852ad27eSCédric Le Goater return (server < spapr->nr_servers) ? &spapr->icps[server] : NULL; 3051b2fc59aaSCédric Le Goater } 3052b2fc59aaSCédric Le Goater 30536449da45SCédric Le Goater static void spapr_pic_print_info(InterruptStatsProvider *obj, 30546449da45SCédric Le Goater Monitor *mon) 30556449da45SCédric Le Goater { 30566449da45SCédric Le Goater sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 30576449da45SCédric Le Goater int i; 30586449da45SCédric Le Goater 30596449da45SCédric Le Goater for (i = 0; i < spapr->nr_servers; i++) { 30606449da45SCédric Le Goater icp_pic_print_info(&spapr->icps[i], mon); 30616449da45SCédric Le Goater } 30626449da45SCédric Le Goater 30636449da45SCédric Le Goater ics_pic_print_info(spapr->ics, mon); 30646449da45SCédric Le Goater } 30656449da45SCédric Le Goater 306629ee3247SAlexey Kardashevskiy static void spapr_machine_class_init(ObjectClass *oc, void *data) 306753018216SPaolo Bonzini { 306829ee3247SAlexey Kardashevskiy MachineClass *mc = MACHINE_CLASS(oc); 3069224245bfSDavid Gibson sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(oc); 307071461b0fSAlexey Kardashevskiy FWPathProviderClass *fwc = FW_PATH_PROVIDER_CLASS(oc); 307134316482SAlexey Kardashevskiy NMIClass *nc = NMI_CLASS(oc); 3072c20d332aSBharata B Rao HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(oc); 30731d1be34dSDavid Gibson PPCVirtualHypervisorClass *vhc = PPC_VIRTUAL_HYPERVISOR_CLASS(oc); 30747844e12bSCédric Le Goater XICSFabricClass *xic = XICS_FABRIC_CLASS(oc); 30756449da45SCédric Le Goater InterruptStatsProviderClass *ispc = INTERRUPT_STATS_PROVIDER_CLASS(oc); 307629ee3247SAlexey Kardashevskiy 30770eb9054cSDavid Gibson mc->desc = "pSeries Logical Partition (PAPR compliant)"; 3078fc9f38c3SDavid Gibson 3079fc9f38c3SDavid Gibson /* 3080fc9f38c3SDavid Gibson * We set up the default / latest behaviour here. The class_init 3081fc9f38c3SDavid Gibson * functions for the specific versioned machine types can override 3082fc9f38c3SDavid Gibson * these details for backwards compatibility 3083fc9f38c3SDavid Gibson */ 3084958db90cSMarcel Apfelbaum mc->init = ppc_spapr_init; 3085958db90cSMarcel Apfelbaum mc->reset = ppc_spapr_reset; 3086958db90cSMarcel Apfelbaum mc->block_default_type = IF_SCSI; 30876244bb7eSGreg Kurz mc->max_cpus = 1024; 3088958db90cSMarcel Apfelbaum mc->no_parallel = 1; 30895b2128d2SAlexander Graf mc->default_boot_order = ""; 3090a34944feSNikunj A Dadhania mc->default_ram_size = 512 * M_BYTE; 3091958db90cSMarcel Apfelbaum mc->kvm_type = spapr_kvm_type; 30929e3f9733SAlexander Graf mc->has_dynamic_sysbus = true; 3093e4024630SLaurent Vivier mc->pci_allow_0_address = true; 30947ebaf795SBharata B Rao mc->get_hotplug_handler = spapr_get_hotplug_handler; 309594a94e4cSBharata B Rao hc->pre_plug = spapr_machine_device_pre_plug; 3096c20d332aSBharata B Rao hc->plug = spapr_machine_device_plug; 3097c20d332aSBharata B Rao hc->unplug = spapr_machine_device_unplug; 309820bb648dSDavid Gibson mc->cpu_index_to_socket_id = spapr_cpu_index_to_socket_id; 3099535455fdSIgor Mammedov mc->possible_cpu_arch_ids = spapr_possible_cpu_arch_ids; 3100cf632463SBharata B Rao hc->unplug_request = spapr_machine_device_unplug_request; 310100b4fbe2SMarcel Apfelbaum 3102fc9f38c3SDavid Gibson smc->dr_lmb_enabled = true; 31033daa4a9fSThomas Huth smc->tcg_default_cpu = "POWER8"; 3104c5514d0eSIgor Mammedov mc->has_hotpluggable_cpus = true; 310571461b0fSAlexey Kardashevskiy fwc->get_dev_path = spapr_get_fw_dev_path; 310634316482SAlexey Kardashevskiy nc->nmi_monitor_handler = spapr_nmi; 31076737d9adSDavid Gibson smc->phb_placement = spapr_phb_placement; 31081d1be34dSDavid Gibson vhc->hypercall = emulate_spapr_hypercall; 3109e57ca75cSDavid Gibson vhc->hpt_mask = spapr_hpt_mask; 3110e57ca75cSDavid Gibson vhc->map_hptes = spapr_map_hptes; 3111e57ca75cSDavid Gibson vhc->unmap_hptes = spapr_unmap_hptes; 3112e57ca75cSDavid Gibson vhc->store_hpte = spapr_store_hpte; 31139861bb3eSSuraj Jitindar Singh vhc->get_patbe = spapr_get_patbe; 31147844e12bSCédric Le Goater xic->ics_get = spapr_ics_get; 31157844e12bSCédric Le Goater xic->ics_resend = spapr_ics_resend; 3116b2fc59aaSCédric Le Goater xic->icp_get = spapr_icp_get; 31176449da45SCédric Le Goater ispc->print_info = spapr_pic_print_info; 311855641213SLaurent Vivier /* Force NUMA node memory size to be a multiple of 311955641213SLaurent Vivier * SPAPR_MEMORY_BLOCK_SIZE (256M) since that's the granularity 312055641213SLaurent Vivier * in which LMBs are represented and hot-added 312155641213SLaurent Vivier */ 312255641213SLaurent Vivier mc->numa_mem_align_shift = 28; 312353018216SPaolo Bonzini } 312453018216SPaolo Bonzini 312529ee3247SAlexey Kardashevskiy static const TypeInfo spapr_machine_info = { 312629ee3247SAlexey Kardashevskiy .name = TYPE_SPAPR_MACHINE, 312729ee3247SAlexey Kardashevskiy .parent = TYPE_MACHINE, 31284aee7362SDavid Gibson .abstract = true, 31296ca1502eSAlexey Kardashevskiy .instance_size = sizeof(sPAPRMachineState), 313023825581SEduardo Habkost .instance_init = spapr_machine_initfn, 313187bbdd9cSDavid Gibson .instance_finalize = spapr_machine_finalizefn, 3132183930c0SDavid Gibson .class_size = sizeof(sPAPRMachineClass), 313329ee3247SAlexey Kardashevskiy .class_init = spapr_machine_class_init, 313471461b0fSAlexey Kardashevskiy .interfaces = (InterfaceInfo[]) { 313571461b0fSAlexey Kardashevskiy { TYPE_FW_PATH_PROVIDER }, 313634316482SAlexey Kardashevskiy { TYPE_NMI }, 3137c20d332aSBharata B Rao { TYPE_HOTPLUG_HANDLER }, 31381d1be34dSDavid Gibson { TYPE_PPC_VIRTUAL_HYPERVISOR }, 31397844e12bSCédric Le Goater { TYPE_XICS_FABRIC }, 31406449da45SCédric Le Goater { TYPE_INTERRUPT_STATS_PROVIDER }, 314171461b0fSAlexey Kardashevskiy { } 314271461b0fSAlexey Kardashevskiy }, 314329ee3247SAlexey Kardashevskiy }; 314429ee3247SAlexey Kardashevskiy 3145fccbc785SDavid Gibson #define DEFINE_SPAPR_MACHINE(suffix, verstr, latest) \ 31465013c547SDavid Gibson static void spapr_machine_##suffix##_class_init(ObjectClass *oc, \ 31475013c547SDavid Gibson void *data) \ 31485013c547SDavid Gibson { \ 31495013c547SDavid Gibson MachineClass *mc = MACHINE_CLASS(oc); \ 31505013c547SDavid Gibson spapr_machine_##suffix##_class_options(mc); \ 3151fccbc785SDavid Gibson if (latest) { \ 3152fccbc785SDavid Gibson mc->alias = "pseries"; \ 3153fccbc785SDavid Gibson mc->is_default = 1; \ 3154fccbc785SDavid Gibson } \ 31555013c547SDavid Gibson } \ 31565013c547SDavid Gibson static void spapr_machine_##suffix##_instance_init(Object *obj) \ 31575013c547SDavid Gibson { \ 31585013c547SDavid Gibson MachineState *machine = MACHINE(obj); \ 31595013c547SDavid Gibson spapr_machine_##suffix##_instance_options(machine); \ 31605013c547SDavid Gibson } \ 31615013c547SDavid Gibson static const TypeInfo spapr_machine_##suffix##_info = { \ 31625013c547SDavid Gibson .name = MACHINE_TYPE_NAME("pseries-" verstr), \ 31635013c547SDavid Gibson .parent = TYPE_SPAPR_MACHINE, \ 31645013c547SDavid Gibson .class_init = spapr_machine_##suffix##_class_init, \ 31655013c547SDavid Gibson .instance_init = spapr_machine_##suffix##_instance_init, \ 31665013c547SDavid Gibson }; \ 31675013c547SDavid Gibson static void spapr_machine_register_##suffix(void) \ 31685013c547SDavid Gibson { \ 31695013c547SDavid Gibson type_register(&spapr_machine_##suffix##_info); \ 31705013c547SDavid Gibson } \ 31710e6aac87SEduardo Habkost type_init(spapr_machine_register_##suffix) 31725013c547SDavid Gibson 31731c5f29bbSDavid Gibson /* 31743fa14fbeSDavid Gibson * pseries-2.10 3175db800b21SDavid Gibson */ 31763fa14fbeSDavid Gibson static void spapr_machine_2_10_instance_options(MachineState *machine) 3177db800b21SDavid Gibson { 3178db800b21SDavid Gibson } 3179db800b21SDavid Gibson 31803fa14fbeSDavid Gibson static void spapr_machine_2_10_class_options(MachineClass *mc) 3181db800b21SDavid Gibson { 3182db800b21SDavid Gibson /* Defaults for the latest behaviour inherited from the base class */ 3183db800b21SDavid Gibson } 3184db800b21SDavid Gibson 31853fa14fbeSDavid Gibson DEFINE_SPAPR_MACHINE(2_10, "2.10", true); 31863fa14fbeSDavid Gibson 31873fa14fbeSDavid Gibson /* 31883fa14fbeSDavid Gibson * pseries-2.9 31893fa14fbeSDavid Gibson */ 31903fa14fbeSDavid Gibson #define SPAPR_COMPAT_2_9 \ 31913fa14fbeSDavid Gibson HW_COMPAT_2_9 31923fa14fbeSDavid Gibson 31933fa14fbeSDavid Gibson static void spapr_machine_2_9_instance_options(MachineState *machine) 31943fa14fbeSDavid Gibson { 31953fa14fbeSDavid Gibson spapr_machine_2_10_instance_options(machine); 31963fa14fbeSDavid Gibson } 31973fa14fbeSDavid Gibson 31983fa14fbeSDavid Gibson static void spapr_machine_2_9_class_options(MachineClass *mc) 31993fa14fbeSDavid Gibson { 32003fa14fbeSDavid Gibson spapr_machine_2_10_class_options(mc); 32013fa14fbeSDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_9); 32023fa14fbeSDavid Gibson } 32033fa14fbeSDavid Gibson 32043fa14fbeSDavid Gibson DEFINE_SPAPR_MACHINE(2_9, "2.9", false); 3205fa325e6cSDavid Gibson 3206fa325e6cSDavid Gibson /* 3207fa325e6cSDavid Gibson * pseries-2.8 3208fa325e6cSDavid Gibson */ 3209fa325e6cSDavid Gibson #define SPAPR_COMPAT_2_8 \ 321082516263SDavid Gibson HW_COMPAT_2_8 \ 321182516263SDavid Gibson { \ 321282516263SDavid Gibson .driver = TYPE_SPAPR_PCI_HOST_BRIDGE, \ 321382516263SDavid Gibson .property = "pcie-extended-configuration-space", \ 321482516263SDavid Gibson .value = "off", \ 321582516263SDavid Gibson }, 3216fa325e6cSDavid Gibson 3217fa325e6cSDavid Gibson static void spapr_machine_2_8_instance_options(MachineState *machine) 3218fa325e6cSDavid Gibson { 3219fa325e6cSDavid Gibson spapr_machine_2_9_instance_options(machine); 3220fa325e6cSDavid Gibson } 3221fa325e6cSDavid Gibson 3222fa325e6cSDavid Gibson static void spapr_machine_2_8_class_options(MachineClass *mc) 3223fa325e6cSDavid Gibson { 3224fa325e6cSDavid Gibson spapr_machine_2_9_class_options(mc); 3225fa325e6cSDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_8); 322655641213SLaurent Vivier mc->numa_mem_align_shift = 23; 3227fa325e6cSDavid Gibson } 3228fa325e6cSDavid Gibson 3229fa325e6cSDavid Gibson DEFINE_SPAPR_MACHINE(2_8, "2.8", false); 3230db800b21SDavid Gibson 3231db800b21SDavid Gibson /* 32321ea1eefcSBharata B Rao * pseries-2.7 32331ea1eefcSBharata B Rao */ 3234db800b21SDavid Gibson #define SPAPR_COMPAT_2_7 \ 3235db800b21SDavid Gibson HW_COMPAT_2_7 \ 3236357d1e3bSDavid Gibson { \ 3237357d1e3bSDavid Gibson .driver = TYPE_SPAPR_PCI_HOST_BRIDGE, \ 3238357d1e3bSDavid Gibson .property = "mem_win_size", \ 3239357d1e3bSDavid Gibson .value = stringify(SPAPR_PCI_2_7_MMIO_WIN_SIZE),\ 3240357d1e3bSDavid Gibson }, \ 3241357d1e3bSDavid Gibson { \ 3242357d1e3bSDavid Gibson .driver = TYPE_SPAPR_PCI_HOST_BRIDGE, \ 3243357d1e3bSDavid Gibson .property = "mem64_win_size", \ 3244357d1e3bSDavid Gibson .value = "0", \ 3245146c11f1SDavid Gibson }, \ 3246146c11f1SDavid Gibson { \ 3247146c11f1SDavid Gibson .driver = TYPE_POWERPC_CPU, \ 3248146c11f1SDavid Gibson .property = "pre-2.8-migration", \ 3249146c11f1SDavid Gibson .value = "on", \ 32505c4537bdSDavid Gibson }, \ 32515c4537bdSDavid Gibson { \ 32525c4537bdSDavid Gibson .driver = TYPE_SPAPR_PCI_HOST_BRIDGE, \ 32535c4537bdSDavid Gibson .property = "pre-2.8-migration", \ 32545c4537bdSDavid Gibson .value = "on", \ 3255357d1e3bSDavid Gibson }, 3256357d1e3bSDavid Gibson 3257357d1e3bSDavid Gibson static void phb_placement_2_7(sPAPRMachineState *spapr, uint32_t index, 3258357d1e3bSDavid Gibson uint64_t *buid, hwaddr *pio, 3259357d1e3bSDavid Gibson hwaddr *mmio32, hwaddr *mmio64, 3260357d1e3bSDavid Gibson unsigned n_dma, uint32_t *liobns, Error **errp) 3261357d1e3bSDavid Gibson { 3262357d1e3bSDavid Gibson /* Legacy PHB placement for pseries-2.7 and earlier machine types */ 3263357d1e3bSDavid Gibson const uint64_t base_buid = 0x800000020000000ULL; 3264357d1e3bSDavid Gibson const hwaddr phb_spacing = 0x1000000000ULL; /* 64 GiB */ 3265357d1e3bSDavid Gibson const hwaddr mmio_offset = 0xa0000000; /* 2 GiB + 512 MiB */ 3266357d1e3bSDavid Gibson const hwaddr pio_offset = 0x80000000; /* 2 GiB */ 3267357d1e3bSDavid Gibson const uint32_t max_index = 255; 3268357d1e3bSDavid Gibson const hwaddr phb0_alignment = 0x10000000000ULL; /* 1 TiB */ 3269357d1e3bSDavid Gibson 3270357d1e3bSDavid Gibson uint64_t ram_top = MACHINE(spapr)->ram_size; 3271357d1e3bSDavid Gibson hwaddr phb0_base, phb_base; 3272357d1e3bSDavid Gibson int i; 3273357d1e3bSDavid Gibson 3274357d1e3bSDavid Gibson /* Do we have hotpluggable memory? */ 3275357d1e3bSDavid Gibson if (MACHINE(spapr)->maxram_size > ram_top) { 3276357d1e3bSDavid Gibson /* Can't just use maxram_size, because there may be an 3277357d1e3bSDavid Gibson * alignment gap between normal and hotpluggable memory 3278357d1e3bSDavid Gibson * regions */ 3279357d1e3bSDavid Gibson ram_top = spapr->hotplug_memory.base + 3280357d1e3bSDavid Gibson memory_region_size(&spapr->hotplug_memory.mr); 3281357d1e3bSDavid Gibson } 3282357d1e3bSDavid Gibson 3283357d1e3bSDavid Gibson phb0_base = QEMU_ALIGN_UP(ram_top, phb0_alignment); 3284357d1e3bSDavid Gibson 3285357d1e3bSDavid Gibson if (index > max_index) { 3286357d1e3bSDavid Gibson error_setg(errp, "\"index\" for PAPR PHB is too large (max %u)", 3287357d1e3bSDavid Gibson max_index); 3288357d1e3bSDavid Gibson return; 3289357d1e3bSDavid Gibson } 3290357d1e3bSDavid Gibson 3291357d1e3bSDavid Gibson *buid = base_buid + index; 3292357d1e3bSDavid Gibson for (i = 0; i < n_dma; ++i) { 3293357d1e3bSDavid Gibson liobns[i] = SPAPR_PCI_LIOBN(index, i); 3294357d1e3bSDavid Gibson } 3295357d1e3bSDavid Gibson 3296357d1e3bSDavid Gibson phb_base = phb0_base + index * phb_spacing; 3297357d1e3bSDavid Gibson *pio = phb_base + pio_offset; 3298357d1e3bSDavid Gibson *mmio32 = phb_base + mmio_offset; 3299357d1e3bSDavid Gibson /* 3300357d1e3bSDavid Gibson * We don't set the 64-bit MMIO window, relying on the PHB's 3301357d1e3bSDavid Gibson * fallback behaviour of automatically splitting a large "32-bit" 3302357d1e3bSDavid Gibson * window into contiguous 32-bit and 64-bit windows 3303357d1e3bSDavid Gibson */ 3304357d1e3bSDavid Gibson } 3305db800b21SDavid Gibson 33061ea1eefcSBharata B Rao static void spapr_machine_2_7_instance_options(MachineState *machine) 33071ea1eefcSBharata B Rao { 3308f6229214SMichael Roth sPAPRMachineState *spapr = SPAPR_MACHINE(machine); 3309f6229214SMichael Roth 3310672de881SMichael Roth spapr_machine_2_8_instance_options(machine); 3311f6229214SMichael Roth spapr->use_hotplug_event_source = false; 33121ea1eefcSBharata B Rao } 33131ea1eefcSBharata B Rao 33141ea1eefcSBharata B Rao static void spapr_machine_2_7_class_options(MachineClass *mc) 33151ea1eefcSBharata B Rao { 33163daa4a9fSThomas Huth sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); 33173daa4a9fSThomas Huth 3318db800b21SDavid Gibson spapr_machine_2_8_class_options(mc); 33193daa4a9fSThomas Huth smc->tcg_default_cpu = "POWER7"; 3320db800b21SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_7); 3321357d1e3bSDavid Gibson smc->phb_placement = phb_placement_2_7; 33221ea1eefcSBharata B Rao } 33231ea1eefcSBharata B Rao 3324db800b21SDavid Gibson DEFINE_SPAPR_MACHINE(2_7, "2.7", false); 33251ea1eefcSBharata B Rao 33261ea1eefcSBharata B Rao /* 33274b23699cSDavid Gibson * pseries-2.6 33284b23699cSDavid Gibson */ 33291ea1eefcSBharata B Rao #define SPAPR_COMPAT_2_6 \ 3330ae4de14cSAlexey Kardashevskiy HW_COMPAT_2_6 \ 3331ae4de14cSAlexey Kardashevskiy { \ 3332ae4de14cSAlexey Kardashevskiy .driver = TYPE_SPAPR_PCI_HOST_BRIDGE,\ 3333ae4de14cSAlexey Kardashevskiy .property = "ddw",\ 3334ae4de14cSAlexey Kardashevskiy .value = stringify(off),\ 3335ae4de14cSAlexey Kardashevskiy }, 33361ea1eefcSBharata B Rao 33374b23699cSDavid Gibson static void spapr_machine_2_6_instance_options(MachineState *machine) 33384b23699cSDavid Gibson { 3339672de881SMichael Roth spapr_machine_2_7_instance_options(machine); 33404b23699cSDavid Gibson } 33414b23699cSDavid Gibson 33424b23699cSDavid Gibson static void spapr_machine_2_6_class_options(MachineClass *mc) 33434b23699cSDavid Gibson { 33441ea1eefcSBharata B Rao spapr_machine_2_7_class_options(mc); 3345c5514d0eSIgor Mammedov mc->has_hotpluggable_cpus = false; 33461ea1eefcSBharata B Rao SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_6); 33474b23699cSDavid Gibson } 33484b23699cSDavid Gibson 33491ea1eefcSBharata B Rao DEFINE_SPAPR_MACHINE(2_6, "2.6", false); 33504b23699cSDavid Gibson 33514b23699cSDavid Gibson /* 33521c5f29bbSDavid Gibson * pseries-2.5 33531c5f29bbSDavid Gibson */ 33544b23699cSDavid Gibson #define SPAPR_COMPAT_2_5 \ 335557c522f4SThomas Huth HW_COMPAT_2_5 \ 335657c522f4SThomas Huth { \ 335757c522f4SThomas Huth .driver = "spapr-vlan", \ 335857c522f4SThomas Huth .property = "use-rx-buffer-pools", \ 335957c522f4SThomas Huth .value = "off", \ 336057c522f4SThomas Huth }, 33614b23699cSDavid Gibson 33625013c547SDavid Gibson static void spapr_machine_2_5_instance_options(MachineState *machine) 33631c5f29bbSDavid Gibson { 3364672de881SMichael Roth spapr_machine_2_6_instance_options(machine); 33655013c547SDavid Gibson } 33665013c547SDavid Gibson 33675013c547SDavid Gibson static void spapr_machine_2_5_class_options(MachineClass *mc) 33685013c547SDavid Gibson { 336957040d45SThomas Huth sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); 337057040d45SThomas Huth 33714b23699cSDavid Gibson spapr_machine_2_6_class_options(mc); 337257040d45SThomas Huth smc->use_ohci_by_default = true; 33734b23699cSDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_5); 33741c5f29bbSDavid Gibson } 33751c5f29bbSDavid Gibson 33764b23699cSDavid Gibson DEFINE_SPAPR_MACHINE(2_5, "2.5", false); 33771c5f29bbSDavid Gibson 33781c5f29bbSDavid Gibson /* 33791c5f29bbSDavid Gibson * pseries-2.4 33801c5f29bbSDavid Gibson */ 338180fd50f9SCornelia Huck #define SPAPR_COMPAT_2_4 \ 338280fd50f9SCornelia Huck HW_COMPAT_2_4 338380fd50f9SCornelia Huck 33845013c547SDavid Gibson static void spapr_machine_2_4_instance_options(MachineState *machine) 33851c5f29bbSDavid Gibson { 33865013c547SDavid Gibson spapr_machine_2_5_instance_options(machine); 33875013c547SDavid Gibson } 33881c5f29bbSDavid Gibson 33895013c547SDavid Gibson static void spapr_machine_2_4_class_options(MachineClass *mc) 33905013c547SDavid Gibson { 3391fc9f38c3SDavid Gibson sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); 3392fc9f38c3SDavid Gibson 3393fc9f38c3SDavid Gibson spapr_machine_2_5_class_options(mc); 3394fc9f38c3SDavid Gibson smc->dr_lmb_enabled = false; 3395f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_4); 33961c5f29bbSDavid Gibson } 33971c5f29bbSDavid Gibson 3398fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_4, "2.4", false); 33991c5f29bbSDavid Gibson 34001c5f29bbSDavid Gibson /* 34011c5f29bbSDavid Gibson * pseries-2.3 34021c5f29bbSDavid Gibson */ 340338ff32c6SEduardo Habkost #define SPAPR_COMPAT_2_3 \ 34047619c7b0SMichael Roth HW_COMPAT_2_3 \ 34057619c7b0SMichael Roth {\ 34067619c7b0SMichael Roth .driver = "spapr-pci-host-bridge",\ 34077619c7b0SMichael Roth .property = "dynamic-reconfiguration",\ 34087619c7b0SMichael Roth .value = "off",\ 34097619c7b0SMichael Roth }, 341038ff32c6SEduardo Habkost 34115013c547SDavid Gibson static void spapr_machine_2_3_instance_options(MachineState *machine) 34121c5f29bbSDavid Gibson { 34135013c547SDavid Gibson spapr_machine_2_4_instance_options(machine); 34141c5f29bbSDavid Gibson savevm_skip_section_footers(); 34151c5f29bbSDavid Gibson global_state_set_optional(); 341609b5e30dSGreg Kurz savevm_skip_configuration(); 34171c5f29bbSDavid Gibson } 34181c5f29bbSDavid Gibson 34195013c547SDavid Gibson static void spapr_machine_2_3_class_options(MachineClass *mc) 34201c5f29bbSDavid Gibson { 3421fc9f38c3SDavid Gibson spapr_machine_2_4_class_options(mc); 3422f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_3); 34231c5f29bbSDavid Gibson } 3424fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_3, "2.3", false); 34251c5f29bbSDavid Gibson 34261c5f29bbSDavid Gibson /* 34271c5f29bbSDavid Gibson * pseries-2.2 34281c5f29bbSDavid Gibson */ 34291c5f29bbSDavid Gibson 3430b194df47SAlexey Kardashevskiy #define SPAPR_COMPAT_2_2 \ 34314dfd8eaaSEduardo Habkost HW_COMPAT_2_2 \ 3432b194df47SAlexey Kardashevskiy {\ 3433b194df47SAlexey Kardashevskiy .driver = TYPE_SPAPR_PCI_HOST_BRIDGE,\ 3434b194df47SAlexey Kardashevskiy .property = "mem_win_size",\ 3435b194df47SAlexey Kardashevskiy .value = "0x20000000",\ 3436dd754bafSEduardo Habkost }, 3437b194df47SAlexey Kardashevskiy 34385013c547SDavid Gibson static void spapr_machine_2_2_instance_options(MachineState *machine) 3439b0e966d0SJason Wang { 34405013c547SDavid Gibson spapr_machine_2_3_instance_options(machine); 3441cba0e779SGreg Kurz machine->suppress_vmdesc = true; 3442b0e966d0SJason Wang } 3443b0e966d0SJason Wang 34445013c547SDavid Gibson static void spapr_machine_2_2_class_options(MachineClass *mc) 3445b0e966d0SJason Wang { 3446fc9f38c3SDavid Gibson spapr_machine_2_3_class_options(mc); 3447f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_2); 34481c5f29bbSDavid Gibson } 3449fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_2, "2.2", false); 34501c5f29bbSDavid Gibson 34511c5f29bbSDavid Gibson /* 34521c5f29bbSDavid Gibson * pseries-2.1 34531c5f29bbSDavid Gibson */ 34541c5f29bbSDavid Gibson #define SPAPR_COMPAT_2_1 \ 34551c5f29bbSDavid Gibson HW_COMPAT_2_1 34561c5f29bbSDavid Gibson 34575013c547SDavid Gibson static void spapr_machine_2_1_instance_options(MachineState *machine) 34581c5f29bbSDavid Gibson { 34595013c547SDavid Gibson spapr_machine_2_2_instance_options(machine); 34601c5f29bbSDavid Gibson } 34611c5f29bbSDavid Gibson 34625013c547SDavid Gibson static void spapr_machine_2_1_class_options(MachineClass *mc) 3463b0e966d0SJason Wang { 3464fc9f38c3SDavid Gibson spapr_machine_2_2_class_options(mc); 3465f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_1); 34666026db45SAlexey Kardashevskiy } 3467fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_1, "2.1", false); 34686026db45SAlexey Kardashevskiy 346929ee3247SAlexey Kardashevskiy static void spapr_machine_register_types(void) 347029ee3247SAlexey Kardashevskiy { 347129ee3247SAlexey Kardashevskiy type_register_static(&spapr_machine_info); 347229ee3247SAlexey Kardashevskiy } 347329ee3247SAlexey Kardashevskiy 347429ee3247SAlexey Kardashevskiy type_init(spapr_machine_register_types) 3475