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" 3953018216SPaolo Bonzini #include "sysemu/kvm.h" 40c20d332aSBharata B Rao #include "sysemu/device_tree.h" 4153018216SPaolo Bonzini #include "kvm_ppc.h" 42ff14e817SDr. David Alan Gilbert #include "migration/migration.h" 434be21d56SDavid Gibson #include "mmu-hash64.h" 443794d548SAlexey Kardashevskiy #include "qom/cpu.h" 4553018216SPaolo Bonzini 4653018216SPaolo Bonzini #include "hw/boards.h" 470d09e41aSPaolo Bonzini #include "hw/ppc/ppc.h" 4853018216SPaolo Bonzini #include "hw/loader.h" 4953018216SPaolo Bonzini 500d09e41aSPaolo Bonzini #include "hw/ppc/spapr.h" 510d09e41aSPaolo Bonzini #include "hw/ppc/spapr_vio.h" 520d09e41aSPaolo Bonzini #include "hw/pci-host/spapr.h" 530d09e41aSPaolo Bonzini #include "hw/ppc/xics.h" 5453018216SPaolo Bonzini #include "hw/pci/msi.h" 5553018216SPaolo Bonzini 5653018216SPaolo Bonzini #include "hw/pci/pci.h" 5771461b0fSAlexey Kardashevskiy #include "hw/scsi/scsi.h" 5871461b0fSAlexey Kardashevskiy #include "hw/virtio/virtio-scsi.h" 5953018216SPaolo Bonzini 6053018216SPaolo Bonzini #include "exec/address-spaces.h" 6153018216SPaolo Bonzini #include "hw/usb.h" 6253018216SPaolo Bonzini #include "qemu/config-file.h" 63135a129aSAneesh Kumar K.V #include "qemu/error-report.h" 642a6593cbSAlexey Kardashevskiy #include "trace.h" 6534316482SAlexey Kardashevskiy #include "hw/nmi.h" 6653018216SPaolo Bonzini 6768a27b20SMichael S. Tsirkin #include "hw/compat.h" 68f348b6d1SVeronia Bahaa #include "qemu/cutils.h" 6994a94e4cSBharata B Rao #include "hw/ppc/spapr_cpu_core.h" 702474bfd4SIgor Mammedov #include "qmp-commands.h" 7168a27b20SMichael S. Tsirkin 7253018216SPaolo Bonzini #include <libfdt.h> 7353018216SPaolo Bonzini 7453018216SPaolo Bonzini /* SLOF memory layout: 7553018216SPaolo Bonzini * 7653018216SPaolo Bonzini * SLOF raw image loaded at 0, copies its romfs right below the flat 7753018216SPaolo Bonzini * device-tree, then position SLOF itself 31M below that 7853018216SPaolo Bonzini * 7953018216SPaolo Bonzini * So we set FW_OVERHEAD to 40MB which should account for all of that 8053018216SPaolo Bonzini * and more 8153018216SPaolo Bonzini * 8253018216SPaolo Bonzini * We load our kernel at 4M, leaving space for SLOF initial image 8353018216SPaolo Bonzini */ 8438b02bd8SAlexey Kardashevskiy #define FDT_MAX_SIZE 0x100000 8553018216SPaolo Bonzini #define RTAS_MAX_SIZE 0x10000 86b7d1f77aSBenjamin Herrenschmidt #define RTAS_MAX_ADDR 0x80000000 /* RTAS must stay below that */ 8753018216SPaolo Bonzini #define FW_MAX_SIZE 0x400000 8853018216SPaolo Bonzini #define FW_FILE_NAME "slof.bin" 8953018216SPaolo Bonzini #define FW_OVERHEAD 0x2800000 9053018216SPaolo Bonzini #define KERNEL_LOAD_ADDR FW_MAX_SIZE 9153018216SPaolo Bonzini 9253018216SPaolo Bonzini #define MIN_RMA_SLOF 128UL 9353018216SPaolo Bonzini 9453018216SPaolo Bonzini #define PHANDLE_XICP 0x00001111 9553018216SPaolo Bonzini 9653018216SPaolo Bonzini #define HTAB_SIZE(spapr) (1ULL << ((spapr)->htab_shift)) 9753018216SPaolo Bonzini 98c04d6cfaSAnthony Liguori static XICSState *try_create_xics(const char *type, int nr_servers, 9934f2af3dSMarkus Armbruster int nr_irqs, Error **errp) 100c04d6cfaSAnthony Liguori { 10134f2af3dSMarkus Armbruster Error *err = NULL; 102c04d6cfaSAnthony Liguori DeviceState *dev; 103c04d6cfaSAnthony Liguori 104c04d6cfaSAnthony Liguori dev = qdev_create(NULL, type); 105c04d6cfaSAnthony Liguori qdev_prop_set_uint32(dev, "nr_servers", nr_servers); 106c04d6cfaSAnthony Liguori qdev_prop_set_uint32(dev, "nr_irqs", nr_irqs); 10734f2af3dSMarkus Armbruster object_property_set_bool(OBJECT(dev), true, "realized", &err); 10834f2af3dSMarkus Armbruster if (err) { 10934f2af3dSMarkus Armbruster error_propagate(errp, err); 11034f2af3dSMarkus Armbruster object_unparent(OBJECT(dev)); 111c04d6cfaSAnthony Liguori return NULL; 112c04d6cfaSAnthony Liguori } 1135a3d7b23SAlexey Kardashevskiy return XICS_COMMON(dev); 114c04d6cfaSAnthony Liguori } 115c04d6cfaSAnthony Liguori 116446f16a6SMarcel Apfelbaum static XICSState *xics_system_init(MachineState *machine, 1171e49182dSDavid Gibson int nr_servers, int nr_irqs, Error **errp) 118c04d6cfaSAnthony Liguori { 11927f24582SBenjamin Herrenschmidt XICSState *xics = NULL; 120c04d6cfaSAnthony Liguori 12111ad93f6SDavid Gibson if (kvm_enabled()) { 12234f2af3dSMarkus Armbruster Error *err = NULL; 12334f2af3dSMarkus Armbruster 124446f16a6SMarcel Apfelbaum if (machine_kernel_irqchip_allowed(machine)) { 12527f24582SBenjamin Herrenschmidt xics = try_create_xics(TYPE_XICS_SPAPR_KVM, nr_servers, nr_irqs, 126161deaf2SBenjamin Herrenschmidt &err); 12711ad93f6SDavid Gibson } 12827f24582SBenjamin Herrenschmidt if (machine_kernel_irqchip_required(machine) && !xics) { 129b83baa60SMarkus Armbruster error_reportf_err(err, 130b83baa60SMarkus Armbruster "kernel_irqchip requested but unavailable: "); 131b83baa60SMarkus Armbruster } else { 132903a41d3SStefano Dong (董兴水) error_free(err); 13311ad93f6SDavid Gibson } 134b83baa60SMarkus Armbruster } 13511ad93f6SDavid Gibson 13627f24582SBenjamin Herrenschmidt if (!xics) { 13727f24582SBenjamin Herrenschmidt xics = try_create_xics(TYPE_XICS_SPAPR, nr_servers, nr_irqs, errp); 138c04d6cfaSAnthony Liguori } 139c04d6cfaSAnthony Liguori 14027f24582SBenjamin Herrenschmidt return xics; 141c04d6cfaSAnthony Liguori } 142c04d6cfaSAnthony Liguori 143833d4668SAlexey Kardashevskiy static int spapr_fixup_cpu_smt_dt(void *fdt, int offset, PowerPCCPU *cpu, 144833d4668SAlexey Kardashevskiy int smt_threads) 145833d4668SAlexey Kardashevskiy { 146833d4668SAlexey Kardashevskiy int i, ret = 0; 147833d4668SAlexey Kardashevskiy uint32_t servers_prop[smt_threads]; 148833d4668SAlexey Kardashevskiy uint32_t gservers_prop[smt_threads * 2]; 149833d4668SAlexey Kardashevskiy int index = ppc_get_vcpu_dt_id(cpu); 150833d4668SAlexey Kardashevskiy 1516d9412eaSAlexey Kardashevskiy if (cpu->cpu_version) { 1524bce526eSLaurent Dufour ret = fdt_setprop_cell(fdt, offset, "cpu-version", cpu->cpu_version); 1536d9412eaSAlexey Kardashevskiy if (ret < 0) { 1546d9412eaSAlexey Kardashevskiy return ret; 1556d9412eaSAlexey Kardashevskiy } 1566d9412eaSAlexey Kardashevskiy } 1576d9412eaSAlexey Kardashevskiy 158833d4668SAlexey Kardashevskiy /* Build interrupt servers and gservers properties */ 159833d4668SAlexey Kardashevskiy for (i = 0; i < smt_threads; i++) { 160833d4668SAlexey Kardashevskiy servers_prop[i] = cpu_to_be32(index + i); 161833d4668SAlexey Kardashevskiy /* Hack, direct the group queues back to cpu 0 */ 162833d4668SAlexey Kardashevskiy gservers_prop[i*2] = cpu_to_be32(index + i); 163833d4668SAlexey Kardashevskiy gservers_prop[i*2 + 1] = 0; 164833d4668SAlexey Kardashevskiy } 165833d4668SAlexey Kardashevskiy ret = fdt_setprop(fdt, offset, "ibm,ppc-interrupt-server#s", 166833d4668SAlexey Kardashevskiy servers_prop, sizeof(servers_prop)); 167833d4668SAlexey Kardashevskiy if (ret < 0) { 168833d4668SAlexey Kardashevskiy return ret; 169833d4668SAlexey Kardashevskiy } 170833d4668SAlexey Kardashevskiy ret = fdt_setprop(fdt, offset, "ibm,ppc-interrupt-gserver#s", 171833d4668SAlexey Kardashevskiy gservers_prop, sizeof(gservers_prop)); 172833d4668SAlexey Kardashevskiy 173833d4668SAlexey Kardashevskiy return ret; 174833d4668SAlexey Kardashevskiy } 175833d4668SAlexey Kardashevskiy 1760da6f3feSBharata B Rao static int spapr_fixup_cpu_numa_dt(void *fdt, int offset, CPUState *cs) 1770da6f3feSBharata B Rao { 1780da6f3feSBharata B Rao int ret = 0; 1790da6f3feSBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(cs); 1800da6f3feSBharata B Rao int index = ppc_get_vcpu_dt_id(cpu); 1810da6f3feSBharata B Rao uint32_t associativity[] = {cpu_to_be32(0x5), 1820da6f3feSBharata B Rao cpu_to_be32(0x0), 1830da6f3feSBharata B Rao cpu_to_be32(0x0), 1840da6f3feSBharata B Rao cpu_to_be32(0x0), 1850da6f3feSBharata B Rao cpu_to_be32(cs->numa_node), 1860da6f3feSBharata B Rao cpu_to_be32(index)}; 1870da6f3feSBharata B Rao 1880da6f3feSBharata B Rao /* Advertise NUMA via ibm,associativity */ 1890da6f3feSBharata B Rao if (nb_numa_nodes > 1) { 1900da6f3feSBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,associativity", associativity, 1910da6f3feSBharata B Rao sizeof(associativity)); 1920da6f3feSBharata B Rao } 1930da6f3feSBharata B Rao 1940da6f3feSBharata B Rao return ret; 1950da6f3feSBharata B Rao } 1960da6f3feSBharata B Rao 19728e02042SDavid Gibson static int spapr_fixup_cpu_dt(void *fdt, sPAPRMachineState *spapr) 19853018216SPaolo Bonzini { 19982677ed2SAlexey Kardashevskiy int ret = 0, offset, cpus_offset; 20082677ed2SAlexey Kardashevskiy CPUState *cs; 20153018216SPaolo Bonzini char cpu_model[32]; 20253018216SPaolo Bonzini int smt = kvmppc_smt_threads(); 20353018216SPaolo Bonzini uint32_t pft_size_prop[] = {0, cpu_to_be32(spapr->htab_shift)}; 20453018216SPaolo Bonzini 20582677ed2SAlexey Kardashevskiy CPU_FOREACH(cs) { 20682677ed2SAlexey Kardashevskiy PowerPCCPU *cpu = POWERPC_CPU(cs); 20782677ed2SAlexey Kardashevskiy DeviceClass *dc = DEVICE_GET_CLASS(cs); 20882677ed2SAlexey Kardashevskiy int index = ppc_get_vcpu_dt_id(cpu); 20953018216SPaolo Bonzini 2100f20ba62SAlexey Kardashevskiy if ((index % smt) != 0) { 21153018216SPaolo Bonzini continue; 21253018216SPaolo Bonzini } 21353018216SPaolo Bonzini 21482677ed2SAlexey Kardashevskiy snprintf(cpu_model, 32, "%s@%x", dc->fw_name, index); 21553018216SPaolo Bonzini 21682677ed2SAlexey Kardashevskiy cpus_offset = fdt_path_offset(fdt, "/cpus"); 21782677ed2SAlexey Kardashevskiy if (cpus_offset < 0) { 21882677ed2SAlexey Kardashevskiy cpus_offset = fdt_add_subnode(fdt, fdt_path_offset(fdt, "/"), 21982677ed2SAlexey Kardashevskiy "cpus"); 22082677ed2SAlexey Kardashevskiy if (cpus_offset < 0) { 22182677ed2SAlexey Kardashevskiy return cpus_offset; 22282677ed2SAlexey Kardashevskiy } 22382677ed2SAlexey Kardashevskiy } 22482677ed2SAlexey Kardashevskiy offset = fdt_subnode_offset(fdt, cpus_offset, cpu_model); 22582677ed2SAlexey Kardashevskiy if (offset < 0) { 22682677ed2SAlexey Kardashevskiy offset = fdt_add_subnode(fdt, cpus_offset, cpu_model); 22753018216SPaolo Bonzini if (offset < 0) { 22853018216SPaolo Bonzini return offset; 22953018216SPaolo Bonzini } 23082677ed2SAlexey Kardashevskiy } 23153018216SPaolo Bonzini 2320da6f3feSBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,pft-size", 2330da6f3feSBharata B Rao pft_size_prop, sizeof(pft_size_prop)); 23453018216SPaolo Bonzini if (ret < 0) { 23553018216SPaolo Bonzini return ret; 23653018216SPaolo Bonzini } 23753018216SPaolo Bonzini 2380da6f3feSBharata B Rao ret = spapr_fixup_cpu_numa_dt(fdt, offset, cs); 23953018216SPaolo Bonzini if (ret < 0) { 24053018216SPaolo Bonzini return ret; 24153018216SPaolo Bonzini } 242833d4668SAlexey Kardashevskiy 24382677ed2SAlexey Kardashevskiy ret = spapr_fixup_cpu_smt_dt(fdt, offset, cpu, 2442a48d993SAlexey Kardashevskiy ppc_get_compat_smt_threads(cpu)); 245833d4668SAlexey Kardashevskiy if (ret < 0) { 246833d4668SAlexey Kardashevskiy return ret; 247833d4668SAlexey Kardashevskiy } 24853018216SPaolo Bonzini } 24953018216SPaolo Bonzini return ret; 25053018216SPaolo Bonzini } 25153018216SPaolo Bonzini 25253018216SPaolo Bonzini 25353018216SPaolo Bonzini static size_t create_page_sizes_prop(CPUPPCState *env, uint32_t *prop, 25453018216SPaolo Bonzini size_t maxsize) 25553018216SPaolo Bonzini { 25653018216SPaolo Bonzini size_t maxcells = maxsize / sizeof(uint32_t); 25753018216SPaolo Bonzini int i, j, count; 25853018216SPaolo Bonzini uint32_t *p = prop; 25953018216SPaolo Bonzini 26053018216SPaolo Bonzini for (i = 0; i < PPC_PAGE_SIZES_MAX_SZ; i++) { 26153018216SPaolo Bonzini struct ppc_one_seg_page_size *sps = &env->sps.sps[i]; 26253018216SPaolo Bonzini 26353018216SPaolo Bonzini if (!sps->page_shift) { 26453018216SPaolo Bonzini break; 26553018216SPaolo Bonzini } 26653018216SPaolo Bonzini for (count = 0; count < PPC_PAGE_SIZES_MAX_SZ; count++) { 26753018216SPaolo Bonzini if (sps->enc[count].page_shift == 0) { 26853018216SPaolo Bonzini break; 26953018216SPaolo Bonzini } 27053018216SPaolo Bonzini } 27153018216SPaolo Bonzini if ((p - prop) >= (maxcells - 3 - count * 2)) { 27253018216SPaolo Bonzini break; 27353018216SPaolo Bonzini } 27453018216SPaolo Bonzini *(p++) = cpu_to_be32(sps->page_shift); 27553018216SPaolo Bonzini *(p++) = cpu_to_be32(sps->slb_enc); 27653018216SPaolo Bonzini *(p++) = cpu_to_be32(count); 27753018216SPaolo Bonzini for (j = 0; j < count; j++) { 27853018216SPaolo Bonzini *(p++) = cpu_to_be32(sps->enc[j].page_shift); 27953018216SPaolo Bonzini *(p++) = cpu_to_be32(sps->enc[j].pte_enc); 28053018216SPaolo Bonzini } 28153018216SPaolo Bonzini } 28253018216SPaolo Bonzini 28353018216SPaolo Bonzini return (p - prop) * sizeof(uint32_t); 28453018216SPaolo Bonzini } 28553018216SPaolo Bonzini 286b082d65aSAlexey Kardashevskiy static hwaddr spapr_node0_size(void) 287b082d65aSAlexey Kardashevskiy { 288fb164994SDavid Gibson MachineState *machine = MACHINE(qdev_get_machine()); 289fb164994SDavid Gibson 290b082d65aSAlexey Kardashevskiy if (nb_numa_nodes) { 291b082d65aSAlexey Kardashevskiy int i; 292b082d65aSAlexey Kardashevskiy for (i = 0; i < nb_numa_nodes; ++i) { 293b082d65aSAlexey Kardashevskiy if (numa_info[i].node_mem) { 294fb164994SDavid Gibson return MIN(pow2floor(numa_info[i].node_mem), 295fb164994SDavid Gibson machine->ram_size); 296b082d65aSAlexey Kardashevskiy } 297b082d65aSAlexey Kardashevskiy } 298b082d65aSAlexey Kardashevskiy } 299fb164994SDavid Gibson return machine->ram_size; 300b082d65aSAlexey Kardashevskiy } 301b082d65aSAlexey Kardashevskiy 30253018216SPaolo Bonzini #define _FDT(exp) \ 30353018216SPaolo Bonzini do { \ 30453018216SPaolo Bonzini int ret = (exp); \ 30553018216SPaolo Bonzini if (ret < 0) { \ 30653018216SPaolo Bonzini fprintf(stderr, "qemu: error creating device tree: %s: %s\n", \ 30753018216SPaolo Bonzini #exp, fdt_strerror(ret)); \ 30853018216SPaolo Bonzini exit(1); \ 30953018216SPaolo Bonzini } \ 31053018216SPaolo Bonzini } while (0) 31153018216SPaolo Bonzini 312a1d59c0fSAlexey Kardashevskiy static void add_str(GString *s, const gchar *s1) 313a1d59c0fSAlexey Kardashevskiy { 314a1d59c0fSAlexey Kardashevskiy g_string_append_len(s, s1, strlen(s1) + 1); 315a1d59c0fSAlexey Kardashevskiy } 31653018216SPaolo Bonzini 3173bbf37f2SAndreas Färber static void *spapr_create_fdt_skel(hwaddr initrd_base, 31853018216SPaolo Bonzini hwaddr initrd_size, 31953018216SPaolo Bonzini hwaddr kernel_size, 32016457e7fSBenjamin Herrenschmidt bool little_endian, 32153018216SPaolo Bonzini const char *kernel_cmdline, 32253018216SPaolo Bonzini uint32_t epow_irq) 32353018216SPaolo Bonzini { 32453018216SPaolo Bonzini void *fdt; 32553018216SPaolo Bonzini uint32_t start_prop = cpu_to_be32(initrd_base); 32653018216SPaolo Bonzini uint32_t end_prop = cpu_to_be32(initrd_base + initrd_size); 327a1d59c0fSAlexey Kardashevskiy GString *hypertas = g_string_sized_new(256); 328a1d59c0fSAlexey Kardashevskiy GString *qemu_hypertas = g_string_sized_new(256); 32953018216SPaolo Bonzini uint32_t refpoints[] = {cpu_to_be32(0x4), cpu_to_be32(0x4)}; 3309e734e3dSBharata B Rao uint32_t interrupt_server_ranges_prop[] = {0, cpu_to_be32(max_cpus)}; 33153018216SPaolo Bonzini unsigned char vec5[] = {0x0, 0x0, 0x0, 0x0, 0x0, 0x80}; 332ef951443SNikunj A Dadhania char *buf; 33353018216SPaolo Bonzini 334a1d59c0fSAlexey Kardashevskiy add_str(hypertas, "hcall-pft"); 335a1d59c0fSAlexey Kardashevskiy add_str(hypertas, "hcall-term"); 336a1d59c0fSAlexey Kardashevskiy add_str(hypertas, "hcall-dabr"); 337a1d59c0fSAlexey Kardashevskiy add_str(hypertas, "hcall-interrupt"); 338a1d59c0fSAlexey Kardashevskiy add_str(hypertas, "hcall-tce"); 339a1d59c0fSAlexey Kardashevskiy add_str(hypertas, "hcall-vio"); 340a1d59c0fSAlexey Kardashevskiy add_str(hypertas, "hcall-splpar"); 341a1d59c0fSAlexey Kardashevskiy add_str(hypertas, "hcall-bulk"); 342a1d59c0fSAlexey Kardashevskiy add_str(hypertas, "hcall-set-mode"); 3436cc09e26SThomas Huth add_str(hypertas, "hcall-sprg0"); 3446cc09e26SThomas Huth add_str(hypertas, "hcall-copy"); 3456cc09e26SThomas Huth add_str(hypertas, "hcall-debug"); 346a1d59c0fSAlexey Kardashevskiy add_str(qemu_hypertas, "hcall-memop1"); 347a1d59c0fSAlexey Kardashevskiy 34853018216SPaolo Bonzini fdt = g_malloc0(FDT_MAX_SIZE); 34953018216SPaolo Bonzini _FDT((fdt_create(fdt, FDT_MAX_SIZE))); 35053018216SPaolo Bonzini 35153018216SPaolo Bonzini if (kernel_size) { 35253018216SPaolo Bonzini _FDT((fdt_add_reservemap_entry(fdt, KERNEL_LOAD_ADDR, kernel_size))); 35353018216SPaolo Bonzini } 35453018216SPaolo Bonzini if (initrd_size) { 35553018216SPaolo Bonzini _FDT((fdt_add_reservemap_entry(fdt, initrd_base, initrd_size))); 35653018216SPaolo Bonzini } 35753018216SPaolo Bonzini _FDT((fdt_finish_reservemap(fdt))); 35853018216SPaolo Bonzini 35953018216SPaolo Bonzini /* Root node */ 36053018216SPaolo Bonzini _FDT((fdt_begin_node(fdt, ""))); 36153018216SPaolo Bonzini _FDT((fdt_property_string(fdt, "device_type", "chrp"))); 36253018216SPaolo Bonzini _FDT((fdt_property_string(fdt, "model", "IBM pSeries (emulated by qemu)"))); 363fa388916SAnthony Liguori _FDT((fdt_property_string(fdt, "compatible", "qemu,pseries"))); 36453018216SPaolo Bonzini 365ef951443SNikunj A Dadhania /* 366ef951443SNikunj A Dadhania * Add info to guest to indentify which host is it being run on 367ef951443SNikunj A Dadhania * and what is the uuid of the guest 368ef951443SNikunj A Dadhania */ 369ef951443SNikunj A Dadhania if (kvmppc_get_host_model(&buf)) { 370ef951443SNikunj A Dadhania _FDT((fdt_property_string(fdt, "host-model", buf))); 371ef951443SNikunj A Dadhania g_free(buf); 372ef951443SNikunj A Dadhania } 373ef951443SNikunj A Dadhania if (kvmppc_get_host_serial(&buf)) { 374ef951443SNikunj A Dadhania _FDT((fdt_property_string(fdt, "host-serial", buf))); 375ef951443SNikunj A Dadhania g_free(buf); 376ef951443SNikunj A Dadhania } 377ef951443SNikunj A Dadhania 378ef951443SNikunj A Dadhania buf = g_strdup_printf(UUID_FMT, qemu_uuid[0], qemu_uuid[1], 379ef951443SNikunj A Dadhania qemu_uuid[2], qemu_uuid[3], qemu_uuid[4], 380ef951443SNikunj A Dadhania qemu_uuid[5], qemu_uuid[6], qemu_uuid[7], 381ef951443SNikunj A Dadhania qemu_uuid[8], qemu_uuid[9], qemu_uuid[10], 382ef951443SNikunj A Dadhania qemu_uuid[11], qemu_uuid[12], qemu_uuid[13], 383ef951443SNikunj A Dadhania qemu_uuid[14], qemu_uuid[15]); 384ef951443SNikunj A Dadhania 385ef951443SNikunj A Dadhania _FDT((fdt_property_string(fdt, "vm,uuid", buf))); 3863dc0a66dSAlexey Kardashevskiy if (qemu_uuid_set) { 3873dc0a66dSAlexey Kardashevskiy _FDT((fdt_property_string(fdt, "system-id", buf))); 3883dc0a66dSAlexey Kardashevskiy } 389ef951443SNikunj A Dadhania g_free(buf); 390ef951443SNikunj A Dadhania 3912c1aaa81SSam Bobroff if (qemu_get_vm_name()) { 3922c1aaa81SSam Bobroff _FDT((fdt_property_string(fdt, "ibm,partition-name", 3932c1aaa81SSam Bobroff qemu_get_vm_name()))); 3942c1aaa81SSam Bobroff } 3952c1aaa81SSam Bobroff 39653018216SPaolo Bonzini _FDT((fdt_property_cell(fdt, "#address-cells", 0x2))); 39753018216SPaolo Bonzini _FDT((fdt_property_cell(fdt, "#size-cells", 0x2))); 39853018216SPaolo Bonzini 39953018216SPaolo Bonzini /* /chosen */ 40053018216SPaolo Bonzini _FDT((fdt_begin_node(fdt, "chosen"))); 40153018216SPaolo Bonzini 40253018216SPaolo Bonzini /* Set Form1_affinity */ 40353018216SPaolo Bonzini _FDT((fdt_property(fdt, "ibm,architecture-vec-5", vec5, sizeof(vec5)))); 40453018216SPaolo Bonzini 40553018216SPaolo Bonzini _FDT((fdt_property_string(fdt, "bootargs", kernel_cmdline))); 40653018216SPaolo Bonzini _FDT((fdt_property(fdt, "linux,initrd-start", 40753018216SPaolo Bonzini &start_prop, sizeof(start_prop)))); 40853018216SPaolo Bonzini _FDT((fdt_property(fdt, "linux,initrd-end", 40953018216SPaolo Bonzini &end_prop, sizeof(end_prop)))); 41053018216SPaolo Bonzini if (kernel_size) { 41153018216SPaolo Bonzini uint64_t kprop[2] = { cpu_to_be64(KERNEL_LOAD_ADDR), 41253018216SPaolo Bonzini cpu_to_be64(kernel_size) }; 41353018216SPaolo Bonzini 41453018216SPaolo Bonzini _FDT((fdt_property(fdt, "qemu,boot-kernel", &kprop, sizeof(kprop)))); 41516457e7fSBenjamin Herrenschmidt if (little_endian) { 41616457e7fSBenjamin Herrenschmidt _FDT((fdt_property(fdt, "qemu,boot-kernel-le", NULL, 0))); 41716457e7fSBenjamin Herrenschmidt } 41853018216SPaolo Bonzini } 419cc84c0f3SAvik Sil if (boot_menu) { 420cc84c0f3SAvik Sil _FDT((fdt_property_cell(fdt, "qemu,boot-menu", boot_menu))); 421cc84c0f3SAvik Sil } 42253018216SPaolo Bonzini _FDT((fdt_property_cell(fdt, "qemu,graphic-width", graphic_width))); 42353018216SPaolo Bonzini _FDT((fdt_property_cell(fdt, "qemu,graphic-height", graphic_height))); 42453018216SPaolo Bonzini _FDT((fdt_property_cell(fdt, "qemu,graphic-depth", graphic_depth))); 42553018216SPaolo Bonzini 42653018216SPaolo Bonzini _FDT((fdt_end_node(fdt))); 42753018216SPaolo Bonzini 42853018216SPaolo Bonzini /* RTAS */ 42953018216SPaolo Bonzini _FDT((fdt_begin_node(fdt, "rtas"))); 43053018216SPaolo Bonzini 431da95324eSAlexey Kardashevskiy if (!kvm_enabled() || kvmppc_spapr_use_multitce()) { 432da95324eSAlexey Kardashevskiy add_str(hypertas, "hcall-multi-tce"); 433da95324eSAlexey Kardashevskiy } 434a1d59c0fSAlexey Kardashevskiy _FDT((fdt_property(fdt, "ibm,hypertas-functions", hypertas->str, 435a1d59c0fSAlexey Kardashevskiy hypertas->len))); 436a1d59c0fSAlexey Kardashevskiy g_string_free(hypertas, TRUE); 437a1d59c0fSAlexey Kardashevskiy _FDT((fdt_property(fdt, "qemu,hypertas-functions", qemu_hypertas->str, 438a1d59c0fSAlexey Kardashevskiy qemu_hypertas->len))); 439a1d59c0fSAlexey Kardashevskiy g_string_free(qemu_hypertas, TRUE); 44053018216SPaolo Bonzini 44153018216SPaolo Bonzini _FDT((fdt_property(fdt, "ibm,associativity-reference-points", 44253018216SPaolo Bonzini refpoints, sizeof(refpoints)))); 44353018216SPaolo Bonzini 44453018216SPaolo Bonzini _FDT((fdt_property_cell(fdt, "rtas-error-log-max", RTAS_ERROR_LOG_MAX))); 44579853e18STyrel Datwyler _FDT((fdt_property_cell(fdt, "rtas-event-scan-rate", 44679853e18STyrel Datwyler RTAS_EVENT_SCAN_RATE))); 44753018216SPaolo Bonzini 448226419d6SMichael S. Tsirkin if (msi_nonbroken) { 449a95f9922SSam Bobroff _FDT((fdt_property(fdt, "ibm,change-msix-capable", NULL, 0))); 450a95f9922SSam Bobroff } 451a95f9922SSam Bobroff 4522e14072fSNikunj A Dadhania /* 4539d632f5fSzhanghailiang * According to PAPR, rtas ibm,os-term does not guarantee a return 4542e14072fSNikunj A Dadhania * back to the guest cpu. 4552e14072fSNikunj A Dadhania * 4562e14072fSNikunj A Dadhania * While an additional ibm,extended-os-term property indicates that 4572e14072fSNikunj A Dadhania * rtas call return will always occur. Set this property. 4582e14072fSNikunj A Dadhania */ 4592e14072fSNikunj A Dadhania _FDT((fdt_property(fdt, "ibm,extended-os-term", NULL, 0))); 4602e14072fSNikunj A Dadhania 46153018216SPaolo Bonzini _FDT((fdt_end_node(fdt))); 46253018216SPaolo Bonzini 46353018216SPaolo Bonzini /* interrupt controller */ 46453018216SPaolo Bonzini _FDT((fdt_begin_node(fdt, "interrupt-controller"))); 46553018216SPaolo Bonzini 46653018216SPaolo Bonzini _FDT((fdt_property_string(fdt, "device_type", 46753018216SPaolo Bonzini "PowerPC-External-Interrupt-Presentation"))); 46853018216SPaolo Bonzini _FDT((fdt_property_string(fdt, "compatible", "IBM,ppc-xicp"))); 46953018216SPaolo Bonzini _FDT((fdt_property(fdt, "interrupt-controller", NULL, 0))); 47053018216SPaolo Bonzini _FDT((fdt_property(fdt, "ibm,interrupt-server-ranges", 47153018216SPaolo Bonzini interrupt_server_ranges_prop, 47253018216SPaolo Bonzini sizeof(interrupt_server_ranges_prop)))); 47353018216SPaolo Bonzini _FDT((fdt_property_cell(fdt, "#interrupt-cells", 2))); 47453018216SPaolo Bonzini _FDT((fdt_property_cell(fdt, "linux,phandle", PHANDLE_XICP))); 47553018216SPaolo Bonzini _FDT((fdt_property_cell(fdt, "phandle", PHANDLE_XICP))); 47653018216SPaolo Bonzini 47753018216SPaolo Bonzini _FDT((fdt_end_node(fdt))); 47853018216SPaolo Bonzini 47953018216SPaolo Bonzini /* vdevice */ 48053018216SPaolo Bonzini _FDT((fdt_begin_node(fdt, "vdevice"))); 48153018216SPaolo Bonzini 48253018216SPaolo Bonzini _FDT((fdt_property_string(fdt, "device_type", "vdevice"))); 48353018216SPaolo Bonzini _FDT((fdt_property_string(fdt, "compatible", "IBM,vdevice"))); 48453018216SPaolo Bonzini _FDT((fdt_property_cell(fdt, "#address-cells", 0x1))); 48553018216SPaolo Bonzini _FDT((fdt_property_cell(fdt, "#size-cells", 0x0))); 48653018216SPaolo Bonzini _FDT((fdt_property_cell(fdt, "#interrupt-cells", 0x2))); 48753018216SPaolo Bonzini _FDT((fdt_property(fdt, "interrupt-controller", NULL, 0))); 48853018216SPaolo Bonzini 48953018216SPaolo Bonzini _FDT((fdt_end_node(fdt))); 49053018216SPaolo Bonzini 49153018216SPaolo Bonzini /* event-sources */ 49253018216SPaolo Bonzini spapr_events_fdt_skel(fdt, epow_irq); 49353018216SPaolo Bonzini 494f7d69146SAlexander Graf /* /hypervisor node */ 495f7d69146SAlexander Graf if (kvm_enabled()) { 496f7d69146SAlexander Graf uint8_t hypercall[16]; 497f7d69146SAlexander Graf 498f7d69146SAlexander Graf /* indicate KVM hypercall interface */ 499f7d69146SAlexander Graf _FDT((fdt_begin_node(fdt, "hypervisor"))); 500f7d69146SAlexander Graf _FDT((fdt_property_string(fdt, "compatible", "linux,kvm"))); 501f7d69146SAlexander Graf if (kvmppc_has_cap_fixup_hcalls()) { 502f7d69146SAlexander Graf /* 503f7d69146SAlexander Graf * Older KVM versions with older guest kernels were broken with the 504f7d69146SAlexander Graf * magic page, don't allow the guest to map it. 505f7d69146SAlexander Graf */ 5060ddbd053SAlexey Kardashevskiy if (!kvmppc_get_hypercall(first_cpu->env_ptr, hypercall, 5070ddbd053SAlexey Kardashevskiy sizeof(hypercall))) { 508f7d69146SAlexander Graf _FDT((fdt_property(fdt, "hcall-instructions", hypercall, 509f7d69146SAlexander Graf sizeof(hypercall)))); 510f7d69146SAlexander Graf } 5110ddbd053SAlexey Kardashevskiy } 512f7d69146SAlexander Graf _FDT((fdt_end_node(fdt))); 513f7d69146SAlexander Graf } 514f7d69146SAlexander Graf 51553018216SPaolo Bonzini _FDT((fdt_end_node(fdt))); /* close root node */ 51653018216SPaolo Bonzini _FDT((fdt_finish(fdt))); 51753018216SPaolo Bonzini 51853018216SPaolo Bonzini return fdt; 51953018216SPaolo Bonzini } 52053018216SPaolo Bonzini 52103d196b7SBharata B Rao static int spapr_populate_memory_node(void *fdt, int nodeid, hwaddr start, 52226a8c353SAlexey Kardashevskiy hwaddr size) 52326a8c353SAlexey Kardashevskiy { 52426a8c353SAlexey Kardashevskiy uint32_t associativity[] = { 52526a8c353SAlexey Kardashevskiy cpu_to_be32(0x4), /* length */ 52626a8c353SAlexey Kardashevskiy cpu_to_be32(0x0), cpu_to_be32(0x0), 527c3b4f589SAlexey Kardashevskiy cpu_to_be32(0x0), cpu_to_be32(nodeid) 52826a8c353SAlexey Kardashevskiy }; 52926a8c353SAlexey Kardashevskiy char mem_name[32]; 53026a8c353SAlexey Kardashevskiy uint64_t mem_reg_property[2]; 53126a8c353SAlexey Kardashevskiy int off; 53226a8c353SAlexey Kardashevskiy 53326a8c353SAlexey Kardashevskiy mem_reg_property[0] = cpu_to_be64(start); 53426a8c353SAlexey Kardashevskiy mem_reg_property[1] = cpu_to_be64(size); 53526a8c353SAlexey Kardashevskiy 53626a8c353SAlexey Kardashevskiy sprintf(mem_name, "memory@" TARGET_FMT_lx, start); 53726a8c353SAlexey Kardashevskiy off = fdt_add_subnode(fdt, 0, mem_name); 53826a8c353SAlexey Kardashevskiy _FDT(off); 53926a8c353SAlexey Kardashevskiy _FDT((fdt_setprop_string(fdt, off, "device_type", "memory"))); 54026a8c353SAlexey Kardashevskiy _FDT((fdt_setprop(fdt, off, "reg", mem_reg_property, 54126a8c353SAlexey Kardashevskiy sizeof(mem_reg_property)))); 54226a8c353SAlexey Kardashevskiy _FDT((fdt_setprop(fdt, off, "ibm,associativity", associativity, 54326a8c353SAlexey Kardashevskiy sizeof(associativity)))); 54403d196b7SBharata B Rao return off; 54526a8c353SAlexey Kardashevskiy } 54626a8c353SAlexey Kardashevskiy 54728e02042SDavid Gibson static int spapr_populate_memory(sPAPRMachineState *spapr, void *fdt) 54853018216SPaolo Bonzini { 549fb164994SDavid Gibson MachineState *machine = MACHINE(spapr); 5507db8a127SAlexey Kardashevskiy hwaddr mem_start, node_size; 5517db8a127SAlexey Kardashevskiy int i, nb_nodes = nb_numa_nodes; 5527db8a127SAlexey Kardashevskiy NodeInfo *nodes = numa_info; 5537db8a127SAlexey Kardashevskiy NodeInfo ramnode; 55453018216SPaolo Bonzini 5557db8a127SAlexey Kardashevskiy /* No NUMA nodes, assume there is just one node with whole RAM */ 5567db8a127SAlexey Kardashevskiy if (!nb_numa_nodes) { 5577db8a127SAlexey Kardashevskiy nb_nodes = 1; 558fb164994SDavid Gibson ramnode.node_mem = machine->ram_size; 5597db8a127SAlexey Kardashevskiy nodes = &ramnode; 5605fe269b1SPaul Mackerras } 56153018216SPaolo Bonzini 5627db8a127SAlexey Kardashevskiy for (i = 0, mem_start = 0; i < nb_nodes; ++i) { 5637db8a127SAlexey Kardashevskiy if (!nodes[i].node_mem) { 5647db8a127SAlexey Kardashevskiy continue; 56553018216SPaolo Bonzini } 566fb164994SDavid Gibson if (mem_start >= machine->ram_size) { 5675fe269b1SPaul Mackerras node_size = 0; 5685fe269b1SPaul Mackerras } else { 5697db8a127SAlexey Kardashevskiy node_size = nodes[i].node_mem; 570fb164994SDavid Gibson if (node_size > machine->ram_size - mem_start) { 571fb164994SDavid Gibson node_size = machine->ram_size - mem_start; 5725fe269b1SPaul Mackerras } 5735fe269b1SPaul Mackerras } 5747db8a127SAlexey Kardashevskiy if (!mem_start) { 5757db8a127SAlexey Kardashevskiy /* ppc_spapr_init() checks for rma_size <= node0_size already */ 576e8f986fcSBharata B Rao spapr_populate_memory_node(fdt, i, 0, spapr->rma_size); 5777db8a127SAlexey Kardashevskiy mem_start += spapr->rma_size; 5787db8a127SAlexey Kardashevskiy node_size -= spapr->rma_size; 5797db8a127SAlexey Kardashevskiy } 5806010818cSAlexey Kardashevskiy for ( ; node_size; ) { 5816010818cSAlexey Kardashevskiy hwaddr sizetmp = pow2floor(node_size); 5826010818cSAlexey Kardashevskiy 5836010818cSAlexey Kardashevskiy /* mem_start != 0 here */ 5846010818cSAlexey Kardashevskiy if (ctzl(mem_start) < ctzl(sizetmp)) { 5856010818cSAlexey Kardashevskiy sizetmp = 1ULL << ctzl(mem_start); 5866010818cSAlexey Kardashevskiy } 5876010818cSAlexey Kardashevskiy 5886010818cSAlexey Kardashevskiy spapr_populate_memory_node(fdt, i, mem_start, sizetmp); 5896010818cSAlexey Kardashevskiy node_size -= sizetmp; 5906010818cSAlexey Kardashevskiy mem_start += sizetmp; 5916010818cSAlexey Kardashevskiy } 59253018216SPaolo Bonzini } 59353018216SPaolo Bonzini 59453018216SPaolo Bonzini return 0; 59553018216SPaolo Bonzini } 59653018216SPaolo Bonzini 5970da6f3feSBharata B Rao static void spapr_populate_cpu_dt(CPUState *cs, void *fdt, int offset, 5980da6f3feSBharata B Rao sPAPRMachineState *spapr) 5990da6f3feSBharata B Rao { 6000da6f3feSBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(cs); 6010da6f3feSBharata B Rao CPUPPCState *env = &cpu->env; 6020da6f3feSBharata B Rao PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(cs); 6030da6f3feSBharata B Rao int index = ppc_get_vcpu_dt_id(cpu); 6040da6f3feSBharata B Rao uint32_t segs[] = {cpu_to_be32(28), cpu_to_be32(40), 6050da6f3feSBharata B Rao 0xffffffff, 0xffffffff}; 606afd10a0fSBharata B Rao uint32_t tbfreq = kvm_enabled() ? kvmppc_get_tbfreq() 607afd10a0fSBharata B Rao : SPAPR_TIMEBASE_FREQ; 6080da6f3feSBharata B Rao uint32_t cpufreq = kvm_enabled() ? kvmppc_get_clockfreq() : 1000000000; 6090da6f3feSBharata B Rao uint32_t page_sizes_prop[64]; 6100da6f3feSBharata B Rao size_t page_sizes_prop_size; 61122419c2aSDavid Gibson uint32_t vcpus_per_socket = smp_threads * smp_cores; 6120da6f3feSBharata B Rao uint32_t pft_size_prop[] = {0, cpu_to_be32(spapr->htab_shift)}; 613af81cf32SBharata B Rao sPAPRDRConnector *drc; 614af81cf32SBharata B Rao sPAPRDRConnectorClass *drck; 615af81cf32SBharata B Rao int drc_index; 616af81cf32SBharata B Rao 617af81cf32SBharata B Rao drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_CPU, index); 618af81cf32SBharata B Rao if (drc) { 619af81cf32SBharata B Rao drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 620af81cf32SBharata B Rao drc_index = drck->get_index(drc); 621af81cf32SBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,my-drc-index", drc_index))); 622af81cf32SBharata B Rao } 6230da6f3feSBharata B Rao 62490da0d5aSBenjamin Herrenschmidt /* Note: we keep CI large pages off for now because a 64K capable guest 62590da0d5aSBenjamin Herrenschmidt * provisioned with large pages might otherwise try to map a qemu 62690da0d5aSBenjamin Herrenschmidt * framebuffer (or other kind of memory mapped PCI BAR) using 64K pages 62790da0d5aSBenjamin Herrenschmidt * even if that qemu runs on a 4k host. 62890da0d5aSBenjamin Herrenschmidt * 62990da0d5aSBenjamin Herrenschmidt * We can later add this bit back when we are confident this is not 63090da0d5aSBenjamin Herrenschmidt * an issue (!HV KVM or 64K host) 63190da0d5aSBenjamin Herrenschmidt */ 63290da0d5aSBenjamin Herrenschmidt uint8_t pa_features_206[] = { 6, 0, 63390da0d5aSBenjamin Herrenschmidt 0xf6, 0x1f, 0xc7, 0x00, 0x80, 0xc0 }; 63490da0d5aSBenjamin Herrenschmidt uint8_t pa_features_207[] = { 24, 0, 63590da0d5aSBenjamin Herrenschmidt 0xf6, 0x1f, 0xc7, 0xc0, 0x80, 0xf0, 63690da0d5aSBenjamin Herrenschmidt 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 63790da0d5aSBenjamin Herrenschmidt 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 63890da0d5aSBenjamin Herrenschmidt 0x80, 0x00, 0x80, 0x00, 0x80, 0x00 }; 63990da0d5aSBenjamin Herrenschmidt uint8_t *pa_features; 64090da0d5aSBenjamin Herrenschmidt size_t pa_size; 64190da0d5aSBenjamin Herrenschmidt 6420da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "reg", index))); 6430da6f3feSBharata B Rao _FDT((fdt_setprop_string(fdt, offset, "device_type", "cpu"))); 6440da6f3feSBharata B Rao 6450da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "cpu-version", env->spr[SPR_PVR]))); 6460da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "d-cache-block-size", 6470da6f3feSBharata B Rao env->dcache_line_size))); 6480da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "d-cache-line-size", 6490da6f3feSBharata B Rao env->dcache_line_size))); 6500da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "i-cache-block-size", 6510da6f3feSBharata B Rao env->icache_line_size))); 6520da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "i-cache-line-size", 6530da6f3feSBharata B Rao env->icache_line_size))); 6540da6f3feSBharata B Rao 6550da6f3feSBharata B Rao if (pcc->l1_dcache_size) { 6560da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "d-cache-size", 6570da6f3feSBharata B Rao pcc->l1_dcache_size))); 6580da6f3feSBharata B Rao } else { 6590da6f3feSBharata B Rao fprintf(stderr, "Warning: Unknown L1 dcache size for cpu\n"); 6600da6f3feSBharata B Rao } 6610da6f3feSBharata B Rao if (pcc->l1_icache_size) { 6620da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "i-cache-size", 6630da6f3feSBharata B Rao pcc->l1_icache_size))); 6640da6f3feSBharata B Rao } else { 6650da6f3feSBharata B Rao fprintf(stderr, "Warning: Unknown L1 icache size for cpu\n"); 6660da6f3feSBharata B Rao } 6670da6f3feSBharata B Rao 6680da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "timebase-frequency", tbfreq))); 6690da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "clock-frequency", cpufreq))); 670fd5da5c4SThomas Huth _FDT((fdt_setprop_cell(fdt, offset, "slb-size", env->slb_nr))); 6710da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,slb-size", env->slb_nr))); 6720da6f3feSBharata B Rao _FDT((fdt_setprop_string(fdt, offset, "status", "okay"))); 6730da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "64-bit", NULL, 0))); 6740da6f3feSBharata B Rao 6750da6f3feSBharata B Rao if (env->spr_cb[SPR_PURR].oea_read) { 6760da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,purr", NULL, 0))); 6770da6f3feSBharata B Rao } 6780da6f3feSBharata B Rao 6790da6f3feSBharata B Rao if (env->mmu_model & POWERPC_MMU_1TSEG) { 6800da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,processor-segment-sizes", 6810da6f3feSBharata B Rao segs, sizeof(segs)))); 6820da6f3feSBharata B Rao } 6830da6f3feSBharata B Rao 6840da6f3feSBharata B Rao /* Advertise VMX/VSX (vector extensions) if available 6850da6f3feSBharata B Rao * 0 / no property == no vector extensions 6860da6f3feSBharata B Rao * 1 == VMX / Altivec available 6870da6f3feSBharata B Rao * 2 == VSX available */ 6880da6f3feSBharata B Rao if (env->insns_flags & PPC_ALTIVEC) { 6890da6f3feSBharata B Rao uint32_t vmx = (env->insns_flags2 & PPC2_VSX) ? 2 : 1; 6900da6f3feSBharata B Rao 6910da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,vmx", vmx))); 6920da6f3feSBharata B Rao } 6930da6f3feSBharata B Rao 6940da6f3feSBharata B Rao /* Advertise DFP (Decimal Floating Point) if available 6950da6f3feSBharata B Rao * 0 / no property == no DFP 6960da6f3feSBharata B Rao * 1 == DFP available */ 6970da6f3feSBharata B Rao if (env->insns_flags2 & PPC2_DFP) { 6980da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,dfp", 1))); 6990da6f3feSBharata B Rao } 7000da6f3feSBharata B Rao 7010da6f3feSBharata B Rao page_sizes_prop_size = create_page_sizes_prop(env, page_sizes_prop, 7020da6f3feSBharata B Rao sizeof(page_sizes_prop)); 7030da6f3feSBharata B Rao if (page_sizes_prop_size) { 7040da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,segment-page-sizes", 7050da6f3feSBharata B Rao page_sizes_prop, page_sizes_prop_size))); 7060da6f3feSBharata B Rao } 7070da6f3feSBharata B Rao 70890da0d5aSBenjamin Herrenschmidt /* Do the ibm,pa-features property, adjust it for ci-large-pages */ 70990da0d5aSBenjamin Herrenschmidt if (env->mmu_model == POWERPC_MMU_2_06) { 71090da0d5aSBenjamin Herrenschmidt pa_features = pa_features_206; 71190da0d5aSBenjamin Herrenschmidt pa_size = sizeof(pa_features_206); 71290da0d5aSBenjamin Herrenschmidt } else /* env->mmu_model == POWERPC_MMU_2_07 */ { 71390da0d5aSBenjamin Herrenschmidt pa_features = pa_features_207; 71490da0d5aSBenjamin Herrenschmidt pa_size = sizeof(pa_features_207); 71590da0d5aSBenjamin Herrenschmidt } 71690da0d5aSBenjamin Herrenschmidt if (env->ci_large_pages) { 71790da0d5aSBenjamin Herrenschmidt pa_features[3] |= 0x20; 71890da0d5aSBenjamin Herrenschmidt } 71990da0d5aSBenjamin Herrenschmidt _FDT((fdt_setprop(fdt, offset, "ibm,pa-features", pa_features, pa_size))); 72090da0d5aSBenjamin Herrenschmidt 7210da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,chip-id", 72222419c2aSDavid Gibson cs->cpu_index / vcpus_per_socket))); 7230da6f3feSBharata B Rao 7240da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,pft-size", 7250da6f3feSBharata B Rao pft_size_prop, sizeof(pft_size_prop)))); 7260da6f3feSBharata B Rao 7270da6f3feSBharata B Rao _FDT(spapr_fixup_cpu_numa_dt(fdt, offset, cs)); 7280da6f3feSBharata B Rao 7290da6f3feSBharata B Rao _FDT(spapr_fixup_cpu_smt_dt(fdt, offset, cpu, 7300da6f3feSBharata B Rao ppc_get_compat_smt_threads(cpu))); 7310da6f3feSBharata B Rao } 7320da6f3feSBharata B Rao 7330da6f3feSBharata B Rao static void spapr_populate_cpus_dt_node(void *fdt, sPAPRMachineState *spapr) 7340da6f3feSBharata B Rao { 7350da6f3feSBharata B Rao CPUState *cs; 7360da6f3feSBharata B Rao int cpus_offset; 7370da6f3feSBharata B Rao char *nodename; 7380da6f3feSBharata B Rao int smt = kvmppc_smt_threads(); 7390da6f3feSBharata B Rao 7400da6f3feSBharata B Rao cpus_offset = fdt_add_subnode(fdt, 0, "cpus"); 7410da6f3feSBharata B Rao _FDT(cpus_offset); 7420da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, cpus_offset, "#address-cells", 0x1))); 7430da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, cpus_offset, "#size-cells", 0x0))); 7440da6f3feSBharata B Rao 7450da6f3feSBharata B Rao /* 7460da6f3feSBharata B Rao * We walk the CPUs in reverse order to ensure that CPU DT nodes 7470da6f3feSBharata B Rao * created by fdt_add_subnode() end up in the right order in FDT 7480da6f3feSBharata B Rao * for the guest kernel the enumerate the CPUs correctly. 7490da6f3feSBharata B Rao */ 7500da6f3feSBharata B Rao CPU_FOREACH_REVERSE(cs) { 7510da6f3feSBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(cs); 7520da6f3feSBharata B Rao int index = ppc_get_vcpu_dt_id(cpu); 7530da6f3feSBharata B Rao DeviceClass *dc = DEVICE_GET_CLASS(cs); 7540da6f3feSBharata B Rao int offset; 7550da6f3feSBharata B Rao 7560da6f3feSBharata B Rao if ((index % smt) != 0) { 7570da6f3feSBharata B Rao continue; 7580da6f3feSBharata B Rao } 7590da6f3feSBharata B Rao 7600da6f3feSBharata B Rao nodename = g_strdup_printf("%s@%x", dc->fw_name, index); 7610da6f3feSBharata B Rao offset = fdt_add_subnode(fdt, cpus_offset, nodename); 7620da6f3feSBharata B Rao g_free(nodename); 7630da6f3feSBharata B Rao _FDT(offset); 7640da6f3feSBharata B Rao spapr_populate_cpu_dt(cs, fdt, offset, spapr); 7650da6f3feSBharata B Rao } 7660da6f3feSBharata B Rao 7670da6f3feSBharata B Rao } 7680da6f3feSBharata B Rao 76903d196b7SBharata B Rao /* 77003d196b7SBharata B Rao * Adds ibm,dynamic-reconfiguration-memory node. 77103d196b7SBharata B Rao * Refer to docs/specs/ppc-spapr-hotplug.txt for the documentation 77203d196b7SBharata B Rao * of this device tree node. 77303d196b7SBharata B Rao */ 77403d196b7SBharata B Rao static int spapr_populate_drconf_memory(sPAPRMachineState *spapr, void *fdt) 77503d196b7SBharata B Rao { 77603d196b7SBharata B Rao MachineState *machine = MACHINE(spapr); 77703d196b7SBharata B Rao int ret, i, offset; 77803d196b7SBharata B Rao uint64_t lmb_size = SPAPR_MEMORY_BLOCK_SIZE; 77903d196b7SBharata B Rao uint32_t prop_lmb_size[] = {0, cpu_to_be32(lmb_size)}; 780d0e5a8f2SBharata B Rao uint32_t hotplug_lmb_start = spapr->hotplug_memory.base / lmb_size; 781d0e5a8f2SBharata B Rao uint32_t nr_lmbs = (spapr->hotplug_memory.base + 782d0e5a8f2SBharata B Rao memory_region_size(&spapr->hotplug_memory.mr)) / 783d0e5a8f2SBharata B Rao lmb_size; 78403d196b7SBharata B Rao uint32_t *int_buf, *cur_index, buf_len; 7856663864eSBharata B Rao int nr_nodes = nb_numa_nodes ? nb_numa_nodes : 1; 78603d196b7SBharata B Rao 787ef001f06SThomas Huth /* 788d0e5a8f2SBharata B Rao * Don't create the node if there is no hotpluggable memory 78916c25aefSBharata B Rao */ 790d0e5a8f2SBharata B Rao if (machine->ram_size == machine->maxram_size) { 79116c25aefSBharata B Rao return 0; 79216c25aefSBharata B Rao } 79316c25aefSBharata B Rao 79416c25aefSBharata B Rao /* 795ef001f06SThomas Huth * Allocate enough buffer size to fit in ibm,dynamic-memory 796ef001f06SThomas Huth * or ibm,associativity-lookup-arrays 797ef001f06SThomas Huth */ 798ef001f06SThomas Huth buf_len = MAX(nr_lmbs * SPAPR_DR_LMB_LIST_ENTRY_SIZE + 1, nr_nodes * 4 + 2) 799ef001f06SThomas Huth * sizeof(uint32_t); 80003d196b7SBharata B Rao cur_index = int_buf = g_malloc0(buf_len); 80103d196b7SBharata B Rao 80203d196b7SBharata B Rao offset = fdt_add_subnode(fdt, 0, "ibm,dynamic-reconfiguration-memory"); 80303d196b7SBharata B Rao 80403d196b7SBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,lmb-size", prop_lmb_size, 80503d196b7SBharata B Rao sizeof(prop_lmb_size)); 80603d196b7SBharata B Rao if (ret < 0) { 80703d196b7SBharata B Rao goto out; 80803d196b7SBharata B Rao } 80903d196b7SBharata B Rao 81003d196b7SBharata B Rao ret = fdt_setprop_cell(fdt, offset, "ibm,memory-flags-mask", 0xff); 81103d196b7SBharata B Rao if (ret < 0) { 81203d196b7SBharata B Rao goto out; 81303d196b7SBharata B Rao } 81403d196b7SBharata B Rao 81503d196b7SBharata B Rao ret = fdt_setprop_cell(fdt, offset, "ibm,memory-preservation-time", 0x0); 81603d196b7SBharata B Rao if (ret < 0) { 81703d196b7SBharata B Rao goto out; 81803d196b7SBharata B Rao } 81903d196b7SBharata B Rao 82003d196b7SBharata B Rao /* ibm,dynamic-memory */ 82103d196b7SBharata B Rao int_buf[0] = cpu_to_be32(nr_lmbs); 82203d196b7SBharata B Rao cur_index++; 82303d196b7SBharata B Rao for (i = 0; i < nr_lmbs; i++) { 824d0e5a8f2SBharata B Rao uint64_t addr = i * lmb_size; 82503d196b7SBharata B Rao uint32_t *dynamic_memory = cur_index; 82603d196b7SBharata B Rao 827d0e5a8f2SBharata B Rao if (i >= hotplug_lmb_start) { 828d0e5a8f2SBharata B Rao sPAPRDRConnector *drc; 829d0e5a8f2SBharata B Rao sPAPRDRConnectorClass *drck; 830d0e5a8f2SBharata B Rao 831d0e5a8f2SBharata B Rao drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_LMB, i); 83203d196b7SBharata B Rao g_assert(drc); 83303d196b7SBharata B Rao drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 83403d196b7SBharata B Rao 83503d196b7SBharata B Rao dynamic_memory[0] = cpu_to_be32(addr >> 32); 83603d196b7SBharata B Rao dynamic_memory[1] = cpu_to_be32(addr & 0xffffffff); 83703d196b7SBharata B Rao dynamic_memory[2] = cpu_to_be32(drck->get_index(drc)); 83803d196b7SBharata B Rao dynamic_memory[3] = cpu_to_be32(0); /* reserved */ 83903d196b7SBharata B Rao dynamic_memory[4] = cpu_to_be32(numa_get_node(addr, NULL)); 840d0e5a8f2SBharata B Rao if (memory_region_present(get_system_memory(), addr)) { 84103d196b7SBharata B Rao dynamic_memory[5] = cpu_to_be32(SPAPR_LMB_FLAGS_ASSIGNED); 84203d196b7SBharata B Rao } else { 84303d196b7SBharata B Rao dynamic_memory[5] = cpu_to_be32(0); 84403d196b7SBharata B Rao } 845d0e5a8f2SBharata B Rao } else { 846d0e5a8f2SBharata B Rao /* 847d0e5a8f2SBharata B Rao * LMB information for RMA, boot time RAM and gap b/n RAM and 848d0e5a8f2SBharata B Rao * hotplug memory region -- all these are marked as reserved 849d0e5a8f2SBharata B Rao * and as having no valid DRC. 850d0e5a8f2SBharata B Rao */ 851d0e5a8f2SBharata B Rao dynamic_memory[0] = cpu_to_be32(addr >> 32); 852d0e5a8f2SBharata B Rao dynamic_memory[1] = cpu_to_be32(addr & 0xffffffff); 853d0e5a8f2SBharata B Rao dynamic_memory[2] = cpu_to_be32(0); 854d0e5a8f2SBharata B Rao dynamic_memory[3] = cpu_to_be32(0); /* reserved */ 855d0e5a8f2SBharata B Rao dynamic_memory[4] = cpu_to_be32(-1); 856d0e5a8f2SBharata B Rao dynamic_memory[5] = cpu_to_be32(SPAPR_LMB_FLAGS_RESERVED | 857d0e5a8f2SBharata B Rao SPAPR_LMB_FLAGS_DRC_INVALID); 858d0e5a8f2SBharata B Rao } 85903d196b7SBharata B Rao 86003d196b7SBharata B Rao cur_index += SPAPR_DR_LMB_LIST_ENTRY_SIZE; 86103d196b7SBharata B Rao } 86203d196b7SBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,dynamic-memory", int_buf, buf_len); 86303d196b7SBharata B Rao if (ret < 0) { 86403d196b7SBharata B Rao goto out; 86503d196b7SBharata B Rao } 86603d196b7SBharata B Rao 86703d196b7SBharata B Rao /* ibm,associativity-lookup-arrays */ 86803d196b7SBharata B Rao cur_index = int_buf; 8696663864eSBharata B Rao int_buf[0] = cpu_to_be32(nr_nodes); 87003d196b7SBharata B Rao int_buf[1] = cpu_to_be32(4); /* Number of entries per associativity list */ 87103d196b7SBharata B Rao cur_index += 2; 8726663864eSBharata B Rao for (i = 0; i < nr_nodes; i++) { 87303d196b7SBharata B Rao uint32_t associativity[] = { 87403d196b7SBharata B Rao cpu_to_be32(0x0), 87503d196b7SBharata B Rao cpu_to_be32(0x0), 87603d196b7SBharata B Rao cpu_to_be32(0x0), 87703d196b7SBharata B Rao cpu_to_be32(i) 87803d196b7SBharata B Rao }; 87903d196b7SBharata B Rao memcpy(cur_index, associativity, sizeof(associativity)); 88003d196b7SBharata B Rao cur_index += 4; 88103d196b7SBharata B Rao } 88203d196b7SBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,associativity-lookup-arrays", int_buf, 88303d196b7SBharata B Rao (cur_index - int_buf) * sizeof(uint32_t)); 88403d196b7SBharata B Rao out: 88503d196b7SBharata B Rao g_free(int_buf); 88603d196b7SBharata B Rao return ret; 88703d196b7SBharata B Rao } 88803d196b7SBharata B Rao 88903d196b7SBharata B Rao int spapr_h_cas_compose_response(sPAPRMachineState *spapr, 89003d196b7SBharata B Rao target_ulong addr, target_ulong size, 89103d196b7SBharata B Rao bool cpu_update, bool memory_update) 89203d196b7SBharata B Rao { 89303d196b7SBharata B Rao void *fdt, *fdt_skel; 89403d196b7SBharata B Rao sPAPRDeviceTreeUpdateHeader hdr = { .version_id = 1 }; 89503d196b7SBharata B Rao sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(qdev_get_machine()); 89603d196b7SBharata B Rao 89703d196b7SBharata B Rao size -= sizeof(hdr); 89803d196b7SBharata B Rao 89903d196b7SBharata B Rao /* Create sceleton */ 90003d196b7SBharata B Rao fdt_skel = g_malloc0(size); 90103d196b7SBharata B Rao _FDT((fdt_create(fdt_skel, size))); 90203d196b7SBharata B Rao _FDT((fdt_begin_node(fdt_skel, ""))); 90303d196b7SBharata B Rao _FDT((fdt_end_node(fdt_skel))); 90403d196b7SBharata B Rao _FDT((fdt_finish(fdt_skel))); 90503d196b7SBharata B Rao fdt = g_malloc0(size); 90603d196b7SBharata B Rao _FDT((fdt_open_into(fdt_skel, fdt, size))); 90703d196b7SBharata B Rao g_free(fdt_skel); 90803d196b7SBharata B Rao 90903d196b7SBharata B Rao /* Fixup cpu nodes */ 91003d196b7SBharata B Rao if (cpu_update) { 91103d196b7SBharata B Rao _FDT((spapr_fixup_cpu_dt(fdt, spapr))); 91203d196b7SBharata B Rao } 91303d196b7SBharata B Rao 91416c25aefSBharata B Rao /* Generate ibm,dynamic-reconfiguration-memory node if required */ 91503d196b7SBharata B Rao if (memory_update && smc->dr_lmb_enabled) { 91603d196b7SBharata B Rao _FDT((spapr_populate_drconf_memory(spapr, fdt))); 91703d196b7SBharata B Rao } 91803d196b7SBharata B Rao 91903d196b7SBharata B Rao /* Pack resulting tree */ 92003d196b7SBharata B Rao _FDT((fdt_pack(fdt))); 92103d196b7SBharata B Rao 92203d196b7SBharata B Rao if (fdt_totalsize(fdt) + sizeof(hdr) > size) { 92303d196b7SBharata B Rao trace_spapr_cas_failed(size); 92403d196b7SBharata B Rao return -1; 92503d196b7SBharata B Rao } 92603d196b7SBharata B Rao 92703d196b7SBharata B Rao cpu_physical_memory_write(addr, &hdr, sizeof(hdr)); 92803d196b7SBharata B Rao cpu_physical_memory_write(addr + sizeof(hdr), fdt, fdt_totalsize(fdt)); 92903d196b7SBharata B Rao trace_spapr_cas_continue(fdt_totalsize(fdt) + sizeof(hdr)); 93003d196b7SBharata B Rao g_free(fdt); 93103d196b7SBharata B Rao 93203d196b7SBharata B Rao return 0; 93303d196b7SBharata B Rao } 93403d196b7SBharata B Rao 93528e02042SDavid Gibson static void spapr_finalize_fdt(sPAPRMachineState *spapr, 93653018216SPaolo Bonzini hwaddr fdt_addr, 93753018216SPaolo Bonzini hwaddr rtas_addr, 93853018216SPaolo Bonzini hwaddr rtas_size) 93953018216SPaolo Bonzini { 9405b2128d2SAlexander Graf MachineState *machine = MACHINE(qdev_get_machine()); 9413c0c47e3SDavid Gibson MachineClass *mc = MACHINE_GET_CLASS(machine); 942c20d332aSBharata B Rao sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(machine); 9435b2128d2SAlexander Graf const char *boot_device = machine->boot_order; 94471461b0fSAlexey Kardashevskiy int ret, i; 94571461b0fSAlexey Kardashevskiy size_t cb = 0; 94671461b0fSAlexey Kardashevskiy char *bootlist; 94753018216SPaolo Bonzini void *fdt; 94853018216SPaolo Bonzini sPAPRPHBState *phb; 94953018216SPaolo Bonzini 95053018216SPaolo Bonzini fdt = g_malloc(FDT_MAX_SIZE); 95153018216SPaolo Bonzini 95253018216SPaolo Bonzini /* open out the base tree into a temp buffer for the final tweaks */ 95353018216SPaolo Bonzini _FDT((fdt_open_into(spapr->fdt_skel, fdt, FDT_MAX_SIZE))); 95453018216SPaolo Bonzini 955e8f986fcSBharata B Rao ret = spapr_populate_memory(spapr, fdt); 956e8f986fcSBharata B Rao if (ret < 0) { 957e8f986fcSBharata B Rao fprintf(stderr, "couldn't setup memory nodes in fdt\n"); 958e8f986fcSBharata B Rao exit(1); 95953018216SPaolo Bonzini } 96053018216SPaolo Bonzini 96153018216SPaolo Bonzini ret = spapr_populate_vdevice(spapr->vio_bus, fdt); 96253018216SPaolo Bonzini if (ret < 0) { 96353018216SPaolo Bonzini fprintf(stderr, "couldn't setup vio devices in fdt\n"); 96453018216SPaolo Bonzini exit(1); 96553018216SPaolo Bonzini } 96653018216SPaolo Bonzini 9674d9392beSThomas Huth if (object_resolve_path_type("", TYPE_SPAPR_RNG, NULL)) { 9684d9392beSThomas Huth ret = spapr_rng_populate_dt(fdt); 9694d9392beSThomas Huth if (ret < 0) { 9704d9392beSThomas Huth fprintf(stderr, "could not set up rng device in the fdt\n"); 9714d9392beSThomas Huth exit(1); 9724d9392beSThomas Huth } 9734d9392beSThomas Huth } 9744d9392beSThomas Huth 97553018216SPaolo Bonzini QLIST_FOREACH(phb, &spapr->phbs, list) { 97653018216SPaolo Bonzini ret = spapr_populate_pci_dt(phb, PHANDLE_XICP, fdt); 97753018216SPaolo Bonzini if (ret < 0) { 978da34fed7SThomas Huth error_report("couldn't setup PCI devices in fdt"); 97953018216SPaolo Bonzini exit(1); 98053018216SPaolo Bonzini } 981da34fed7SThomas Huth } 98253018216SPaolo Bonzini 98353018216SPaolo Bonzini /* RTAS */ 98453018216SPaolo Bonzini ret = spapr_rtas_device_tree_setup(fdt, rtas_addr, rtas_size); 98553018216SPaolo Bonzini if (ret < 0) { 98653018216SPaolo Bonzini fprintf(stderr, "Couldn't set up RTAS device tree properties\n"); 98753018216SPaolo Bonzini } 98853018216SPaolo Bonzini 9890da6f3feSBharata B Rao /* cpus */ 9900da6f3feSBharata B Rao spapr_populate_cpus_dt_node(fdt, spapr); 99153018216SPaolo Bonzini 99271461b0fSAlexey Kardashevskiy bootlist = get_boot_devices_list(&cb, true); 99371461b0fSAlexey Kardashevskiy if (cb && bootlist) { 99471461b0fSAlexey Kardashevskiy int offset = fdt_path_offset(fdt, "/chosen"); 99571461b0fSAlexey Kardashevskiy if (offset < 0) { 99671461b0fSAlexey Kardashevskiy exit(1); 99771461b0fSAlexey Kardashevskiy } 99871461b0fSAlexey Kardashevskiy for (i = 0; i < cb; i++) { 99971461b0fSAlexey Kardashevskiy if (bootlist[i] == '\n') { 100071461b0fSAlexey Kardashevskiy bootlist[i] = ' '; 100171461b0fSAlexey Kardashevskiy } 100271461b0fSAlexey Kardashevskiy 100371461b0fSAlexey Kardashevskiy } 100471461b0fSAlexey Kardashevskiy ret = fdt_setprop_string(fdt, offset, "qemu,boot-list", bootlist); 100571461b0fSAlexey Kardashevskiy } 100671461b0fSAlexey Kardashevskiy 10075b2128d2SAlexander Graf if (boot_device && strlen(boot_device)) { 10085b2128d2SAlexander Graf int offset = fdt_path_offset(fdt, "/chosen"); 10095b2128d2SAlexander Graf 10105b2128d2SAlexander Graf if (offset < 0) { 10115b2128d2SAlexander Graf exit(1); 10125b2128d2SAlexander Graf } 10135b2128d2SAlexander Graf fdt_setprop_string(fdt, offset, "qemu,boot-device", boot_device); 10145b2128d2SAlexander Graf } 10155b2128d2SAlexander Graf 101653018216SPaolo Bonzini if (!spapr->has_graphics) { 101753018216SPaolo Bonzini spapr_populate_chosen_stdout(fdt, spapr->vio_bus); 101853018216SPaolo Bonzini } 101953018216SPaolo Bonzini 1020c20d332aSBharata B Rao if (smc->dr_lmb_enabled) { 1021c20d332aSBharata B Rao _FDT(spapr_drc_populate_dt(fdt, 0, NULL, SPAPR_DR_CONNECTOR_TYPE_LMB)); 1022c20d332aSBharata B Rao } 1023c20d332aSBharata B Rao 10243c0c47e3SDavid Gibson if (mc->query_hotpluggable_cpus) { 1025af81cf32SBharata B Rao int offset = fdt_path_offset(fdt, "/cpus"); 1026af81cf32SBharata B Rao ret = spapr_drc_populate_dt(fdt, offset, NULL, 1027af81cf32SBharata B Rao SPAPR_DR_CONNECTOR_TYPE_CPU); 1028af81cf32SBharata B Rao if (ret < 0) { 1029af81cf32SBharata B Rao error_report("Couldn't set up CPU DR device tree properties"); 1030af81cf32SBharata B Rao exit(1); 1031af81cf32SBharata B Rao } 1032af81cf32SBharata B Rao } 1033af81cf32SBharata B Rao 103453018216SPaolo Bonzini _FDT((fdt_pack(fdt))); 103553018216SPaolo Bonzini 103653018216SPaolo Bonzini if (fdt_totalsize(fdt) > FDT_MAX_SIZE) { 1037730fce59SThomas Huth error_report("FDT too big ! 0x%x bytes (max is 0x%x)", 103853018216SPaolo Bonzini fdt_totalsize(fdt), FDT_MAX_SIZE); 103953018216SPaolo Bonzini exit(1); 104053018216SPaolo Bonzini } 104153018216SPaolo Bonzini 1042ad440b4aSAndrew Jones qemu_fdt_dumpdtb(fdt, fdt_totalsize(fdt)); 104353018216SPaolo Bonzini cpu_physical_memory_write(fdt_addr, fdt, fdt_totalsize(fdt)); 104453018216SPaolo Bonzini 1045a21a7a70SGonglei g_free(bootlist); 104653018216SPaolo Bonzini g_free(fdt); 104753018216SPaolo Bonzini } 104853018216SPaolo Bonzini 104953018216SPaolo Bonzini static uint64_t translate_kernel_address(void *opaque, uint64_t addr) 105053018216SPaolo Bonzini { 105153018216SPaolo Bonzini return (addr & 0x0fffffff) + KERNEL_LOAD_ADDR; 105253018216SPaolo Bonzini } 105353018216SPaolo Bonzini 105453018216SPaolo Bonzini static void emulate_spapr_hypercall(PowerPCCPU *cpu) 105553018216SPaolo Bonzini { 105653018216SPaolo Bonzini CPUPPCState *env = &cpu->env; 105753018216SPaolo Bonzini 105853018216SPaolo Bonzini if (msr_pr) { 105953018216SPaolo Bonzini hcall_dprintf("Hypercall made with MSR[PR]=1\n"); 106053018216SPaolo Bonzini env->gpr[3] = H_PRIVILEGE; 106153018216SPaolo Bonzini } else { 106253018216SPaolo Bonzini env->gpr[3] = spapr_hypercall(cpu, env->gpr[3], &env->gpr[4]); 106353018216SPaolo Bonzini } 106453018216SPaolo Bonzini } 106553018216SPaolo Bonzini 1066e6b8fd24SSamuel Mendoza-Jonas #define HPTE(_table, _i) (void *)(((uint64_t *)(_table)) + ((_i) * 2)) 1067e6b8fd24SSamuel Mendoza-Jonas #define HPTE_VALID(_hpte) (tswap64(*((uint64_t *)(_hpte))) & HPTE64_V_VALID) 1068e6b8fd24SSamuel Mendoza-Jonas #define HPTE_DIRTY(_hpte) (tswap64(*((uint64_t *)(_hpte))) & HPTE64_V_HPTE_DIRTY) 1069e6b8fd24SSamuel Mendoza-Jonas #define CLEAN_HPTE(_hpte) ((*(uint64_t *)(_hpte)) &= tswap64(~HPTE64_V_HPTE_DIRTY)) 1070e6b8fd24SSamuel Mendoza-Jonas #define DIRTY_HPTE(_hpte) ((*(uint64_t *)(_hpte)) |= tswap64(HPTE64_V_HPTE_DIRTY)) 1071e6b8fd24SSamuel Mendoza-Jonas 1072715c5407SDavid Gibson /* 1073715c5407SDavid Gibson * Get the fd to access the kernel htab, re-opening it if necessary 1074715c5407SDavid Gibson */ 1075715c5407SDavid Gibson static int get_htab_fd(sPAPRMachineState *spapr) 1076715c5407SDavid Gibson { 1077715c5407SDavid Gibson if (spapr->htab_fd >= 0) { 1078715c5407SDavid Gibson return spapr->htab_fd; 1079715c5407SDavid Gibson } 1080715c5407SDavid Gibson 1081715c5407SDavid Gibson spapr->htab_fd = kvmppc_get_htab_fd(false); 1082715c5407SDavid Gibson if (spapr->htab_fd < 0) { 1083715c5407SDavid Gibson error_report("Unable to open fd for reading hash table from KVM: %s", 1084715c5407SDavid Gibson strerror(errno)); 1085715c5407SDavid Gibson } 1086715c5407SDavid Gibson 1087715c5407SDavid Gibson return spapr->htab_fd; 1088715c5407SDavid Gibson } 1089715c5407SDavid Gibson 1090715c5407SDavid Gibson static void close_htab_fd(sPAPRMachineState *spapr) 1091715c5407SDavid Gibson { 1092715c5407SDavid Gibson if (spapr->htab_fd >= 0) { 1093715c5407SDavid Gibson close(spapr->htab_fd); 1094715c5407SDavid Gibson } 1095715c5407SDavid Gibson spapr->htab_fd = -1; 1096715c5407SDavid Gibson } 1097715c5407SDavid Gibson 10988dfe8e7fSDavid Gibson static int spapr_hpt_shift_for_ramsize(uint64_t ramsize) 10998dfe8e7fSDavid Gibson { 11008dfe8e7fSDavid Gibson int shift; 11018dfe8e7fSDavid Gibson 11028dfe8e7fSDavid Gibson /* We aim for a hash table of size 1/128 the size of RAM (rounded 11038dfe8e7fSDavid Gibson * up). The PAPR recommendation is actually 1/64 of RAM size, but 11048dfe8e7fSDavid Gibson * that's much more than is needed for Linux guests */ 11058dfe8e7fSDavid Gibson shift = ctz64(pow2ceil(ramsize)) - 7; 11068dfe8e7fSDavid Gibson shift = MAX(shift, 18); /* Minimum architected size */ 11078dfe8e7fSDavid Gibson shift = MIN(shift, 46); /* Maximum architected size */ 11088dfe8e7fSDavid Gibson return shift; 11098dfe8e7fSDavid Gibson } 11108dfe8e7fSDavid Gibson 1111c5f54f3eSDavid Gibson static void spapr_reallocate_hpt(sPAPRMachineState *spapr, int shift, 1112c5f54f3eSDavid Gibson Error **errp) 111353018216SPaolo Bonzini { 1114c5f54f3eSDavid Gibson long rc; 111553018216SPaolo Bonzini 1116c5f54f3eSDavid Gibson /* Clean up any HPT info from a previous boot */ 1117c5f54f3eSDavid Gibson g_free(spapr->htab); 1118c5f54f3eSDavid Gibson spapr->htab = NULL; 1119c5f54f3eSDavid Gibson spapr->htab_shift = 0; 1120c5f54f3eSDavid Gibson close_htab_fd(spapr); 112153018216SPaolo Bonzini 1122c5f54f3eSDavid Gibson rc = kvmppc_reset_htab(shift); 1123c5f54f3eSDavid Gibson if (rc < 0) { 1124c5f54f3eSDavid Gibson /* kernel-side HPT needed, but couldn't allocate one */ 1125c5f54f3eSDavid Gibson error_setg_errno(errp, errno, 1126c5f54f3eSDavid Gibson "Failed to allocate KVM HPT of order %d (try smaller maxmem?)", 1127c5f54f3eSDavid Gibson shift); 1128c5f54f3eSDavid Gibson /* This is almost certainly fatal, but if the caller really 1129c5f54f3eSDavid Gibson * wants to carry on with shift == 0, it's welcome to try */ 1130c5f54f3eSDavid Gibson } else if (rc > 0) { 1131c5f54f3eSDavid Gibson /* kernel-side HPT allocated */ 1132c5f54f3eSDavid Gibson if (rc != shift) { 1133c5f54f3eSDavid Gibson error_setg(errp, 1134c5f54f3eSDavid Gibson "Requested order %d HPT, but kernel allocated order %ld (try smaller maxmem?)", 1135c5f54f3eSDavid Gibson shift, rc); 11367735fedaSBharata B Rao } 11377735fedaSBharata B Rao 113853018216SPaolo Bonzini spapr->htab_shift = shift; 1139c18ad9a5SDavid Gibson spapr->htab = NULL; 1140b817772aSBharata B Rao } else { 1141c5f54f3eSDavid Gibson /* kernel-side HPT not needed, allocate in userspace instead */ 1142c5f54f3eSDavid Gibson size_t size = 1ULL << shift; 1143c5f54f3eSDavid Gibson int i; 114401a57972SSamuel Mendoza-Jonas 1145c5f54f3eSDavid Gibson spapr->htab = qemu_memalign(size, size); 1146c5f54f3eSDavid Gibson if (!spapr->htab) { 1147c5f54f3eSDavid Gibson error_setg_errno(errp, errno, 1148c5f54f3eSDavid Gibson "Could not allocate HPT of order %d", shift); 1149c5f54f3eSDavid Gibson return; 1150b817772aSBharata B Rao } 1151b817772aSBharata B Rao 1152c5f54f3eSDavid Gibson memset(spapr->htab, 0, size); 1153c5f54f3eSDavid Gibson spapr->htab_shift = shift; 1154b817772aSBharata B Rao 1155c5f54f3eSDavid Gibson for (i = 0; i < size / HASH_PTE_SIZE_64; i++) { 1156c5f54f3eSDavid Gibson DIRTY_HPTE(HPTE(spapr->htab, i)); 11577735fedaSBharata B Rao } 115853018216SPaolo Bonzini } 115953018216SPaolo Bonzini } 116053018216SPaolo Bonzini 11619e3f9733SAlexander Graf static int find_unknown_sysbus_device(SysBusDevice *sbdev, void *opaque) 11629e3f9733SAlexander Graf { 11639e3f9733SAlexander Graf bool matched = false; 11649e3f9733SAlexander Graf 11659e3f9733SAlexander Graf if (object_dynamic_cast(OBJECT(sbdev), TYPE_SPAPR_PCI_HOST_BRIDGE)) { 11669e3f9733SAlexander Graf matched = true; 11679e3f9733SAlexander Graf } 11689e3f9733SAlexander Graf 11699e3f9733SAlexander Graf if (!matched) { 11709e3f9733SAlexander Graf error_report("Device %s is not supported by this machine yet.", 11719e3f9733SAlexander Graf qdev_fw_name(DEVICE(sbdev))); 11729e3f9733SAlexander Graf exit(1); 11739e3f9733SAlexander Graf } 11749e3f9733SAlexander Graf 11759e3f9733SAlexander Graf return 0; 11769e3f9733SAlexander Graf } 11779e3f9733SAlexander Graf 117853018216SPaolo Bonzini static void ppc_spapr_reset(void) 117953018216SPaolo Bonzini { 1180c5f54f3eSDavid Gibson MachineState *machine = MACHINE(qdev_get_machine()); 1181c5f54f3eSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(machine); 1182182735efSAndreas Färber PowerPCCPU *first_ppc_cpu; 1183b7d1f77aSBenjamin Herrenschmidt uint32_t rtas_limit; 1184259186a7SAndreas Färber 11859e3f9733SAlexander Graf /* Check for unknown sysbus devices */ 11869e3f9733SAlexander Graf foreach_dynamic_sysbus_device(find_unknown_sysbus_device, NULL); 11879e3f9733SAlexander Graf 1188c5f54f3eSDavid Gibson /* Allocate and/or reset the hash page table */ 1189c5f54f3eSDavid Gibson spapr_reallocate_hpt(spapr, 1190c5f54f3eSDavid Gibson spapr_hpt_shift_for_ramsize(machine->maxram_size), 1191c5f54f3eSDavid Gibson &error_fatal); 1192c5f54f3eSDavid Gibson 1193c5f54f3eSDavid Gibson /* Update the RMA size if necessary */ 1194c5f54f3eSDavid Gibson if (spapr->vrma_adjust) { 1195c5f54f3eSDavid Gibson spapr->rma_size = kvmppc_rma_size(spapr_node0_size(), 1196c5f54f3eSDavid Gibson spapr->htab_shift); 1197c5f54f3eSDavid Gibson } 119853018216SPaolo Bonzini 119953018216SPaolo Bonzini qemu_devices_reset(); 120053018216SPaolo Bonzini 1201b7d1f77aSBenjamin Herrenschmidt /* 1202b7d1f77aSBenjamin Herrenschmidt * We place the device tree and RTAS just below either the top of the RMA, 1203b7d1f77aSBenjamin Herrenschmidt * or just below 2GB, whichever is lowere, so that it can be 1204b7d1f77aSBenjamin Herrenschmidt * processed with 32-bit real mode code if necessary 1205b7d1f77aSBenjamin Herrenschmidt */ 1206b7d1f77aSBenjamin Herrenschmidt rtas_limit = MIN(spapr->rma_size, RTAS_MAX_ADDR); 1207b7d1f77aSBenjamin Herrenschmidt spapr->rtas_addr = rtas_limit - RTAS_MAX_SIZE; 1208b7d1f77aSBenjamin Herrenschmidt spapr->fdt_addr = spapr->rtas_addr - FDT_MAX_SIZE; 1209b7d1f77aSBenjamin Herrenschmidt 121053018216SPaolo Bonzini /* Load the fdt */ 121153018216SPaolo Bonzini spapr_finalize_fdt(spapr, spapr->fdt_addr, spapr->rtas_addr, 121253018216SPaolo Bonzini spapr->rtas_size); 121353018216SPaolo Bonzini 1214b7d1f77aSBenjamin Herrenschmidt /* Copy RTAS over */ 1215b7d1f77aSBenjamin Herrenschmidt cpu_physical_memory_write(spapr->rtas_addr, spapr->rtas_blob, 1216b7d1f77aSBenjamin Herrenschmidt spapr->rtas_size); 1217b7d1f77aSBenjamin Herrenschmidt 121853018216SPaolo Bonzini /* Set up the entry state */ 1219182735efSAndreas Färber first_ppc_cpu = POWERPC_CPU(first_cpu); 1220182735efSAndreas Färber first_ppc_cpu->env.gpr[3] = spapr->fdt_addr; 1221182735efSAndreas Färber first_ppc_cpu->env.gpr[5] = 0; 1222182735efSAndreas Färber first_cpu->halted = 0; 12231b718907SDavid Gibson first_ppc_cpu->env.nip = SPAPR_ENTRY_POINT; 122453018216SPaolo Bonzini 122553018216SPaolo Bonzini } 122653018216SPaolo Bonzini 122728e02042SDavid Gibson static void spapr_create_nvram(sPAPRMachineState *spapr) 122853018216SPaolo Bonzini { 12292ff3de68SMarkus Armbruster DeviceState *dev = qdev_create(&spapr->vio_bus->bus, "spapr-nvram"); 12303978b863SPaolo Bonzini DriveInfo *dinfo = drive_get(IF_PFLASH, 0, 0); 123153018216SPaolo Bonzini 12323978b863SPaolo Bonzini if (dinfo) { 12336231a6daSMarkus Armbruster qdev_prop_set_drive(dev, "drive", blk_by_legacy_dinfo(dinfo), 12346231a6daSMarkus Armbruster &error_fatal); 123553018216SPaolo Bonzini } 123653018216SPaolo Bonzini 123753018216SPaolo Bonzini qdev_init_nofail(dev); 123853018216SPaolo Bonzini 123953018216SPaolo Bonzini spapr->nvram = (struct sPAPRNVRAM *)dev; 124053018216SPaolo Bonzini } 124153018216SPaolo Bonzini 124228e02042SDavid Gibson static void spapr_rtc_create(sPAPRMachineState *spapr) 124328df36a1SDavid Gibson { 124428df36a1SDavid Gibson DeviceState *dev = qdev_create(NULL, TYPE_SPAPR_RTC); 124528df36a1SDavid Gibson 124628df36a1SDavid Gibson qdev_init_nofail(dev); 124728df36a1SDavid Gibson spapr->rtc = dev; 124874e5ae28SDavid Gibson 124974e5ae28SDavid Gibson object_property_add_alias(qdev_get_machine(), "rtc-time", 125074e5ae28SDavid Gibson OBJECT(spapr->rtc), "date", NULL); 125128df36a1SDavid Gibson } 125228df36a1SDavid Gibson 125353018216SPaolo Bonzini /* Returns whether we want to use VGA or not */ 125414c6a894SDavid Gibson static bool spapr_vga_init(PCIBus *pci_bus, Error **errp) 125553018216SPaolo Bonzini { 125653018216SPaolo Bonzini switch (vga_interface_type) { 125753018216SPaolo Bonzini case VGA_NONE: 12587effdaa3SMark Wu return false; 12597effdaa3SMark Wu case VGA_DEVICE: 12607effdaa3SMark Wu return true; 126153018216SPaolo Bonzini case VGA_STD: 1262b798c190SBenjamin Herrenschmidt case VGA_VIRTIO: 126353018216SPaolo Bonzini return pci_vga_init(pci_bus) != NULL; 126453018216SPaolo Bonzini default: 126514c6a894SDavid Gibson error_setg(errp, 126614c6a894SDavid Gibson "Unsupported VGA mode, only -vga std or -vga virtio is supported"); 126714c6a894SDavid Gibson return false; 126853018216SPaolo Bonzini } 126953018216SPaolo Bonzini } 127053018216SPaolo Bonzini 1271880ae7deSDavid Gibson static int spapr_post_load(void *opaque, int version_id) 1272880ae7deSDavid Gibson { 127328e02042SDavid Gibson sPAPRMachineState *spapr = (sPAPRMachineState *)opaque; 1274880ae7deSDavid Gibson int err = 0; 1275880ae7deSDavid Gibson 1276631b22eaSStefan Weil /* In earlier versions, there was no separate qdev for the PAPR 1277880ae7deSDavid Gibson * RTC, so the RTC offset was stored directly in sPAPREnvironment. 1278880ae7deSDavid Gibson * So when migrating from those versions, poke the incoming offset 1279880ae7deSDavid Gibson * value into the RTC device */ 1280880ae7deSDavid Gibson if (version_id < 3) { 1281880ae7deSDavid Gibson err = spapr_rtc_import_offset(spapr->rtc, spapr->rtc_offset); 1282880ae7deSDavid Gibson } 1283880ae7deSDavid Gibson 1284880ae7deSDavid Gibson return err; 1285880ae7deSDavid Gibson } 1286880ae7deSDavid Gibson 1287880ae7deSDavid Gibson static bool version_before_3(void *opaque, int version_id) 1288880ae7deSDavid Gibson { 1289880ae7deSDavid Gibson return version_id < 3; 1290880ae7deSDavid Gibson } 1291880ae7deSDavid Gibson 12924be21d56SDavid Gibson static const VMStateDescription vmstate_spapr = { 12934be21d56SDavid Gibson .name = "spapr", 1294880ae7deSDavid Gibson .version_id = 3, 12954be21d56SDavid Gibson .minimum_version_id = 1, 1296880ae7deSDavid Gibson .post_load = spapr_post_load, 12974be21d56SDavid Gibson .fields = (VMStateField[]) { 1298880ae7deSDavid Gibson /* used to be @next_irq */ 1299880ae7deSDavid Gibson VMSTATE_UNUSED_BUFFER(version_before_3, 0, 4), 13004be21d56SDavid Gibson 13014be21d56SDavid Gibson /* RTC offset */ 130228e02042SDavid Gibson VMSTATE_UINT64_TEST(rtc_offset, sPAPRMachineState, version_before_3), 1303880ae7deSDavid Gibson 130428e02042SDavid Gibson VMSTATE_PPC_TIMEBASE_V(tb, sPAPRMachineState, 2), 13054be21d56SDavid Gibson VMSTATE_END_OF_LIST() 13064be21d56SDavid Gibson }, 13074be21d56SDavid Gibson }; 13084be21d56SDavid Gibson 13094be21d56SDavid Gibson static int htab_save_setup(QEMUFile *f, void *opaque) 13104be21d56SDavid Gibson { 131128e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 13124be21d56SDavid Gibson 13134be21d56SDavid Gibson /* "Iteration" header */ 13144be21d56SDavid Gibson qemu_put_be32(f, spapr->htab_shift); 13154be21d56SDavid Gibson 1316e68cb8b4SAlexey Kardashevskiy if (spapr->htab) { 1317e68cb8b4SAlexey Kardashevskiy spapr->htab_save_index = 0; 1318e68cb8b4SAlexey Kardashevskiy spapr->htab_first_pass = true; 1319e68cb8b4SAlexey Kardashevskiy } else { 1320e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 13214be21d56SDavid Gibson } 13224be21d56SDavid Gibson 1323e68cb8b4SAlexey Kardashevskiy 1324e68cb8b4SAlexey Kardashevskiy return 0; 1325e68cb8b4SAlexey Kardashevskiy } 13264be21d56SDavid Gibson 132728e02042SDavid Gibson static void htab_save_first_pass(QEMUFile *f, sPAPRMachineState *spapr, 13284be21d56SDavid Gibson int64_t max_ns) 13294be21d56SDavid Gibson { 1330378bc217SDavid Gibson bool has_timeout = max_ns != -1; 13314be21d56SDavid Gibson int htabslots = HTAB_SIZE(spapr) / HASH_PTE_SIZE_64; 13324be21d56SDavid Gibson int index = spapr->htab_save_index; 1333bc72ad67SAlex Bligh int64_t starttime = qemu_clock_get_ns(QEMU_CLOCK_REALTIME); 13344be21d56SDavid Gibson 13354be21d56SDavid Gibson assert(spapr->htab_first_pass); 13364be21d56SDavid Gibson 13374be21d56SDavid Gibson do { 13384be21d56SDavid Gibson int chunkstart; 13394be21d56SDavid Gibson 13404be21d56SDavid Gibson /* Consume invalid HPTEs */ 13414be21d56SDavid Gibson while ((index < htabslots) 13424be21d56SDavid Gibson && !HPTE_VALID(HPTE(spapr->htab, index))) { 13434be21d56SDavid Gibson index++; 13444be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 13454be21d56SDavid Gibson } 13464be21d56SDavid Gibson 13474be21d56SDavid Gibson /* Consume valid HPTEs */ 13484be21d56SDavid Gibson chunkstart = index; 1349338c25b6SSamuel Mendoza-Jonas while ((index < htabslots) && (index - chunkstart < USHRT_MAX) 13504be21d56SDavid Gibson && HPTE_VALID(HPTE(spapr->htab, index))) { 13514be21d56SDavid Gibson index++; 13524be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 13534be21d56SDavid Gibson } 13544be21d56SDavid Gibson 13554be21d56SDavid Gibson if (index > chunkstart) { 13564be21d56SDavid Gibson int n_valid = index - chunkstart; 13574be21d56SDavid Gibson 13584be21d56SDavid Gibson qemu_put_be32(f, chunkstart); 13594be21d56SDavid Gibson qemu_put_be16(f, n_valid); 13604be21d56SDavid Gibson qemu_put_be16(f, 0); 13614be21d56SDavid Gibson qemu_put_buffer(f, HPTE(spapr->htab, chunkstart), 13624be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_valid); 13634be21d56SDavid Gibson 1364378bc217SDavid Gibson if (has_timeout && 1365378bc217SDavid Gibson (qemu_clock_get_ns(QEMU_CLOCK_REALTIME) - starttime) > max_ns) { 13664be21d56SDavid Gibson break; 13674be21d56SDavid Gibson } 13684be21d56SDavid Gibson } 13694be21d56SDavid Gibson } while ((index < htabslots) && !qemu_file_rate_limit(f)); 13704be21d56SDavid Gibson 13714be21d56SDavid Gibson if (index >= htabslots) { 13724be21d56SDavid Gibson assert(index == htabslots); 13734be21d56SDavid Gibson index = 0; 13744be21d56SDavid Gibson spapr->htab_first_pass = false; 13754be21d56SDavid Gibson } 13764be21d56SDavid Gibson spapr->htab_save_index = index; 13774be21d56SDavid Gibson } 13784be21d56SDavid Gibson 137928e02042SDavid Gibson static int htab_save_later_pass(QEMUFile *f, sPAPRMachineState *spapr, 13804be21d56SDavid Gibson int64_t max_ns) 13814be21d56SDavid Gibson { 13824be21d56SDavid Gibson bool final = max_ns < 0; 13834be21d56SDavid Gibson int htabslots = HTAB_SIZE(spapr) / HASH_PTE_SIZE_64; 13844be21d56SDavid Gibson int examined = 0, sent = 0; 13854be21d56SDavid Gibson int index = spapr->htab_save_index; 1386bc72ad67SAlex Bligh int64_t starttime = qemu_clock_get_ns(QEMU_CLOCK_REALTIME); 13874be21d56SDavid Gibson 13884be21d56SDavid Gibson assert(!spapr->htab_first_pass); 13894be21d56SDavid Gibson 13904be21d56SDavid Gibson do { 13914be21d56SDavid Gibson int chunkstart, invalidstart; 13924be21d56SDavid Gibson 13934be21d56SDavid Gibson /* Consume non-dirty HPTEs */ 13944be21d56SDavid Gibson while ((index < htabslots) 13954be21d56SDavid Gibson && !HPTE_DIRTY(HPTE(spapr->htab, index))) { 13964be21d56SDavid Gibson index++; 13974be21d56SDavid Gibson examined++; 13984be21d56SDavid Gibson } 13994be21d56SDavid Gibson 14004be21d56SDavid Gibson chunkstart = index; 14014be21d56SDavid Gibson /* Consume valid dirty HPTEs */ 1402338c25b6SSamuel Mendoza-Jonas while ((index < htabslots) && (index - chunkstart < USHRT_MAX) 14034be21d56SDavid Gibson && HPTE_DIRTY(HPTE(spapr->htab, index)) 14044be21d56SDavid Gibson && HPTE_VALID(HPTE(spapr->htab, index))) { 14054be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 14064be21d56SDavid Gibson index++; 14074be21d56SDavid Gibson examined++; 14084be21d56SDavid Gibson } 14094be21d56SDavid Gibson 14104be21d56SDavid Gibson invalidstart = index; 14114be21d56SDavid Gibson /* Consume invalid dirty HPTEs */ 1412338c25b6SSamuel Mendoza-Jonas while ((index < htabslots) && (index - invalidstart < USHRT_MAX) 14134be21d56SDavid Gibson && HPTE_DIRTY(HPTE(spapr->htab, index)) 14144be21d56SDavid Gibson && !HPTE_VALID(HPTE(spapr->htab, index))) { 14154be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 14164be21d56SDavid Gibson index++; 14174be21d56SDavid Gibson examined++; 14184be21d56SDavid Gibson } 14194be21d56SDavid Gibson 14204be21d56SDavid Gibson if (index > chunkstart) { 14214be21d56SDavid Gibson int n_valid = invalidstart - chunkstart; 14224be21d56SDavid Gibson int n_invalid = index - invalidstart; 14234be21d56SDavid Gibson 14244be21d56SDavid Gibson qemu_put_be32(f, chunkstart); 14254be21d56SDavid Gibson qemu_put_be16(f, n_valid); 14264be21d56SDavid Gibson qemu_put_be16(f, n_invalid); 14274be21d56SDavid Gibson qemu_put_buffer(f, HPTE(spapr->htab, chunkstart), 14284be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_valid); 14294be21d56SDavid Gibson sent += index - chunkstart; 14304be21d56SDavid Gibson 1431bc72ad67SAlex Bligh if (!final && (qemu_clock_get_ns(QEMU_CLOCK_REALTIME) - starttime) > max_ns) { 14324be21d56SDavid Gibson break; 14334be21d56SDavid Gibson } 14344be21d56SDavid Gibson } 14354be21d56SDavid Gibson 14364be21d56SDavid Gibson if (examined >= htabslots) { 14374be21d56SDavid Gibson break; 14384be21d56SDavid Gibson } 14394be21d56SDavid Gibson 14404be21d56SDavid Gibson if (index >= htabslots) { 14414be21d56SDavid Gibson assert(index == htabslots); 14424be21d56SDavid Gibson index = 0; 14434be21d56SDavid Gibson } 14444be21d56SDavid Gibson } while ((examined < htabslots) && (!qemu_file_rate_limit(f) || final)); 14454be21d56SDavid Gibson 14464be21d56SDavid Gibson if (index >= htabslots) { 14474be21d56SDavid Gibson assert(index == htabslots); 14484be21d56SDavid Gibson index = 0; 14494be21d56SDavid Gibson } 14504be21d56SDavid Gibson 14514be21d56SDavid Gibson spapr->htab_save_index = index; 14524be21d56SDavid Gibson 1453e68cb8b4SAlexey Kardashevskiy return (examined >= htabslots) && (sent == 0) ? 1 : 0; 14544be21d56SDavid Gibson } 14554be21d56SDavid Gibson 1456e68cb8b4SAlexey Kardashevskiy #define MAX_ITERATION_NS 5000000 /* 5 ms */ 1457e68cb8b4SAlexey Kardashevskiy #define MAX_KVM_BUF_SIZE 2048 1458e68cb8b4SAlexey Kardashevskiy 14594be21d56SDavid Gibson static int htab_save_iterate(QEMUFile *f, void *opaque) 14604be21d56SDavid Gibson { 146128e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 1462715c5407SDavid Gibson int fd; 1463e68cb8b4SAlexey Kardashevskiy int rc = 0; 14644be21d56SDavid Gibson 14654be21d56SDavid Gibson /* Iteration header */ 14664be21d56SDavid Gibson qemu_put_be32(f, 0); 14674be21d56SDavid Gibson 1468e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1469e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 1470e68cb8b4SAlexey Kardashevskiy 1471715c5407SDavid Gibson fd = get_htab_fd(spapr); 1472715c5407SDavid Gibson if (fd < 0) { 1473715c5407SDavid Gibson return fd; 147401a57972SSamuel Mendoza-Jonas } 147501a57972SSamuel Mendoza-Jonas 1476715c5407SDavid Gibson rc = kvmppc_save_htab(f, fd, MAX_KVM_BUF_SIZE, MAX_ITERATION_NS); 1477e68cb8b4SAlexey Kardashevskiy if (rc < 0) { 1478e68cb8b4SAlexey Kardashevskiy return rc; 1479e68cb8b4SAlexey Kardashevskiy } 1480e68cb8b4SAlexey Kardashevskiy } else if (spapr->htab_first_pass) { 14814be21d56SDavid Gibson htab_save_first_pass(f, spapr, MAX_ITERATION_NS); 14824be21d56SDavid Gibson } else { 1483e68cb8b4SAlexey Kardashevskiy rc = htab_save_later_pass(f, spapr, MAX_ITERATION_NS); 14844be21d56SDavid Gibson } 14854be21d56SDavid Gibson 14864be21d56SDavid Gibson /* End marker */ 14874be21d56SDavid Gibson qemu_put_be32(f, 0); 14884be21d56SDavid Gibson qemu_put_be16(f, 0); 14894be21d56SDavid Gibson qemu_put_be16(f, 0); 14904be21d56SDavid Gibson 1491e68cb8b4SAlexey Kardashevskiy return rc; 14924be21d56SDavid Gibson } 14934be21d56SDavid Gibson 14944be21d56SDavid Gibson static int htab_save_complete(QEMUFile *f, void *opaque) 14954be21d56SDavid Gibson { 149628e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 1497715c5407SDavid Gibson int fd; 14984be21d56SDavid Gibson 14994be21d56SDavid Gibson /* Iteration header */ 15004be21d56SDavid Gibson qemu_put_be32(f, 0); 15014be21d56SDavid Gibson 1502e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1503e68cb8b4SAlexey Kardashevskiy int rc; 1504e68cb8b4SAlexey Kardashevskiy 1505e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 1506e68cb8b4SAlexey Kardashevskiy 1507715c5407SDavid Gibson fd = get_htab_fd(spapr); 1508715c5407SDavid Gibson if (fd < 0) { 1509715c5407SDavid Gibson return fd; 151001a57972SSamuel Mendoza-Jonas } 151101a57972SSamuel Mendoza-Jonas 1512715c5407SDavid Gibson rc = kvmppc_save_htab(f, fd, MAX_KVM_BUF_SIZE, -1); 1513e68cb8b4SAlexey Kardashevskiy if (rc < 0) { 1514e68cb8b4SAlexey Kardashevskiy return rc; 1515e68cb8b4SAlexey Kardashevskiy } 1516e68cb8b4SAlexey Kardashevskiy } else { 1517378bc217SDavid Gibson if (spapr->htab_first_pass) { 1518378bc217SDavid Gibson htab_save_first_pass(f, spapr, -1); 1519378bc217SDavid Gibson } 15204be21d56SDavid Gibson htab_save_later_pass(f, spapr, -1); 1521e68cb8b4SAlexey Kardashevskiy } 15224be21d56SDavid Gibson 15234be21d56SDavid Gibson /* End marker */ 15244be21d56SDavid Gibson qemu_put_be32(f, 0); 15254be21d56SDavid Gibson qemu_put_be16(f, 0); 15264be21d56SDavid Gibson qemu_put_be16(f, 0); 15274be21d56SDavid Gibson 15284be21d56SDavid Gibson return 0; 15294be21d56SDavid Gibson } 15304be21d56SDavid Gibson 15314be21d56SDavid Gibson static int htab_load(QEMUFile *f, void *opaque, int version_id) 15324be21d56SDavid Gibson { 153328e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 15344be21d56SDavid Gibson uint32_t section_hdr; 1535e68cb8b4SAlexey Kardashevskiy int fd = -1; 15364be21d56SDavid Gibson 15374be21d56SDavid Gibson if (version_id < 1 || version_id > 1) { 153898a5d100SDavid Gibson error_report("htab_load() bad version"); 15394be21d56SDavid Gibson return -EINVAL; 15404be21d56SDavid Gibson } 15414be21d56SDavid Gibson 15424be21d56SDavid Gibson section_hdr = qemu_get_be32(f); 15434be21d56SDavid Gibson 15444be21d56SDavid Gibson if (section_hdr) { 15459897e462SGreg Kurz Error *local_err = NULL; 1546c5f54f3eSDavid Gibson 1547c5f54f3eSDavid Gibson /* First section gives the htab size */ 1548c5f54f3eSDavid Gibson spapr_reallocate_hpt(spapr, section_hdr, &local_err); 1549c5f54f3eSDavid Gibson if (local_err) { 1550c5f54f3eSDavid Gibson error_report_err(local_err); 15514be21d56SDavid Gibson return -EINVAL; 15524be21d56SDavid Gibson } 15534be21d56SDavid Gibson return 0; 15544be21d56SDavid Gibson } 15554be21d56SDavid Gibson 1556e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1557e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 1558e68cb8b4SAlexey Kardashevskiy 1559e68cb8b4SAlexey Kardashevskiy fd = kvmppc_get_htab_fd(true); 1560e68cb8b4SAlexey Kardashevskiy if (fd < 0) { 156198a5d100SDavid Gibson error_report("Unable to open fd to restore KVM hash table: %s", 1562e68cb8b4SAlexey Kardashevskiy strerror(errno)); 1563e68cb8b4SAlexey Kardashevskiy } 1564e68cb8b4SAlexey Kardashevskiy } 1565e68cb8b4SAlexey Kardashevskiy 15664be21d56SDavid Gibson while (true) { 15674be21d56SDavid Gibson uint32_t index; 15684be21d56SDavid Gibson uint16_t n_valid, n_invalid; 15694be21d56SDavid Gibson 15704be21d56SDavid Gibson index = qemu_get_be32(f); 15714be21d56SDavid Gibson n_valid = qemu_get_be16(f); 15724be21d56SDavid Gibson n_invalid = qemu_get_be16(f); 15734be21d56SDavid Gibson 15744be21d56SDavid Gibson if ((index == 0) && (n_valid == 0) && (n_invalid == 0)) { 15754be21d56SDavid Gibson /* End of Stream */ 15764be21d56SDavid Gibson break; 15774be21d56SDavid Gibson } 15784be21d56SDavid Gibson 1579e68cb8b4SAlexey Kardashevskiy if ((index + n_valid + n_invalid) > 15804be21d56SDavid Gibson (HTAB_SIZE(spapr) / HASH_PTE_SIZE_64)) { 15814be21d56SDavid Gibson /* Bad index in stream */ 158298a5d100SDavid Gibson error_report( 158398a5d100SDavid Gibson "htab_load() bad index %d (%hd+%hd entries) in htab stream (htab_shift=%d)", 158498a5d100SDavid Gibson index, n_valid, n_invalid, spapr->htab_shift); 15854be21d56SDavid Gibson return -EINVAL; 15864be21d56SDavid Gibson } 15874be21d56SDavid Gibson 1588e68cb8b4SAlexey Kardashevskiy if (spapr->htab) { 15894be21d56SDavid Gibson if (n_valid) { 15904be21d56SDavid Gibson qemu_get_buffer(f, HPTE(spapr->htab, index), 15914be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_valid); 15924be21d56SDavid Gibson } 15934be21d56SDavid Gibson if (n_invalid) { 15944be21d56SDavid Gibson memset(HPTE(spapr->htab, index + n_valid), 0, 15954be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_invalid); 15964be21d56SDavid Gibson } 1597e68cb8b4SAlexey Kardashevskiy } else { 1598e68cb8b4SAlexey Kardashevskiy int rc; 1599e68cb8b4SAlexey Kardashevskiy 1600e68cb8b4SAlexey Kardashevskiy assert(fd >= 0); 1601e68cb8b4SAlexey Kardashevskiy 1602e68cb8b4SAlexey Kardashevskiy rc = kvmppc_load_htab_chunk(f, fd, index, n_valid, n_invalid); 1603e68cb8b4SAlexey Kardashevskiy if (rc < 0) { 1604e68cb8b4SAlexey Kardashevskiy return rc; 1605e68cb8b4SAlexey Kardashevskiy } 1606e68cb8b4SAlexey Kardashevskiy } 1607e68cb8b4SAlexey Kardashevskiy } 1608e68cb8b4SAlexey Kardashevskiy 1609e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1610e68cb8b4SAlexey Kardashevskiy assert(fd >= 0); 1611e68cb8b4SAlexey Kardashevskiy close(fd); 16124be21d56SDavid Gibson } 16134be21d56SDavid Gibson 16144be21d56SDavid Gibson return 0; 16154be21d56SDavid Gibson } 16164be21d56SDavid Gibson 1617c573fc03SThomas Huth static void htab_cleanup(void *opaque) 1618c573fc03SThomas Huth { 1619c573fc03SThomas Huth sPAPRMachineState *spapr = opaque; 1620c573fc03SThomas Huth 1621c573fc03SThomas Huth close_htab_fd(spapr); 1622c573fc03SThomas Huth } 1623c573fc03SThomas Huth 16244be21d56SDavid Gibson static SaveVMHandlers savevm_htab_handlers = { 16254be21d56SDavid Gibson .save_live_setup = htab_save_setup, 16264be21d56SDavid Gibson .save_live_iterate = htab_save_iterate, 1627a3e06c3dSDr. David Alan Gilbert .save_live_complete_precopy = htab_save_complete, 1628c573fc03SThomas Huth .cleanup = htab_cleanup, 16294be21d56SDavid Gibson .load_state = htab_load, 16304be21d56SDavid Gibson }; 16314be21d56SDavid Gibson 16325b2128d2SAlexander Graf static void spapr_boot_set(void *opaque, const char *boot_device, 16335b2128d2SAlexander Graf Error **errp) 16345b2128d2SAlexander Graf { 16355b2128d2SAlexander Graf MachineState *machine = MACHINE(qdev_get_machine()); 16365b2128d2SAlexander Graf machine->boot_order = g_strdup(boot_device); 16375b2128d2SAlexander Graf } 16385b2128d2SAlexander Graf 1639224245bfSDavid Gibson /* 1640224245bfSDavid Gibson * Reset routine for LMB DR devices. 1641224245bfSDavid Gibson * 1642224245bfSDavid Gibson * Unlike PCI DR devices, LMB DR devices explicitly register this reset 1643224245bfSDavid Gibson * routine. Reset for PCI DR devices will be handled by PHB reset routine 1644224245bfSDavid Gibson * when it walks all its children devices. LMB devices reset occurs 1645224245bfSDavid Gibson * as part of spapr_ppc_reset(). 1646224245bfSDavid Gibson */ 1647224245bfSDavid Gibson static void spapr_drc_reset(void *opaque) 1648224245bfSDavid Gibson { 1649224245bfSDavid Gibson sPAPRDRConnector *drc = opaque; 1650224245bfSDavid Gibson DeviceState *d = DEVICE(drc); 1651224245bfSDavid Gibson 1652224245bfSDavid Gibson if (d) { 1653224245bfSDavid Gibson device_reset(d); 1654224245bfSDavid Gibson } 1655224245bfSDavid Gibson } 1656224245bfSDavid Gibson 1657224245bfSDavid Gibson static void spapr_create_lmb_dr_connectors(sPAPRMachineState *spapr) 1658224245bfSDavid Gibson { 1659224245bfSDavid Gibson MachineState *machine = MACHINE(spapr); 1660224245bfSDavid Gibson uint64_t lmb_size = SPAPR_MEMORY_BLOCK_SIZE; 1661e8f986fcSBharata B Rao uint32_t nr_lmbs = (machine->maxram_size - machine->ram_size)/lmb_size; 1662224245bfSDavid Gibson int i; 1663224245bfSDavid Gibson 1664224245bfSDavid Gibson for (i = 0; i < nr_lmbs; i++) { 1665224245bfSDavid Gibson sPAPRDRConnector *drc; 1666224245bfSDavid Gibson uint64_t addr; 1667224245bfSDavid Gibson 1668e8f986fcSBharata B Rao addr = i * lmb_size + spapr->hotplug_memory.base; 1669224245bfSDavid Gibson drc = spapr_dr_connector_new(OBJECT(spapr), SPAPR_DR_CONNECTOR_TYPE_LMB, 1670224245bfSDavid Gibson addr/lmb_size); 1671224245bfSDavid Gibson qemu_register_reset(spapr_drc_reset, drc); 1672224245bfSDavid Gibson } 1673224245bfSDavid Gibson } 1674224245bfSDavid Gibson 1675224245bfSDavid Gibson /* 1676224245bfSDavid Gibson * If RAM size, maxmem size and individual node mem sizes aren't aligned 1677224245bfSDavid Gibson * to SPAPR_MEMORY_BLOCK_SIZE(256MB), then refuse to start the guest 1678224245bfSDavid Gibson * since we can't support such unaligned sizes with DRCONF_MEMORY. 1679224245bfSDavid Gibson */ 16807c150d6fSDavid Gibson static void spapr_validate_node_memory(MachineState *machine, Error **errp) 1681224245bfSDavid Gibson { 1682224245bfSDavid Gibson int i; 1683224245bfSDavid Gibson 16847c150d6fSDavid Gibson if (machine->ram_size % SPAPR_MEMORY_BLOCK_SIZE) { 16857c150d6fSDavid Gibson error_setg(errp, "Memory size 0x" RAM_ADDR_FMT 16867c150d6fSDavid Gibson " is not aligned to %llu MiB", 16877c150d6fSDavid Gibson machine->ram_size, 1688224245bfSDavid Gibson SPAPR_MEMORY_BLOCK_SIZE / M_BYTE); 16897c150d6fSDavid Gibson return; 16907c150d6fSDavid Gibson } 16917c150d6fSDavid Gibson 16927c150d6fSDavid Gibson if (machine->maxram_size % SPAPR_MEMORY_BLOCK_SIZE) { 16937c150d6fSDavid Gibson error_setg(errp, "Maximum memory size 0x" RAM_ADDR_FMT 16947c150d6fSDavid Gibson " is not aligned to %llu MiB", 16957c150d6fSDavid Gibson machine->ram_size, 16967c150d6fSDavid Gibson SPAPR_MEMORY_BLOCK_SIZE / M_BYTE); 16977c150d6fSDavid Gibson return; 1698224245bfSDavid Gibson } 1699224245bfSDavid Gibson 1700224245bfSDavid Gibson for (i = 0; i < nb_numa_nodes; i++) { 1701224245bfSDavid Gibson if (numa_info[i].node_mem % SPAPR_MEMORY_BLOCK_SIZE) { 17027c150d6fSDavid Gibson error_setg(errp, 17037c150d6fSDavid Gibson "Node %d memory size 0x%" PRIx64 17047c150d6fSDavid Gibson " is not aligned to %llu MiB", 17057c150d6fSDavid Gibson i, numa_info[i].node_mem, 1706224245bfSDavid Gibson SPAPR_MEMORY_BLOCK_SIZE / M_BYTE); 17077c150d6fSDavid Gibson return; 1708224245bfSDavid Gibson } 1709224245bfSDavid Gibson } 1710224245bfSDavid Gibson } 1711224245bfSDavid Gibson 171253018216SPaolo Bonzini /* pSeries LPAR / sPAPR hardware init */ 17133ef96221SMarcel Apfelbaum static void ppc_spapr_init(MachineState *machine) 171453018216SPaolo Bonzini { 171528e02042SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(machine); 17163c0c47e3SDavid Gibson MachineClass *mc = MACHINE_GET_CLASS(machine); 1717224245bfSDavid Gibson sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(machine); 17183ef96221SMarcel Apfelbaum const char *kernel_filename = machine->kernel_filename; 17193ef96221SMarcel Apfelbaum const char *kernel_cmdline = machine->kernel_cmdline; 17203ef96221SMarcel Apfelbaum const char *initrd_filename = machine->initrd_filename; 172153018216SPaolo Bonzini PCIHostState *phb; 172253018216SPaolo Bonzini int i; 172353018216SPaolo Bonzini MemoryRegion *sysmem = get_system_memory(); 172453018216SPaolo Bonzini MemoryRegion *ram = g_new(MemoryRegion, 1); 1725658fa66bSAlexey Kardashevskiy MemoryRegion *rma_region; 1726658fa66bSAlexey Kardashevskiy void *rma = NULL; 172753018216SPaolo Bonzini hwaddr rma_alloc_size; 1728b082d65aSAlexey Kardashevskiy hwaddr node0_size = spapr_node0_size(); 172953018216SPaolo Bonzini uint32_t initrd_base = 0; 173053018216SPaolo Bonzini long kernel_size = 0, initrd_size = 0; 1731b7d1f77aSBenjamin Herrenschmidt long load_limit, fw_size; 173216457e7fSBenjamin Herrenschmidt bool kernel_le = false; 173353018216SPaolo Bonzini char *filename; 173494a94e4cSBharata B Rao int smt = kvmppc_smt_threads(); 173594a94e4cSBharata B Rao int spapr_cores = smp_cpus / smp_threads; 173694a94e4cSBharata B Rao int spapr_max_cores = max_cpus / smp_threads; 173794a94e4cSBharata B Rao 17383c0c47e3SDavid Gibson if (mc->query_hotpluggable_cpus) { 173994a94e4cSBharata B Rao if (smp_cpus % smp_threads) { 174094a94e4cSBharata B Rao error_report("smp_cpus (%u) must be multiple of threads (%u)", 174194a94e4cSBharata B Rao smp_cpus, smp_threads); 174294a94e4cSBharata B Rao exit(1); 174394a94e4cSBharata B Rao } 174494a94e4cSBharata B Rao if (max_cpus % smp_threads) { 174594a94e4cSBharata B Rao error_report("max_cpus (%u) must be multiple of threads (%u)", 174694a94e4cSBharata B Rao max_cpus, smp_threads); 174794a94e4cSBharata B Rao exit(1); 174894a94e4cSBharata B Rao } 174994a94e4cSBharata B Rao } 175053018216SPaolo Bonzini 1751226419d6SMichael S. Tsirkin msi_nonbroken = true; 175253018216SPaolo Bonzini 175353018216SPaolo Bonzini QLIST_INIT(&spapr->phbs); 175453018216SPaolo Bonzini 175553018216SPaolo Bonzini cpu_ppc_hypercall = emulate_spapr_hypercall; 175653018216SPaolo Bonzini 175753018216SPaolo Bonzini /* Allocate RMA if necessary */ 1758658fa66bSAlexey Kardashevskiy rma_alloc_size = kvmppc_alloc_rma(&rma); 175953018216SPaolo Bonzini 176053018216SPaolo Bonzini if (rma_alloc_size == -1) { 1761730fce59SThomas Huth error_report("Unable to create RMA"); 176253018216SPaolo Bonzini exit(1); 176353018216SPaolo Bonzini } 176453018216SPaolo Bonzini 1765c4177479SAlexey Kardashevskiy if (rma_alloc_size && (rma_alloc_size < node0_size)) { 176653018216SPaolo Bonzini spapr->rma_size = rma_alloc_size; 176753018216SPaolo Bonzini } else { 1768c4177479SAlexey Kardashevskiy spapr->rma_size = node0_size; 176953018216SPaolo Bonzini 177053018216SPaolo Bonzini /* With KVM, we don't actually know whether KVM supports an 177153018216SPaolo Bonzini * unbounded RMA (PR KVM) or is limited by the hash table size 177253018216SPaolo Bonzini * (HV KVM using VRMA), so we always assume the latter 177353018216SPaolo Bonzini * 177453018216SPaolo Bonzini * In that case, we also limit the initial allocations for RTAS 177553018216SPaolo Bonzini * etc... to 256M since we have no way to know what the VRMA size 177653018216SPaolo Bonzini * is going to be as it depends on the size of the hash table 177753018216SPaolo Bonzini * isn't determined yet. 177853018216SPaolo Bonzini */ 177953018216SPaolo Bonzini if (kvm_enabled()) { 178053018216SPaolo Bonzini spapr->vrma_adjust = 1; 178153018216SPaolo Bonzini spapr->rma_size = MIN(spapr->rma_size, 0x10000000); 178253018216SPaolo Bonzini } 1783912acdf4SBenjamin Herrenschmidt 1784912acdf4SBenjamin Herrenschmidt /* Actually we don't support unbounded RMA anymore since we 1785912acdf4SBenjamin Herrenschmidt * added proper emulation of HV mode. The max we can get is 1786912acdf4SBenjamin Herrenschmidt * 16G which also happens to be what we configure for PAPR 1787912acdf4SBenjamin Herrenschmidt * mode so make sure we don't do anything bigger than that 1788912acdf4SBenjamin Herrenschmidt */ 1789912acdf4SBenjamin Herrenschmidt spapr->rma_size = MIN(spapr->rma_size, 0x400000000ull); 179053018216SPaolo Bonzini } 179153018216SPaolo Bonzini 1792c4177479SAlexey Kardashevskiy if (spapr->rma_size > node0_size) { 1793d54e4d76SDavid Gibson error_report("Numa node 0 has to span the RMA (%#08"HWADDR_PRIx")", 1794c4177479SAlexey Kardashevskiy spapr->rma_size); 1795c4177479SAlexey Kardashevskiy exit(1); 1796c4177479SAlexey Kardashevskiy } 1797c4177479SAlexey Kardashevskiy 1798b7d1f77aSBenjamin Herrenschmidt /* Setup a load limit for the ramdisk leaving room for SLOF and FDT */ 1799b7d1f77aSBenjamin Herrenschmidt load_limit = MIN(spapr->rma_size, RTAS_MAX_ADDR) - FW_OVERHEAD; 180053018216SPaolo Bonzini 18017b565160SDavid Gibson /* Set up Interrupt Controller before we create the VCPUs */ 180227f24582SBenjamin Herrenschmidt spapr->xics = xics_system_init(machine, 180394a94e4cSBharata B Rao DIV_ROUND_UP(max_cpus * smt, smp_threads), 1804161deaf2SBenjamin Herrenschmidt XICS_IRQS_SPAPR, &error_fatal); 18057b565160SDavid Gibson 1806224245bfSDavid Gibson if (smc->dr_lmb_enabled) { 18077c150d6fSDavid Gibson spapr_validate_node_memory(machine, &error_fatal); 1808224245bfSDavid Gibson } 1809224245bfSDavid Gibson 181053018216SPaolo Bonzini /* init CPUs */ 181119fb2c36SBharata B Rao if (machine->cpu_model == NULL) { 181219fb2c36SBharata B Rao machine->cpu_model = kvm_enabled() ? "host" : "POWER7"; 181353018216SPaolo Bonzini } 181494a94e4cSBharata B Rao 18153c0c47e3SDavid Gibson if (mc->query_hotpluggable_cpus) { 181694a94e4cSBharata B Rao char *type = spapr_get_cpu_core_type(machine->cpu_model); 181794a94e4cSBharata B Rao 1818*4babfaf0SThomas Huth if (type == NULL) { 1819caebf378SCédric Le Goater error_report("Unable to find sPAPR CPU Core definition"); 1820caebf378SCédric Le Goater exit(1); 1821caebf378SCédric Le Goater } 1822caebf378SCédric Le Goater 182394a94e4cSBharata B Rao spapr->cores = g_new0(Object *, spapr_max_cores); 1824af81cf32SBharata B Rao for (i = 0; i < spapr_max_cores; i++) { 182512bf2d33SGreg Kurz int core_id = i * smp_threads; 1826af81cf32SBharata B Rao sPAPRDRConnector *drc = 1827af81cf32SBharata B Rao spapr_dr_connector_new(OBJECT(spapr), 182812bf2d33SGreg Kurz SPAPR_DR_CONNECTOR_TYPE_CPU, 182912bf2d33SGreg Kurz (core_id / smp_threads) * smt); 1830af81cf32SBharata B Rao 1831af81cf32SBharata B Rao qemu_register_reset(spapr_drc_reset, drc); 1832af81cf32SBharata B Rao 1833af81cf32SBharata B Rao if (i < spapr_cores) { 1834caebf378SCédric Le Goater Object *core = object_new(type); 183594a94e4cSBharata B Rao object_property_set_int(core, smp_threads, "nr-threads", 183694a94e4cSBharata B Rao &error_fatal); 183712bf2d33SGreg Kurz object_property_set_int(core, core_id, CPU_CORE_PROP_CORE_ID, 183894a94e4cSBharata B Rao &error_fatal); 183994a94e4cSBharata B Rao object_property_set_bool(core, true, "realized", &error_fatal); 184094a94e4cSBharata B Rao } 1841af81cf32SBharata B Rao } 184294a94e4cSBharata B Rao g_free(type); 184394a94e4cSBharata B Rao } else { 184453018216SPaolo Bonzini for (i = 0; i < smp_cpus; i++) { 184594a94e4cSBharata B Rao PowerPCCPU *cpu = cpu_ppc_init(machine->cpu_model); 184653018216SPaolo Bonzini if (cpu == NULL) { 1847569f4967SDavid Gibson error_report("Unable to find PowerPC CPU definition"); 184853018216SPaolo Bonzini exit(1); 184953018216SPaolo Bonzini } 1850569f4967SDavid Gibson spapr_cpu_init(spapr, cpu, &error_fatal); 185153018216SPaolo Bonzini } 185294a94e4cSBharata B Rao } 185353018216SPaolo Bonzini 1854026bfd89SDavid Gibson if (kvm_enabled()) { 1855026bfd89SDavid Gibson /* Enable H_LOGICAL_CI_* so SLOF can talk to in-kernel devices */ 1856026bfd89SDavid Gibson kvmppc_enable_logical_ci_hcalls(); 1857ef9971ddSAlexey Kardashevskiy kvmppc_enable_set_mode_hcall(); 1858026bfd89SDavid Gibson } 1859026bfd89SDavid Gibson 186053018216SPaolo Bonzini /* allocate RAM */ 1861f92f5da1SAlexey Kardashevskiy memory_region_allocate_system_memory(ram, NULL, "ppc_spapr.ram", 1862fb164994SDavid Gibson machine->ram_size); 1863f92f5da1SAlexey Kardashevskiy memory_region_add_subregion(sysmem, 0, ram); 186453018216SPaolo Bonzini 1865658fa66bSAlexey Kardashevskiy if (rma_alloc_size && rma) { 1866658fa66bSAlexey Kardashevskiy rma_region = g_new(MemoryRegion, 1); 1867658fa66bSAlexey Kardashevskiy memory_region_init_ram_ptr(rma_region, NULL, "ppc_spapr.rma", 1868658fa66bSAlexey Kardashevskiy rma_alloc_size, rma); 1869658fa66bSAlexey Kardashevskiy vmstate_register_ram_global(rma_region); 1870658fa66bSAlexey Kardashevskiy memory_region_add_subregion(sysmem, 0, rma_region); 1871658fa66bSAlexey Kardashevskiy } 1872658fa66bSAlexey Kardashevskiy 18734a1c9cf0SBharata B Rao /* initialize hotplug memory address space */ 18744a1c9cf0SBharata B Rao if (machine->ram_size < machine->maxram_size) { 18754a1c9cf0SBharata B Rao ram_addr_t hotplug_mem_size = machine->maxram_size - machine->ram_size; 187671c9a3ddSBharata B Rao /* 187771c9a3ddSBharata B Rao * Limit the number of hotpluggable memory slots to half the number 187871c9a3ddSBharata B Rao * slots that KVM supports, leaving the other half for PCI and other 187971c9a3ddSBharata B Rao * devices. However ensure that number of slots doesn't drop below 32. 188071c9a3ddSBharata B Rao */ 188171c9a3ddSBharata B Rao int max_memslots = kvm_enabled() ? kvm_get_max_memslots() / 2 : 188271c9a3ddSBharata B Rao SPAPR_MAX_RAM_SLOTS; 18834a1c9cf0SBharata B Rao 188471c9a3ddSBharata B Rao if (max_memslots < SPAPR_MAX_RAM_SLOTS) { 188571c9a3ddSBharata B Rao max_memslots = SPAPR_MAX_RAM_SLOTS; 188671c9a3ddSBharata B Rao } 188771c9a3ddSBharata B Rao if (machine->ram_slots > max_memslots) { 1888d54e4d76SDavid Gibson error_report("Specified number of memory slots %" 1889d54e4d76SDavid Gibson PRIu64" exceeds max supported %d", 189071c9a3ddSBharata B Rao machine->ram_slots, max_memslots); 1891d54e4d76SDavid Gibson exit(1); 18924a1c9cf0SBharata B Rao } 18934a1c9cf0SBharata B Rao 18944a1c9cf0SBharata B Rao spapr->hotplug_memory.base = ROUND_UP(machine->ram_size, 18954a1c9cf0SBharata B Rao SPAPR_HOTPLUG_MEM_ALIGN); 18964a1c9cf0SBharata B Rao memory_region_init(&spapr->hotplug_memory.mr, OBJECT(spapr), 18974a1c9cf0SBharata B Rao "hotplug-memory", hotplug_mem_size); 18984a1c9cf0SBharata B Rao memory_region_add_subregion(sysmem, spapr->hotplug_memory.base, 18994a1c9cf0SBharata B Rao &spapr->hotplug_memory.mr); 19004a1c9cf0SBharata B Rao } 19014a1c9cf0SBharata B Rao 1902224245bfSDavid Gibson if (smc->dr_lmb_enabled) { 1903224245bfSDavid Gibson spapr_create_lmb_dr_connectors(spapr); 1904224245bfSDavid Gibson } 1905224245bfSDavid Gibson 190653018216SPaolo Bonzini filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, "spapr-rtas.bin"); 19074c56440dSStefan Weil if (!filename) { 1908730fce59SThomas Huth error_report("Could not find LPAR rtas '%s'", "spapr-rtas.bin"); 19094c56440dSStefan Weil exit(1); 19104c56440dSStefan Weil } 1911b7d1f77aSBenjamin Herrenschmidt spapr->rtas_size = get_image_size(filename); 19128afc22a2SZhou Jie if (spapr->rtas_size < 0) { 19138afc22a2SZhou Jie error_report("Could not get size of LPAR rtas '%s'", filename); 19148afc22a2SZhou Jie exit(1); 19158afc22a2SZhou Jie } 1916b7d1f77aSBenjamin Herrenschmidt spapr->rtas_blob = g_malloc(spapr->rtas_size); 1917b7d1f77aSBenjamin Herrenschmidt if (load_image_size(filename, spapr->rtas_blob, spapr->rtas_size) < 0) { 1918730fce59SThomas Huth error_report("Could not load LPAR rtas '%s'", filename); 191953018216SPaolo Bonzini exit(1); 192053018216SPaolo Bonzini } 192153018216SPaolo Bonzini if (spapr->rtas_size > RTAS_MAX_SIZE) { 1922730fce59SThomas Huth error_report("RTAS too big ! 0x%zx bytes (max is 0x%x)", 19232f285bddSPeter Maydell (size_t)spapr->rtas_size, RTAS_MAX_SIZE); 192453018216SPaolo Bonzini exit(1); 192553018216SPaolo Bonzini } 192653018216SPaolo Bonzini g_free(filename); 192753018216SPaolo Bonzini 192853018216SPaolo Bonzini /* Set up EPOW events infrastructure */ 192953018216SPaolo Bonzini spapr_events_init(spapr); 193053018216SPaolo Bonzini 193112f42174SDavid Gibson /* Set up the RTC RTAS interfaces */ 193228df36a1SDavid Gibson spapr_rtc_create(spapr); 193312f42174SDavid Gibson 193453018216SPaolo Bonzini /* Set up VIO bus */ 193553018216SPaolo Bonzini spapr->vio_bus = spapr_vio_bus_init(); 193653018216SPaolo Bonzini 193753018216SPaolo Bonzini for (i = 0; i < MAX_SERIAL_PORTS; i++) { 193853018216SPaolo Bonzini if (serial_hds[i]) { 193953018216SPaolo Bonzini spapr_vty_create(spapr->vio_bus, serial_hds[i]); 194053018216SPaolo Bonzini } 194153018216SPaolo Bonzini } 194253018216SPaolo Bonzini 194353018216SPaolo Bonzini /* We always have at least the nvram device on VIO */ 194453018216SPaolo Bonzini spapr_create_nvram(spapr); 194553018216SPaolo Bonzini 194653018216SPaolo Bonzini /* Set up PCI */ 194753018216SPaolo Bonzini spapr_pci_rtas_init(); 194853018216SPaolo Bonzini 194989dfd6e1SDavid Gibson phb = spapr_create_phb(spapr, 0); 195053018216SPaolo Bonzini 195153018216SPaolo Bonzini for (i = 0; i < nb_nics; i++) { 195253018216SPaolo Bonzini NICInfo *nd = &nd_table[i]; 195353018216SPaolo Bonzini 195453018216SPaolo Bonzini if (!nd->model) { 195553018216SPaolo Bonzini nd->model = g_strdup("ibmveth"); 195653018216SPaolo Bonzini } 195753018216SPaolo Bonzini 195853018216SPaolo Bonzini if (strcmp(nd->model, "ibmveth") == 0) { 195953018216SPaolo Bonzini spapr_vlan_create(spapr->vio_bus, nd); 196053018216SPaolo Bonzini } else { 196129b358f9SDavid Gibson pci_nic_init_nofail(&nd_table[i], phb->bus, nd->model, NULL); 196253018216SPaolo Bonzini } 196353018216SPaolo Bonzini } 196453018216SPaolo Bonzini 196553018216SPaolo Bonzini for (i = 0; i <= drive_get_max_bus(IF_SCSI); i++) { 196653018216SPaolo Bonzini spapr_vscsi_create(spapr->vio_bus); 196753018216SPaolo Bonzini } 196853018216SPaolo Bonzini 196953018216SPaolo Bonzini /* Graphics */ 197014c6a894SDavid Gibson if (spapr_vga_init(phb->bus, &error_fatal)) { 197153018216SPaolo Bonzini spapr->has_graphics = true; 1972c6e76503SPaolo Bonzini machine->usb |= defaults_enabled() && !machine->usb_disabled; 197353018216SPaolo Bonzini } 197453018216SPaolo Bonzini 19754ee9ced9SMarcel Apfelbaum if (machine->usb) { 197657040d45SThomas Huth if (smc->use_ohci_by_default) { 197753018216SPaolo Bonzini pci_create_simple(phb->bus, -1, "pci-ohci"); 197857040d45SThomas Huth } else { 197957040d45SThomas Huth pci_create_simple(phb->bus, -1, "nec-usb-xhci"); 198057040d45SThomas Huth } 1981c86580b8SMarkus Armbruster 198253018216SPaolo Bonzini if (spapr->has_graphics) { 1983c86580b8SMarkus Armbruster USBBus *usb_bus = usb_bus_find(-1); 1984c86580b8SMarkus Armbruster 1985c86580b8SMarkus Armbruster usb_create_simple(usb_bus, "usb-kbd"); 1986c86580b8SMarkus Armbruster usb_create_simple(usb_bus, "usb-mouse"); 198753018216SPaolo Bonzini } 198853018216SPaolo Bonzini } 198953018216SPaolo Bonzini 199053018216SPaolo Bonzini if (spapr->rma_size < (MIN_RMA_SLOF << 20)) { 1991d54e4d76SDavid Gibson error_report( 1992d54e4d76SDavid Gibson "pSeries SLOF firmware requires >= %ldM guest RMA (Real Mode Area memory)", 1993d54e4d76SDavid Gibson MIN_RMA_SLOF); 199453018216SPaolo Bonzini exit(1); 199553018216SPaolo Bonzini } 199653018216SPaolo Bonzini 199753018216SPaolo Bonzini if (kernel_filename) { 199853018216SPaolo Bonzini uint64_t lowaddr = 0; 199953018216SPaolo Bonzini 200053018216SPaolo Bonzini kernel_size = load_elf(kernel_filename, translate_kernel_address, NULL, 20017ef295eaSPeter Crosthwaite NULL, &lowaddr, NULL, 1, PPC_ELF_MACHINE, 20027ef295eaSPeter Crosthwaite 0, 0); 20033b66da82SAlexey Kardashevskiy if (kernel_size == ELF_LOAD_WRONG_ENDIAN) { 200416457e7fSBenjamin Herrenschmidt kernel_size = load_elf(kernel_filename, 200516457e7fSBenjamin Herrenschmidt translate_kernel_address, NULL, 20067ef295eaSPeter Crosthwaite NULL, &lowaddr, NULL, 0, PPC_ELF_MACHINE, 20077ef295eaSPeter Crosthwaite 0, 0); 200816457e7fSBenjamin Herrenschmidt kernel_le = kernel_size > 0; 200916457e7fSBenjamin Herrenschmidt } 201016457e7fSBenjamin Herrenschmidt if (kernel_size < 0) { 2011d54e4d76SDavid Gibson error_report("error loading %s: %s", 20123b66da82SAlexey Kardashevskiy kernel_filename, load_elf_strerror(kernel_size)); 201353018216SPaolo Bonzini exit(1); 201453018216SPaolo Bonzini } 201553018216SPaolo Bonzini 201653018216SPaolo Bonzini /* load initrd */ 201753018216SPaolo Bonzini if (initrd_filename) { 201853018216SPaolo Bonzini /* Try to locate the initrd in the gap between the kernel 201953018216SPaolo Bonzini * and the firmware. Add a bit of space just in case 202053018216SPaolo Bonzini */ 202153018216SPaolo Bonzini initrd_base = (KERNEL_LOAD_ADDR + kernel_size + 0x1ffff) & ~0xffff; 202253018216SPaolo Bonzini initrd_size = load_image_targphys(initrd_filename, initrd_base, 202353018216SPaolo Bonzini load_limit - initrd_base); 202453018216SPaolo Bonzini if (initrd_size < 0) { 2025d54e4d76SDavid Gibson error_report("could not load initial ram disk '%s'", 202653018216SPaolo Bonzini initrd_filename); 202753018216SPaolo Bonzini exit(1); 202853018216SPaolo Bonzini } 202953018216SPaolo Bonzini } else { 203053018216SPaolo Bonzini initrd_base = 0; 203153018216SPaolo Bonzini initrd_size = 0; 203253018216SPaolo Bonzini } 203353018216SPaolo Bonzini } 203453018216SPaolo Bonzini 20358e7ea787SAndreas Färber if (bios_name == NULL) { 20368e7ea787SAndreas Färber bios_name = FW_FILE_NAME; 20378e7ea787SAndreas Färber } 20388e7ea787SAndreas Färber filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name); 20394c56440dSStefan Weil if (!filename) { 204068fea5a0SThomas Huth error_report("Could not find LPAR firmware '%s'", bios_name); 20414c56440dSStefan Weil exit(1); 20424c56440dSStefan Weil } 204353018216SPaolo Bonzini fw_size = load_image_targphys(filename, 0, FW_MAX_SIZE); 204468fea5a0SThomas Huth if (fw_size <= 0) { 204568fea5a0SThomas Huth error_report("Could not load LPAR firmware '%s'", filename); 204653018216SPaolo Bonzini exit(1); 204753018216SPaolo Bonzini } 204853018216SPaolo Bonzini g_free(filename); 204953018216SPaolo Bonzini 205028e02042SDavid Gibson /* FIXME: Should register things through the MachineState's qdev 205128e02042SDavid Gibson * interface, this is a legacy from the sPAPREnvironment structure 205228e02042SDavid Gibson * which predated MachineState but had a similar function */ 20534be21d56SDavid Gibson vmstate_register(NULL, 0, &vmstate_spapr, spapr); 20544be21d56SDavid Gibson register_savevm_live(NULL, "spapr/htab", -1, 1, 20554be21d56SDavid Gibson &savevm_htab_handlers, spapr); 20564be21d56SDavid Gibson 205753018216SPaolo Bonzini /* Prepare the device tree */ 20583bbf37f2SAndreas Färber spapr->fdt_skel = spapr_create_fdt_skel(initrd_base, initrd_size, 205916457e7fSBenjamin Herrenschmidt kernel_size, kernel_le, 206031fe14d1SNathan Fontenot kernel_cmdline, 206131fe14d1SNathan Fontenot spapr->check_exception_irq); 206253018216SPaolo Bonzini assert(spapr->fdt_skel != NULL); 20635b2128d2SAlexander Graf 206446503c2bSMichael Roth /* used by RTAS */ 206546503c2bSMichael Roth QTAILQ_INIT(&spapr->ccs_list); 206646503c2bSMichael Roth qemu_register_reset(spapr_ccs_reset_hook, spapr); 206746503c2bSMichael Roth 20685b2128d2SAlexander Graf qemu_register_boot_set(spapr_boot_set, spapr); 206953018216SPaolo Bonzini } 207053018216SPaolo Bonzini 2071135a129aSAneesh Kumar K.V static int spapr_kvm_type(const char *vm_type) 2072135a129aSAneesh Kumar K.V { 2073135a129aSAneesh Kumar K.V if (!vm_type) { 2074135a129aSAneesh Kumar K.V return 0; 2075135a129aSAneesh Kumar K.V } 2076135a129aSAneesh Kumar K.V 2077135a129aSAneesh Kumar K.V if (!strcmp(vm_type, "HV")) { 2078135a129aSAneesh Kumar K.V return 1; 2079135a129aSAneesh Kumar K.V } 2080135a129aSAneesh Kumar K.V 2081135a129aSAneesh Kumar K.V if (!strcmp(vm_type, "PR")) { 2082135a129aSAneesh Kumar K.V return 2; 2083135a129aSAneesh Kumar K.V } 2084135a129aSAneesh Kumar K.V 2085135a129aSAneesh Kumar K.V error_report("Unknown kvm-type specified '%s'", vm_type); 2086135a129aSAneesh Kumar K.V exit(1); 2087135a129aSAneesh Kumar K.V } 2088135a129aSAneesh Kumar K.V 208971461b0fSAlexey Kardashevskiy /* 2090627b84f4SGonglei * Implementation of an interface to adjust firmware path 209171461b0fSAlexey Kardashevskiy * for the bootindex property handling. 209271461b0fSAlexey Kardashevskiy */ 209371461b0fSAlexey Kardashevskiy static char *spapr_get_fw_dev_path(FWPathProvider *p, BusState *bus, 209471461b0fSAlexey Kardashevskiy DeviceState *dev) 209571461b0fSAlexey Kardashevskiy { 209671461b0fSAlexey Kardashevskiy #define CAST(type, obj, name) \ 209771461b0fSAlexey Kardashevskiy ((type *)object_dynamic_cast(OBJECT(obj), (name))) 209871461b0fSAlexey Kardashevskiy SCSIDevice *d = CAST(SCSIDevice, dev, TYPE_SCSI_DEVICE); 209971461b0fSAlexey Kardashevskiy sPAPRPHBState *phb = CAST(sPAPRPHBState, dev, TYPE_SPAPR_PCI_HOST_BRIDGE); 210071461b0fSAlexey Kardashevskiy 210171461b0fSAlexey Kardashevskiy if (d) { 210271461b0fSAlexey Kardashevskiy void *spapr = CAST(void, bus->parent, "spapr-vscsi"); 210371461b0fSAlexey Kardashevskiy VirtIOSCSI *virtio = CAST(VirtIOSCSI, bus->parent, TYPE_VIRTIO_SCSI); 210471461b0fSAlexey Kardashevskiy USBDevice *usb = CAST(USBDevice, bus->parent, TYPE_USB_DEVICE); 210571461b0fSAlexey Kardashevskiy 210671461b0fSAlexey Kardashevskiy if (spapr) { 210771461b0fSAlexey Kardashevskiy /* 210871461b0fSAlexey Kardashevskiy * Replace "channel@0/disk@0,0" with "disk@8000000000000000": 210971461b0fSAlexey Kardashevskiy * We use SRP luns of the form 8000 | (bus << 8) | (id << 5) | lun 211071461b0fSAlexey Kardashevskiy * in the top 16 bits of the 64-bit LUN 211171461b0fSAlexey Kardashevskiy */ 211271461b0fSAlexey Kardashevskiy unsigned id = 0x8000 | (d->id << 8) | d->lun; 211371461b0fSAlexey Kardashevskiy return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev), 211471461b0fSAlexey Kardashevskiy (uint64_t)id << 48); 211571461b0fSAlexey Kardashevskiy } else if (virtio) { 211671461b0fSAlexey Kardashevskiy /* 211771461b0fSAlexey Kardashevskiy * We use SRP luns of the form 01000000 | (target << 8) | lun 211871461b0fSAlexey Kardashevskiy * in the top 32 bits of the 64-bit LUN 211971461b0fSAlexey Kardashevskiy * Note: the quote above is from SLOF and it is wrong, 212071461b0fSAlexey Kardashevskiy * the actual binding is: 212171461b0fSAlexey Kardashevskiy * swap 0100 or 10 << or 20 << ( target lun-id -- srplun ) 212271461b0fSAlexey Kardashevskiy */ 212371461b0fSAlexey Kardashevskiy unsigned id = 0x1000000 | (d->id << 16) | d->lun; 212471461b0fSAlexey Kardashevskiy return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev), 212571461b0fSAlexey Kardashevskiy (uint64_t)id << 32); 212671461b0fSAlexey Kardashevskiy } else if (usb) { 212771461b0fSAlexey Kardashevskiy /* 212871461b0fSAlexey Kardashevskiy * We use SRP luns of the form 01000000 | (usb-port << 16) | lun 212971461b0fSAlexey Kardashevskiy * in the top 32 bits of the 64-bit LUN 213071461b0fSAlexey Kardashevskiy */ 213171461b0fSAlexey Kardashevskiy unsigned usb_port = atoi(usb->port->path); 213271461b0fSAlexey Kardashevskiy unsigned id = 0x1000000 | (usb_port << 16) | d->lun; 213371461b0fSAlexey Kardashevskiy return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev), 213471461b0fSAlexey Kardashevskiy (uint64_t)id << 32); 213571461b0fSAlexey Kardashevskiy } 213671461b0fSAlexey Kardashevskiy } 213771461b0fSAlexey Kardashevskiy 213871461b0fSAlexey Kardashevskiy if (phb) { 213971461b0fSAlexey Kardashevskiy /* Replace "pci" with "pci@800000020000000" */ 214071461b0fSAlexey Kardashevskiy return g_strdup_printf("pci@%"PRIX64, phb->buid); 214171461b0fSAlexey Kardashevskiy } 214271461b0fSAlexey Kardashevskiy 214371461b0fSAlexey Kardashevskiy return NULL; 214471461b0fSAlexey Kardashevskiy } 214571461b0fSAlexey Kardashevskiy 214623825581SEduardo Habkost static char *spapr_get_kvm_type(Object *obj, Error **errp) 214723825581SEduardo Habkost { 214828e02042SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 214923825581SEduardo Habkost 215028e02042SDavid Gibson return g_strdup(spapr->kvm_type); 215123825581SEduardo Habkost } 215223825581SEduardo Habkost 215323825581SEduardo Habkost static void spapr_set_kvm_type(Object *obj, const char *value, Error **errp) 215423825581SEduardo Habkost { 215528e02042SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 215623825581SEduardo Habkost 215728e02042SDavid Gibson g_free(spapr->kvm_type); 215828e02042SDavid Gibson spapr->kvm_type = g_strdup(value); 215923825581SEduardo Habkost } 216023825581SEduardo Habkost 216123825581SEduardo Habkost static void spapr_machine_initfn(Object *obj) 216223825581SEduardo Habkost { 2163715c5407SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 2164715c5407SDavid Gibson 2165715c5407SDavid Gibson spapr->htab_fd = -1; 216623825581SEduardo Habkost object_property_add_str(obj, "kvm-type", 216723825581SEduardo Habkost spapr_get_kvm_type, spapr_set_kvm_type, NULL); 216849d2e648SMarcel Apfelbaum object_property_set_description(obj, "kvm-type", 216949d2e648SMarcel Apfelbaum "Specifies the KVM virtualization mode (HV, PR)", 217049d2e648SMarcel Apfelbaum NULL); 217123825581SEduardo Habkost } 217223825581SEduardo Habkost 217387bbdd9cSDavid Gibson static void spapr_machine_finalizefn(Object *obj) 217487bbdd9cSDavid Gibson { 217587bbdd9cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 217687bbdd9cSDavid Gibson 217787bbdd9cSDavid Gibson g_free(spapr->kvm_type); 217887bbdd9cSDavid Gibson } 217987bbdd9cSDavid Gibson 218034316482SAlexey Kardashevskiy static void ppc_cpu_do_nmi_on_cpu(void *arg) 218134316482SAlexey Kardashevskiy { 218234316482SAlexey Kardashevskiy CPUState *cs = arg; 218334316482SAlexey Kardashevskiy 218434316482SAlexey Kardashevskiy cpu_synchronize_state(cs); 218534316482SAlexey Kardashevskiy ppc_cpu_do_system_reset(cs); 218634316482SAlexey Kardashevskiy } 218734316482SAlexey Kardashevskiy 218834316482SAlexey Kardashevskiy static void spapr_nmi(NMIState *n, int cpu_index, Error **errp) 218934316482SAlexey Kardashevskiy { 219034316482SAlexey Kardashevskiy CPUState *cs; 219134316482SAlexey Kardashevskiy 219234316482SAlexey Kardashevskiy CPU_FOREACH(cs) { 219334316482SAlexey Kardashevskiy async_run_on_cpu(cs, ppc_cpu_do_nmi_on_cpu, cs); 219434316482SAlexey Kardashevskiy } 219534316482SAlexey Kardashevskiy } 219634316482SAlexey Kardashevskiy 2197c20d332aSBharata B Rao static void spapr_add_lmbs(DeviceState *dev, uint64_t addr, uint64_t size, 2198c20d332aSBharata B Rao uint32_t node, Error **errp) 2199c20d332aSBharata B Rao { 2200c20d332aSBharata B Rao sPAPRDRConnector *drc; 2201c20d332aSBharata B Rao sPAPRDRConnectorClass *drck; 2202c20d332aSBharata B Rao uint32_t nr_lmbs = size/SPAPR_MEMORY_BLOCK_SIZE; 2203c20d332aSBharata B Rao int i, fdt_offset, fdt_size; 2204c20d332aSBharata B Rao void *fdt; 2205c20d332aSBharata B Rao 2206c20d332aSBharata B Rao for (i = 0; i < nr_lmbs; i++) { 2207c20d332aSBharata B Rao drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_LMB, 2208c20d332aSBharata B Rao addr/SPAPR_MEMORY_BLOCK_SIZE); 2209c20d332aSBharata B Rao g_assert(drc); 2210c20d332aSBharata B Rao 2211c20d332aSBharata B Rao fdt = create_device_tree(&fdt_size); 2212c20d332aSBharata B Rao fdt_offset = spapr_populate_memory_node(fdt, node, addr, 2213c20d332aSBharata B Rao SPAPR_MEMORY_BLOCK_SIZE); 2214c20d332aSBharata B Rao 2215c20d332aSBharata B Rao drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 2216c20d332aSBharata B Rao drck->attach(drc, dev, fdt, fdt_offset, !dev->hotplugged, errp); 2217c20d332aSBharata B Rao addr += SPAPR_MEMORY_BLOCK_SIZE; 2218c20d332aSBharata B Rao } 22195dd5238cSJianjun Duan /* send hotplug notification to the 22205dd5238cSJianjun Duan * guest only in case of hotplugged memory 22215dd5238cSJianjun Duan */ 22225dd5238cSJianjun Duan if (dev->hotplugged) { 22230a417869SBharata B Rao spapr_hotplug_req_add_by_count(SPAPR_DR_CONNECTOR_TYPE_LMB, nr_lmbs); 2224c20d332aSBharata B Rao } 22255dd5238cSJianjun Duan } 2226c20d332aSBharata B Rao 2227c20d332aSBharata B Rao static void spapr_memory_plug(HotplugHandler *hotplug_dev, DeviceState *dev, 2228c20d332aSBharata B Rao uint32_t node, Error **errp) 2229c20d332aSBharata B Rao { 2230c20d332aSBharata B Rao Error *local_err = NULL; 2231c20d332aSBharata B Rao sPAPRMachineState *ms = SPAPR_MACHINE(hotplug_dev); 2232c20d332aSBharata B Rao PCDIMMDevice *dimm = PC_DIMM(dev); 2233c20d332aSBharata B Rao PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); 2234c20d332aSBharata B Rao MemoryRegion *mr = ddc->get_memory_region(dimm); 2235c20d332aSBharata B Rao uint64_t align = memory_region_get_alignment(mr); 2236c20d332aSBharata B Rao uint64_t size = memory_region_size(mr); 2237c20d332aSBharata B Rao uint64_t addr; 2238c20d332aSBharata B Rao 2239c20d332aSBharata B Rao if (size % SPAPR_MEMORY_BLOCK_SIZE) { 2240c20d332aSBharata B Rao error_setg(&local_err, "Hotplugged memory size must be a multiple of " 2241c20d332aSBharata B Rao "%lld MB", SPAPR_MEMORY_BLOCK_SIZE/M_BYTE); 2242c20d332aSBharata B Rao goto out; 2243c20d332aSBharata B Rao } 2244c20d332aSBharata B Rao 2245d6a9b0b8SMichael S. Tsirkin pc_dimm_memory_plug(dev, &ms->hotplug_memory, mr, align, &local_err); 2246c20d332aSBharata B Rao if (local_err) { 2247c20d332aSBharata B Rao goto out; 2248c20d332aSBharata B Rao } 2249c20d332aSBharata B Rao 2250c20d332aSBharata B Rao addr = object_property_get_int(OBJECT(dimm), PC_DIMM_ADDR_PROP, &local_err); 2251c20d332aSBharata B Rao if (local_err) { 2252c20d332aSBharata B Rao pc_dimm_memory_unplug(dev, &ms->hotplug_memory, mr); 2253c20d332aSBharata B Rao goto out; 2254c20d332aSBharata B Rao } 2255c20d332aSBharata B Rao 2256c20d332aSBharata B Rao spapr_add_lmbs(dev, addr, size, node, &error_abort); 2257c20d332aSBharata B Rao 2258c20d332aSBharata B Rao out: 2259c20d332aSBharata B Rao error_propagate(errp, local_err); 2260c20d332aSBharata B Rao } 2261c20d332aSBharata B Rao 2262af81cf32SBharata B Rao void *spapr_populate_hotplug_cpu_dt(CPUState *cs, int *fdt_offset, 2263af81cf32SBharata B Rao sPAPRMachineState *spapr) 2264af81cf32SBharata B Rao { 2265af81cf32SBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(cs); 2266af81cf32SBharata B Rao DeviceClass *dc = DEVICE_GET_CLASS(cs); 2267af81cf32SBharata B Rao int id = ppc_get_vcpu_dt_id(cpu); 2268af81cf32SBharata B Rao void *fdt; 2269af81cf32SBharata B Rao int offset, fdt_size; 2270af81cf32SBharata B Rao char *nodename; 2271af81cf32SBharata B Rao 2272af81cf32SBharata B Rao fdt = create_device_tree(&fdt_size); 2273af81cf32SBharata B Rao nodename = g_strdup_printf("%s@%x", dc->fw_name, id); 2274af81cf32SBharata B Rao offset = fdt_add_subnode(fdt, 0, nodename); 2275af81cf32SBharata B Rao 2276af81cf32SBharata B Rao spapr_populate_cpu_dt(cs, fdt, offset, spapr); 2277af81cf32SBharata B Rao g_free(nodename); 2278af81cf32SBharata B Rao 2279af81cf32SBharata B Rao *fdt_offset = offset; 2280af81cf32SBharata B Rao return fdt; 2281af81cf32SBharata B Rao } 2282af81cf32SBharata B Rao 2283c20d332aSBharata B Rao static void spapr_machine_device_plug(HotplugHandler *hotplug_dev, 2284c20d332aSBharata B Rao DeviceState *dev, Error **errp) 2285c20d332aSBharata B Rao { 2286c20d332aSBharata B Rao sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(qdev_get_machine()); 2287c20d332aSBharata B Rao 2288c20d332aSBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { 2289b556854bSBharata B Rao int node; 2290c20d332aSBharata B Rao 2291c20d332aSBharata B Rao if (!smc->dr_lmb_enabled) { 2292c20d332aSBharata B Rao error_setg(errp, "Memory hotplug not supported for this machine"); 2293c20d332aSBharata B Rao return; 2294c20d332aSBharata B Rao } 2295c20d332aSBharata B Rao node = object_property_get_int(OBJECT(dev), PC_DIMM_NODE_PROP, errp); 2296c20d332aSBharata B Rao if (*errp) { 2297c20d332aSBharata B Rao return; 2298c20d332aSBharata B Rao } 22991a5512bbSGonglei if (node < 0 || node >= MAX_NODES) { 23001a5512bbSGonglei error_setg(errp, "Invaild node %d", node); 23011a5512bbSGonglei return; 23021a5512bbSGonglei } 2303c20d332aSBharata B Rao 2304b556854bSBharata B Rao /* 2305b556854bSBharata B Rao * Currently PowerPC kernel doesn't allow hot-adding memory to 2306b556854bSBharata B Rao * memory-less node, but instead will silently add the memory 2307b556854bSBharata B Rao * to the first node that has some memory. This causes two 2308b556854bSBharata B Rao * unexpected behaviours for the user. 2309b556854bSBharata B Rao * 2310b556854bSBharata B Rao * - Memory gets hotplugged to a different node than what the user 2311b556854bSBharata B Rao * specified. 2312b556854bSBharata B Rao * - Since pc-dimm subsystem in QEMU still thinks that memory belongs 2313b556854bSBharata B Rao * to memory-less node, a reboot will set things accordingly 2314b556854bSBharata B Rao * and the previously hotplugged memory now ends in the right node. 2315b556854bSBharata B Rao * This appears as if some memory moved from one node to another. 2316b556854bSBharata B Rao * 2317b556854bSBharata B Rao * So until kernel starts supporting memory hotplug to memory-less 2318b556854bSBharata B Rao * nodes, just prevent such attempts upfront in QEMU. 2319b556854bSBharata B Rao */ 2320b556854bSBharata B Rao if (nb_numa_nodes && !numa_info[node].node_mem) { 2321b556854bSBharata B Rao error_setg(errp, "Can't hotplug memory to memory-less node %d", 2322b556854bSBharata B Rao node); 2323b556854bSBharata B Rao return; 2324b556854bSBharata B Rao } 2325b556854bSBharata B Rao 2326c20d332aSBharata B Rao spapr_memory_plug(hotplug_dev, dev, node, errp); 2327af81cf32SBharata B Rao } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 2328af81cf32SBharata B Rao spapr_core_plug(hotplug_dev, dev, errp); 2329c20d332aSBharata B Rao } 2330c20d332aSBharata B Rao } 2331c20d332aSBharata B Rao 2332c20d332aSBharata B Rao static void spapr_machine_device_unplug(HotplugHandler *hotplug_dev, 2333c20d332aSBharata B Rao DeviceState *dev, Error **errp) 2334c20d332aSBharata B Rao { 23353c0c47e3SDavid Gibson MachineClass *mc = MACHINE_GET_CLASS(qdev_get_machine()); 23366f4b5c3eSBharata B Rao 2337c20d332aSBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { 2338c20d332aSBharata B Rao error_setg(errp, "Memory hot unplug not supported by sPAPR"); 23396f4b5c3eSBharata B Rao } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 23403c0c47e3SDavid Gibson if (!mc->query_hotpluggable_cpus) { 23416f4b5c3eSBharata B Rao error_setg(errp, "CPU hot unplug not supported on this machine"); 23426f4b5c3eSBharata B Rao return; 23436f4b5c3eSBharata B Rao } 23446f4b5c3eSBharata B Rao spapr_core_unplug(hotplug_dev, dev, errp); 2345c20d332aSBharata B Rao } 2346c20d332aSBharata B Rao } 2347c20d332aSBharata B Rao 234894a94e4cSBharata B Rao static void spapr_machine_device_pre_plug(HotplugHandler *hotplug_dev, 234994a94e4cSBharata B Rao DeviceState *dev, Error **errp) 235094a94e4cSBharata B Rao { 235194a94e4cSBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 235294a94e4cSBharata B Rao spapr_core_pre_plug(hotplug_dev, dev, errp); 235394a94e4cSBharata B Rao } 235494a94e4cSBharata B Rao } 235594a94e4cSBharata B Rao 2356c20d332aSBharata B Rao static HotplugHandler *spapr_get_hotpug_handler(MachineState *machine, 2357c20d332aSBharata B Rao DeviceState *dev) 2358c20d332aSBharata B Rao { 235994a94e4cSBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM) || 236094a94e4cSBharata B Rao object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 2361c20d332aSBharata B Rao return HOTPLUG_HANDLER(machine); 2362c20d332aSBharata B Rao } 2363c20d332aSBharata B Rao return NULL; 2364c20d332aSBharata B Rao } 2365c20d332aSBharata B Rao 236620bb648dSDavid Gibson static unsigned spapr_cpu_index_to_socket_id(unsigned cpu_index) 236720bb648dSDavid Gibson { 236820bb648dSDavid Gibson /* Allocate to NUMA nodes on a "socket" basis (not that concept of 236920bb648dSDavid Gibson * socket means much for the paravirtualized PAPR platform) */ 237020bb648dSDavid Gibson return cpu_index / smp_threads / smp_cores; 237120bb648dSDavid Gibson } 237220bb648dSDavid Gibson 23732474bfd4SIgor Mammedov static HotpluggableCPUList *spapr_query_hotpluggable_cpus(MachineState *machine) 23742474bfd4SIgor Mammedov { 23752474bfd4SIgor Mammedov int i; 23762474bfd4SIgor Mammedov HotpluggableCPUList *head = NULL; 23772474bfd4SIgor Mammedov sPAPRMachineState *spapr = SPAPR_MACHINE(machine); 23782474bfd4SIgor Mammedov int spapr_max_cores = max_cpus / smp_threads; 23792474bfd4SIgor Mammedov 23802474bfd4SIgor Mammedov for (i = 0; i < spapr_max_cores; i++) { 23812474bfd4SIgor Mammedov HotpluggableCPUList *list_item = g_new0(typeof(*list_item), 1); 23822474bfd4SIgor Mammedov HotpluggableCPU *cpu_item = g_new0(typeof(*cpu_item), 1); 23832474bfd4SIgor Mammedov CpuInstanceProperties *cpu_props = g_new0(typeof(*cpu_props), 1); 23842474bfd4SIgor Mammedov 23852474bfd4SIgor Mammedov cpu_item->type = spapr_get_cpu_core_type(machine->cpu_model); 23862474bfd4SIgor Mammedov cpu_item->vcpus_count = smp_threads; 238727393c33SPeter Krempa cpu_props->has_core_id = true; 238812bf2d33SGreg Kurz cpu_props->core_id = i * smp_threads; 23892474bfd4SIgor Mammedov /* TODO: add 'has_node/node' here to describe 23902474bfd4SIgor Mammedov to which node core belongs */ 23912474bfd4SIgor Mammedov 23922474bfd4SIgor Mammedov cpu_item->props = cpu_props; 23932474bfd4SIgor Mammedov if (spapr->cores[i]) { 23942474bfd4SIgor Mammedov cpu_item->has_qom_path = true; 23952474bfd4SIgor Mammedov cpu_item->qom_path = object_get_canonical_path(spapr->cores[i]); 23962474bfd4SIgor Mammedov } 23972474bfd4SIgor Mammedov list_item->value = cpu_item; 23982474bfd4SIgor Mammedov list_item->next = head; 23992474bfd4SIgor Mammedov head = list_item; 24002474bfd4SIgor Mammedov } 24012474bfd4SIgor Mammedov return head; 24022474bfd4SIgor Mammedov } 24032474bfd4SIgor Mammedov 240429ee3247SAlexey Kardashevskiy static void spapr_machine_class_init(ObjectClass *oc, void *data) 240553018216SPaolo Bonzini { 240629ee3247SAlexey Kardashevskiy MachineClass *mc = MACHINE_CLASS(oc); 2407224245bfSDavid Gibson sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(oc); 240871461b0fSAlexey Kardashevskiy FWPathProviderClass *fwc = FW_PATH_PROVIDER_CLASS(oc); 240934316482SAlexey Kardashevskiy NMIClass *nc = NMI_CLASS(oc); 2410c20d332aSBharata B Rao HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(oc); 241129ee3247SAlexey Kardashevskiy 24120eb9054cSDavid Gibson mc->desc = "pSeries Logical Partition (PAPR compliant)"; 2413fc9f38c3SDavid Gibson 2414fc9f38c3SDavid Gibson /* 2415fc9f38c3SDavid Gibson * We set up the default / latest behaviour here. The class_init 2416fc9f38c3SDavid Gibson * functions for the specific versioned machine types can override 2417fc9f38c3SDavid Gibson * these details for backwards compatibility 2418fc9f38c3SDavid Gibson */ 2419958db90cSMarcel Apfelbaum mc->init = ppc_spapr_init; 2420958db90cSMarcel Apfelbaum mc->reset = ppc_spapr_reset; 2421958db90cSMarcel Apfelbaum mc->block_default_type = IF_SCSI; 242238b02bd8SAlexey Kardashevskiy mc->max_cpus = MAX_CPUMASK_BITS; 2423958db90cSMarcel Apfelbaum mc->no_parallel = 1; 24245b2128d2SAlexander Graf mc->default_boot_order = ""; 2425a34944feSNikunj A Dadhania mc->default_ram_size = 512 * M_BYTE; 2426958db90cSMarcel Apfelbaum mc->kvm_type = spapr_kvm_type; 24279e3f9733SAlexander Graf mc->has_dynamic_sysbus = true; 2428e4024630SLaurent Vivier mc->pci_allow_0_address = true; 2429c20d332aSBharata B Rao mc->get_hotplug_handler = spapr_get_hotpug_handler; 243094a94e4cSBharata B Rao hc->pre_plug = spapr_machine_device_pre_plug; 2431c20d332aSBharata B Rao hc->plug = spapr_machine_device_plug; 2432c20d332aSBharata B Rao hc->unplug = spapr_machine_device_unplug; 243320bb648dSDavid Gibson mc->cpu_index_to_socket_id = spapr_cpu_index_to_socket_id; 243400b4fbe2SMarcel Apfelbaum 2435fc9f38c3SDavid Gibson smc->dr_lmb_enabled = true; 24363c0c47e3SDavid Gibson mc->query_hotpluggable_cpus = spapr_query_hotpluggable_cpus; 243771461b0fSAlexey Kardashevskiy fwc->get_dev_path = spapr_get_fw_dev_path; 243834316482SAlexey Kardashevskiy nc->nmi_monitor_handler = spapr_nmi; 243953018216SPaolo Bonzini } 244053018216SPaolo Bonzini 244129ee3247SAlexey Kardashevskiy static const TypeInfo spapr_machine_info = { 244229ee3247SAlexey Kardashevskiy .name = TYPE_SPAPR_MACHINE, 244329ee3247SAlexey Kardashevskiy .parent = TYPE_MACHINE, 24444aee7362SDavid Gibson .abstract = true, 24456ca1502eSAlexey Kardashevskiy .instance_size = sizeof(sPAPRMachineState), 244623825581SEduardo Habkost .instance_init = spapr_machine_initfn, 244787bbdd9cSDavid Gibson .instance_finalize = spapr_machine_finalizefn, 2448183930c0SDavid Gibson .class_size = sizeof(sPAPRMachineClass), 244929ee3247SAlexey Kardashevskiy .class_init = spapr_machine_class_init, 245071461b0fSAlexey Kardashevskiy .interfaces = (InterfaceInfo[]) { 245171461b0fSAlexey Kardashevskiy { TYPE_FW_PATH_PROVIDER }, 245234316482SAlexey Kardashevskiy { TYPE_NMI }, 2453c20d332aSBharata B Rao { TYPE_HOTPLUG_HANDLER }, 245471461b0fSAlexey Kardashevskiy { } 245571461b0fSAlexey Kardashevskiy }, 245629ee3247SAlexey Kardashevskiy }; 245729ee3247SAlexey Kardashevskiy 2458fccbc785SDavid Gibson #define DEFINE_SPAPR_MACHINE(suffix, verstr, latest) \ 24595013c547SDavid Gibson static void spapr_machine_##suffix##_class_init(ObjectClass *oc, \ 24605013c547SDavid Gibson void *data) \ 24615013c547SDavid Gibson { \ 24625013c547SDavid Gibson MachineClass *mc = MACHINE_CLASS(oc); \ 24635013c547SDavid Gibson spapr_machine_##suffix##_class_options(mc); \ 2464fccbc785SDavid Gibson if (latest) { \ 2465fccbc785SDavid Gibson mc->alias = "pseries"; \ 2466fccbc785SDavid Gibson mc->is_default = 1; \ 2467fccbc785SDavid Gibson } \ 24685013c547SDavid Gibson } \ 24695013c547SDavid Gibson static void spapr_machine_##suffix##_instance_init(Object *obj) \ 24705013c547SDavid Gibson { \ 24715013c547SDavid Gibson MachineState *machine = MACHINE(obj); \ 24725013c547SDavid Gibson spapr_machine_##suffix##_instance_options(machine); \ 24735013c547SDavid Gibson } \ 24745013c547SDavid Gibson static const TypeInfo spapr_machine_##suffix##_info = { \ 24755013c547SDavid Gibson .name = MACHINE_TYPE_NAME("pseries-" verstr), \ 24765013c547SDavid Gibson .parent = TYPE_SPAPR_MACHINE, \ 24775013c547SDavid Gibson .class_init = spapr_machine_##suffix##_class_init, \ 24785013c547SDavid Gibson .instance_init = spapr_machine_##suffix##_instance_init, \ 24795013c547SDavid Gibson }; \ 24805013c547SDavid Gibson static void spapr_machine_register_##suffix(void) \ 24815013c547SDavid Gibson { \ 24825013c547SDavid Gibson type_register(&spapr_machine_##suffix##_info); \ 24835013c547SDavid Gibson } \ 24840e6aac87SEduardo Habkost type_init(spapr_machine_register_##suffix) 24855013c547SDavid Gibson 24861c5f29bbSDavid Gibson /* 24871ea1eefcSBharata B Rao * pseries-2.7 24881ea1eefcSBharata B Rao */ 24891ea1eefcSBharata B Rao static void spapr_machine_2_7_instance_options(MachineState *machine) 24901ea1eefcSBharata B Rao { 24911ea1eefcSBharata B Rao } 24921ea1eefcSBharata B Rao 24931ea1eefcSBharata B Rao static void spapr_machine_2_7_class_options(MachineClass *mc) 24941ea1eefcSBharata B Rao { 24951ea1eefcSBharata B Rao /* Defaults for the latest behaviour inherited from the base class */ 24961ea1eefcSBharata B Rao } 24971ea1eefcSBharata B Rao 24981ea1eefcSBharata B Rao DEFINE_SPAPR_MACHINE(2_7, "2.7", true); 24991ea1eefcSBharata B Rao 25001ea1eefcSBharata B Rao /* 25014b23699cSDavid Gibson * pseries-2.6 25024b23699cSDavid Gibson */ 25031ea1eefcSBharata B Rao #define SPAPR_COMPAT_2_6 \ 2504ae4de14cSAlexey Kardashevskiy HW_COMPAT_2_6 \ 2505ae4de14cSAlexey Kardashevskiy { \ 2506ae4de14cSAlexey Kardashevskiy .driver = TYPE_SPAPR_PCI_HOST_BRIDGE,\ 2507ae4de14cSAlexey Kardashevskiy .property = "ddw",\ 2508ae4de14cSAlexey Kardashevskiy .value = stringify(off),\ 2509ae4de14cSAlexey Kardashevskiy }, 25101ea1eefcSBharata B Rao 25114b23699cSDavid Gibson static void spapr_machine_2_6_instance_options(MachineState *machine) 25124b23699cSDavid Gibson { 25134b23699cSDavid Gibson } 25144b23699cSDavid Gibson 25154b23699cSDavid Gibson static void spapr_machine_2_6_class_options(MachineClass *mc) 25164b23699cSDavid Gibson { 25171ea1eefcSBharata B Rao spapr_machine_2_7_class_options(mc); 25183c0c47e3SDavid Gibson mc->query_hotpluggable_cpus = NULL; 25191ea1eefcSBharata B Rao SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_6); 25204b23699cSDavid Gibson } 25214b23699cSDavid Gibson 25221ea1eefcSBharata B Rao DEFINE_SPAPR_MACHINE(2_6, "2.6", false); 25234b23699cSDavid Gibson 25244b23699cSDavid Gibson /* 25251c5f29bbSDavid Gibson * pseries-2.5 25261c5f29bbSDavid Gibson */ 25274b23699cSDavid Gibson #define SPAPR_COMPAT_2_5 \ 252857c522f4SThomas Huth HW_COMPAT_2_5 \ 252957c522f4SThomas Huth { \ 253057c522f4SThomas Huth .driver = "spapr-vlan", \ 253157c522f4SThomas Huth .property = "use-rx-buffer-pools", \ 253257c522f4SThomas Huth .value = "off", \ 253357c522f4SThomas Huth }, 25344b23699cSDavid Gibson 25355013c547SDavid Gibson static void spapr_machine_2_5_instance_options(MachineState *machine) 25361c5f29bbSDavid Gibson { 25375013c547SDavid Gibson } 25385013c547SDavid Gibson 25395013c547SDavid Gibson static void spapr_machine_2_5_class_options(MachineClass *mc) 25405013c547SDavid Gibson { 254157040d45SThomas Huth sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); 254257040d45SThomas Huth 25434b23699cSDavid Gibson spapr_machine_2_6_class_options(mc); 254457040d45SThomas Huth smc->use_ohci_by_default = true; 25454b23699cSDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_5); 25461c5f29bbSDavid Gibson } 25471c5f29bbSDavid Gibson 25484b23699cSDavid Gibson DEFINE_SPAPR_MACHINE(2_5, "2.5", false); 25491c5f29bbSDavid Gibson 25501c5f29bbSDavid Gibson /* 25511c5f29bbSDavid Gibson * pseries-2.4 25521c5f29bbSDavid Gibson */ 255380fd50f9SCornelia Huck #define SPAPR_COMPAT_2_4 \ 255480fd50f9SCornelia Huck HW_COMPAT_2_4 255580fd50f9SCornelia Huck 25565013c547SDavid Gibson static void spapr_machine_2_4_instance_options(MachineState *machine) 25571c5f29bbSDavid Gibson { 25585013c547SDavid Gibson spapr_machine_2_5_instance_options(machine); 25595013c547SDavid Gibson } 25601c5f29bbSDavid Gibson 25615013c547SDavid Gibson static void spapr_machine_2_4_class_options(MachineClass *mc) 25625013c547SDavid Gibson { 2563fc9f38c3SDavid Gibson sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); 2564fc9f38c3SDavid Gibson 2565fc9f38c3SDavid Gibson spapr_machine_2_5_class_options(mc); 2566fc9f38c3SDavid Gibson smc->dr_lmb_enabled = false; 2567f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_4); 25681c5f29bbSDavid Gibson } 25691c5f29bbSDavid Gibson 2570fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_4, "2.4", false); 25711c5f29bbSDavid Gibson 25721c5f29bbSDavid Gibson /* 25731c5f29bbSDavid Gibson * pseries-2.3 25741c5f29bbSDavid Gibson */ 257538ff32c6SEduardo Habkost #define SPAPR_COMPAT_2_3 \ 25767619c7b0SMichael Roth HW_COMPAT_2_3 \ 25777619c7b0SMichael Roth {\ 25787619c7b0SMichael Roth .driver = "spapr-pci-host-bridge",\ 25797619c7b0SMichael Roth .property = "dynamic-reconfiguration",\ 25807619c7b0SMichael Roth .value = "off",\ 25817619c7b0SMichael Roth }, 258238ff32c6SEduardo Habkost 25835013c547SDavid Gibson static void spapr_machine_2_3_instance_options(MachineState *machine) 25841c5f29bbSDavid Gibson { 25855013c547SDavid Gibson spapr_machine_2_4_instance_options(machine); 25861c5f29bbSDavid Gibson savevm_skip_section_footers(); 25871c5f29bbSDavid Gibson global_state_set_optional(); 258809b5e30dSGreg Kurz savevm_skip_configuration(); 25891c5f29bbSDavid Gibson } 25901c5f29bbSDavid Gibson 25915013c547SDavid Gibson static void spapr_machine_2_3_class_options(MachineClass *mc) 25921c5f29bbSDavid Gibson { 2593fc9f38c3SDavid Gibson spapr_machine_2_4_class_options(mc); 2594f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_3); 25951c5f29bbSDavid Gibson } 2596fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_3, "2.3", false); 25971c5f29bbSDavid Gibson 25981c5f29bbSDavid Gibson /* 25991c5f29bbSDavid Gibson * pseries-2.2 26001c5f29bbSDavid Gibson */ 26011c5f29bbSDavid Gibson 2602b194df47SAlexey Kardashevskiy #define SPAPR_COMPAT_2_2 \ 26034dfd8eaaSEduardo Habkost HW_COMPAT_2_2 \ 2604b194df47SAlexey Kardashevskiy {\ 2605b194df47SAlexey Kardashevskiy .driver = TYPE_SPAPR_PCI_HOST_BRIDGE,\ 2606b194df47SAlexey Kardashevskiy .property = "mem_win_size",\ 2607b194df47SAlexey Kardashevskiy .value = "0x20000000",\ 2608dd754bafSEduardo Habkost }, 2609b194df47SAlexey Kardashevskiy 26105013c547SDavid Gibson static void spapr_machine_2_2_instance_options(MachineState *machine) 2611b0e966d0SJason Wang { 26125013c547SDavid Gibson spapr_machine_2_3_instance_options(machine); 2613cba0e779SGreg Kurz machine->suppress_vmdesc = true; 2614b0e966d0SJason Wang } 2615b0e966d0SJason Wang 26165013c547SDavid Gibson static void spapr_machine_2_2_class_options(MachineClass *mc) 2617b0e966d0SJason Wang { 2618fc9f38c3SDavid Gibson spapr_machine_2_3_class_options(mc); 2619f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_2); 26201c5f29bbSDavid Gibson } 2621fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_2, "2.2", false); 26221c5f29bbSDavid Gibson 26231c5f29bbSDavid Gibson /* 26241c5f29bbSDavid Gibson * pseries-2.1 26251c5f29bbSDavid Gibson */ 26261c5f29bbSDavid Gibson #define SPAPR_COMPAT_2_1 \ 26271c5f29bbSDavid Gibson HW_COMPAT_2_1 26281c5f29bbSDavid Gibson 26295013c547SDavid Gibson static void spapr_machine_2_1_instance_options(MachineState *machine) 26301c5f29bbSDavid Gibson { 26315013c547SDavid Gibson spapr_machine_2_2_instance_options(machine); 26321c5f29bbSDavid Gibson } 26331c5f29bbSDavid Gibson 26345013c547SDavid Gibson static void spapr_machine_2_1_class_options(MachineClass *mc) 2635b0e966d0SJason Wang { 2636fc9f38c3SDavid Gibson spapr_machine_2_2_class_options(mc); 2637f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_1); 26386026db45SAlexey Kardashevskiy } 2639fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_1, "2.1", false); 26406026db45SAlexey Kardashevskiy 264129ee3247SAlexey Kardashevskiy static void spapr_machine_register_types(void) 264229ee3247SAlexey Kardashevskiy { 264329ee3247SAlexey Kardashevskiy type_register_static(&spapr_machine_info); 264429ee3247SAlexey Kardashevskiy } 264529ee3247SAlexey Kardashevskiy 264629ee3247SAlexey Kardashevskiy type_init(spapr_machine_register_types) 2647