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 { 119c04d6cfaSAnthony Liguori XICSState *icp = NULL; 120c04d6cfaSAnthony Liguori 12111ad93f6SDavid Gibson if (kvm_enabled()) { 12234f2af3dSMarkus Armbruster Error *err = NULL; 12334f2af3dSMarkus Armbruster 124446f16a6SMarcel Apfelbaum if (machine_kernel_irqchip_allowed(machine)) { 12534f2af3dSMarkus Armbruster icp = try_create_xics(TYPE_KVM_XICS, nr_servers, nr_irqs, &err); 12611ad93f6SDavid Gibson } 127446f16a6SMarcel Apfelbaum if (machine_kernel_irqchip_required(machine) && !icp) { 128b83baa60SMarkus Armbruster error_reportf_err(err, 129b83baa60SMarkus Armbruster "kernel_irqchip requested but unavailable: "); 130b83baa60SMarkus Armbruster } else { 131903a41d3SStefano Dong (董兴水) error_free(err); 13211ad93f6SDavid Gibson } 133b83baa60SMarkus Armbruster } 13411ad93f6SDavid Gibson 13511ad93f6SDavid Gibson if (!icp) { 1361e49182dSDavid Gibson icp = try_create_xics(TYPE_XICS, nr_servers, nr_irqs, errp); 137c04d6cfaSAnthony Liguori } 138c04d6cfaSAnthony Liguori 139c04d6cfaSAnthony Liguori return icp; 140c04d6cfaSAnthony Liguori } 141c04d6cfaSAnthony Liguori 142833d4668SAlexey Kardashevskiy static int spapr_fixup_cpu_smt_dt(void *fdt, int offset, PowerPCCPU *cpu, 143833d4668SAlexey Kardashevskiy int smt_threads) 144833d4668SAlexey Kardashevskiy { 145833d4668SAlexey Kardashevskiy int i, ret = 0; 146833d4668SAlexey Kardashevskiy uint32_t servers_prop[smt_threads]; 147833d4668SAlexey Kardashevskiy uint32_t gservers_prop[smt_threads * 2]; 148833d4668SAlexey Kardashevskiy int index = ppc_get_vcpu_dt_id(cpu); 149833d4668SAlexey Kardashevskiy 1506d9412eaSAlexey Kardashevskiy if (cpu->cpu_version) { 1514bce526eSLaurent Dufour ret = fdt_setprop_cell(fdt, offset, "cpu-version", cpu->cpu_version); 1526d9412eaSAlexey Kardashevskiy if (ret < 0) { 1536d9412eaSAlexey Kardashevskiy return ret; 1546d9412eaSAlexey Kardashevskiy } 1556d9412eaSAlexey Kardashevskiy } 1566d9412eaSAlexey Kardashevskiy 157833d4668SAlexey Kardashevskiy /* Build interrupt servers and gservers properties */ 158833d4668SAlexey Kardashevskiy for (i = 0; i < smt_threads; i++) { 159833d4668SAlexey Kardashevskiy servers_prop[i] = cpu_to_be32(index + i); 160833d4668SAlexey Kardashevskiy /* Hack, direct the group queues back to cpu 0 */ 161833d4668SAlexey Kardashevskiy gservers_prop[i*2] = cpu_to_be32(index + i); 162833d4668SAlexey Kardashevskiy gservers_prop[i*2 + 1] = 0; 163833d4668SAlexey Kardashevskiy } 164833d4668SAlexey Kardashevskiy ret = fdt_setprop(fdt, offset, "ibm,ppc-interrupt-server#s", 165833d4668SAlexey Kardashevskiy servers_prop, sizeof(servers_prop)); 166833d4668SAlexey Kardashevskiy if (ret < 0) { 167833d4668SAlexey Kardashevskiy return ret; 168833d4668SAlexey Kardashevskiy } 169833d4668SAlexey Kardashevskiy ret = fdt_setprop(fdt, offset, "ibm,ppc-interrupt-gserver#s", 170833d4668SAlexey Kardashevskiy gservers_prop, sizeof(gservers_prop)); 171833d4668SAlexey Kardashevskiy 172833d4668SAlexey Kardashevskiy return ret; 173833d4668SAlexey Kardashevskiy } 174833d4668SAlexey Kardashevskiy 1750da6f3feSBharata B Rao static int spapr_fixup_cpu_numa_dt(void *fdt, int offset, CPUState *cs) 1760da6f3feSBharata B Rao { 1770da6f3feSBharata B Rao int ret = 0; 1780da6f3feSBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(cs); 1790da6f3feSBharata B Rao int index = ppc_get_vcpu_dt_id(cpu); 1800da6f3feSBharata B Rao uint32_t associativity[] = {cpu_to_be32(0x5), 1810da6f3feSBharata B Rao cpu_to_be32(0x0), 1820da6f3feSBharata B Rao cpu_to_be32(0x0), 1830da6f3feSBharata B Rao cpu_to_be32(0x0), 1840da6f3feSBharata B Rao cpu_to_be32(cs->numa_node), 1850da6f3feSBharata B Rao cpu_to_be32(index)}; 1860da6f3feSBharata B Rao 1870da6f3feSBharata B Rao /* Advertise NUMA via ibm,associativity */ 1880da6f3feSBharata B Rao if (nb_numa_nodes > 1) { 1890da6f3feSBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,associativity", associativity, 1900da6f3feSBharata B Rao sizeof(associativity)); 1910da6f3feSBharata B Rao } 1920da6f3feSBharata B Rao 1930da6f3feSBharata B Rao return ret; 1940da6f3feSBharata B Rao } 1950da6f3feSBharata B Rao 19628e02042SDavid Gibson static int spapr_fixup_cpu_dt(void *fdt, sPAPRMachineState *spapr) 19753018216SPaolo Bonzini { 19882677ed2SAlexey Kardashevskiy int ret = 0, offset, cpus_offset; 19982677ed2SAlexey Kardashevskiy CPUState *cs; 20053018216SPaolo Bonzini char cpu_model[32]; 20153018216SPaolo Bonzini int smt = kvmppc_smt_threads(); 20253018216SPaolo Bonzini uint32_t pft_size_prop[] = {0, cpu_to_be32(spapr->htab_shift)}; 20353018216SPaolo Bonzini 20482677ed2SAlexey Kardashevskiy CPU_FOREACH(cs) { 20582677ed2SAlexey Kardashevskiy PowerPCCPU *cpu = POWERPC_CPU(cs); 20682677ed2SAlexey Kardashevskiy DeviceClass *dc = DEVICE_GET_CLASS(cs); 20782677ed2SAlexey Kardashevskiy int index = ppc_get_vcpu_dt_id(cpu); 20853018216SPaolo Bonzini 2090f20ba62SAlexey Kardashevskiy if ((index % smt) != 0) { 21053018216SPaolo Bonzini continue; 21153018216SPaolo Bonzini } 21253018216SPaolo Bonzini 21382677ed2SAlexey Kardashevskiy snprintf(cpu_model, 32, "%s@%x", dc->fw_name, index); 21453018216SPaolo Bonzini 21582677ed2SAlexey Kardashevskiy cpus_offset = fdt_path_offset(fdt, "/cpus"); 21682677ed2SAlexey Kardashevskiy if (cpus_offset < 0) { 21782677ed2SAlexey Kardashevskiy cpus_offset = fdt_add_subnode(fdt, fdt_path_offset(fdt, "/"), 21882677ed2SAlexey Kardashevskiy "cpus"); 21982677ed2SAlexey Kardashevskiy if (cpus_offset < 0) { 22082677ed2SAlexey Kardashevskiy return cpus_offset; 22182677ed2SAlexey Kardashevskiy } 22282677ed2SAlexey Kardashevskiy } 22382677ed2SAlexey Kardashevskiy offset = fdt_subnode_offset(fdt, cpus_offset, cpu_model); 22482677ed2SAlexey Kardashevskiy if (offset < 0) { 22582677ed2SAlexey Kardashevskiy offset = fdt_add_subnode(fdt, cpus_offset, cpu_model); 22653018216SPaolo Bonzini if (offset < 0) { 22753018216SPaolo Bonzini return offset; 22853018216SPaolo Bonzini } 22982677ed2SAlexey Kardashevskiy } 23053018216SPaolo Bonzini 2310da6f3feSBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,pft-size", 2320da6f3feSBharata B Rao pft_size_prop, sizeof(pft_size_prop)); 23353018216SPaolo Bonzini if (ret < 0) { 23453018216SPaolo Bonzini return ret; 23553018216SPaolo Bonzini } 23653018216SPaolo Bonzini 2370da6f3feSBharata B Rao ret = spapr_fixup_cpu_numa_dt(fdt, offset, cs); 23853018216SPaolo Bonzini if (ret < 0) { 23953018216SPaolo Bonzini return ret; 24053018216SPaolo Bonzini } 241833d4668SAlexey Kardashevskiy 24282677ed2SAlexey Kardashevskiy ret = spapr_fixup_cpu_smt_dt(fdt, offset, cpu, 2432a48d993SAlexey Kardashevskiy ppc_get_compat_smt_threads(cpu)); 244833d4668SAlexey Kardashevskiy if (ret < 0) { 245833d4668SAlexey Kardashevskiy return ret; 246833d4668SAlexey Kardashevskiy } 24753018216SPaolo Bonzini } 24853018216SPaolo Bonzini return ret; 24953018216SPaolo Bonzini } 25053018216SPaolo Bonzini 25153018216SPaolo Bonzini 25253018216SPaolo Bonzini static size_t create_page_sizes_prop(CPUPPCState *env, uint32_t *prop, 25353018216SPaolo Bonzini size_t maxsize) 25453018216SPaolo Bonzini { 25553018216SPaolo Bonzini size_t maxcells = maxsize / sizeof(uint32_t); 25653018216SPaolo Bonzini int i, j, count; 25753018216SPaolo Bonzini uint32_t *p = prop; 25853018216SPaolo Bonzini 25953018216SPaolo Bonzini for (i = 0; i < PPC_PAGE_SIZES_MAX_SZ; i++) { 26053018216SPaolo Bonzini struct ppc_one_seg_page_size *sps = &env->sps.sps[i]; 26153018216SPaolo Bonzini 26253018216SPaolo Bonzini if (!sps->page_shift) { 26353018216SPaolo Bonzini break; 26453018216SPaolo Bonzini } 26553018216SPaolo Bonzini for (count = 0; count < PPC_PAGE_SIZES_MAX_SZ; count++) { 26653018216SPaolo Bonzini if (sps->enc[count].page_shift == 0) { 26753018216SPaolo Bonzini break; 26853018216SPaolo Bonzini } 26953018216SPaolo Bonzini } 27053018216SPaolo Bonzini if ((p - prop) >= (maxcells - 3 - count * 2)) { 27153018216SPaolo Bonzini break; 27253018216SPaolo Bonzini } 27353018216SPaolo Bonzini *(p++) = cpu_to_be32(sps->page_shift); 27453018216SPaolo Bonzini *(p++) = cpu_to_be32(sps->slb_enc); 27553018216SPaolo Bonzini *(p++) = cpu_to_be32(count); 27653018216SPaolo Bonzini for (j = 0; j < count; j++) { 27753018216SPaolo Bonzini *(p++) = cpu_to_be32(sps->enc[j].page_shift); 27853018216SPaolo Bonzini *(p++) = cpu_to_be32(sps->enc[j].pte_enc); 27953018216SPaolo Bonzini } 28053018216SPaolo Bonzini } 28153018216SPaolo Bonzini 28253018216SPaolo Bonzini return (p - prop) * sizeof(uint32_t); 28353018216SPaolo Bonzini } 28453018216SPaolo Bonzini 285b082d65aSAlexey Kardashevskiy static hwaddr spapr_node0_size(void) 286b082d65aSAlexey Kardashevskiy { 287fb164994SDavid Gibson MachineState *machine = MACHINE(qdev_get_machine()); 288fb164994SDavid Gibson 289b082d65aSAlexey Kardashevskiy if (nb_numa_nodes) { 290b082d65aSAlexey Kardashevskiy int i; 291b082d65aSAlexey Kardashevskiy for (i = 0; i < nb_numa_nodes; ++i) { 292b082d65aSAlexey Kardashevskiy if (numa_info[i].node_mem) { 293fb164994SDavid Gibson return MIN(pow2floor(numa_info[i].node_mem), 294fb164994SDavid Gibson machine->ram_size); 295b082d65aSAlexey Kardashevskiy } 296b082d65aSAlexey Kardashevskiy } 297b082d65aSAlexey Kardashevskiy } 298fb164994SDavid Gibson return machine->ram_size; 299b082d65aSAlexey Kardashevskiy } 300b082d65aSAlexey Kardashevskiy 30153018216SPaolo Bonzini #define _FDT(exp) \ 30253018216SPaolo Bonzini do { \ 30353018216SPaolo Bonzini int ret = (exp); \ 30453018216SPaolo Bonzini if (ret < 0) { \ 30553018216SPaolo Bonzini fprintf(stderr, "qemu: error creating device tree: %s: %s\n", \ 30653018216SPaolo Bonzini #exp, fdt_strerror(ret)); \ 30753018216SPaolo Bonzini exit(1); \ 30853018216SPaolo Bonzini } \ 30953018216SPaolo Bonzini } while (0) 31053018216SPaolo Bonzini 311a1d59c0fSAlexey Kardashevskiy static void add_str(GString *s, const gchar *s1) 312a1d59c0fSAlexey Kardashevskiy { 313a1d59c0fSAlexey Kardashevskiy g_string_append_len(s, s1, strlen(s1) + 1); 314a1d59c0fSAlexey Kardashevskiy } 31553018216SPaolo Bonzini 3163bbf37f2SAndreas Färber static void *spapr_create_fdt_skel(hwaddr initrd_base, 31753018216SPaolo Bonzini hwaddr initrd_size, 31853018216SPaolo Bonzini hwaddr kernel_size, 31916457e7fSBenjamin Herrenschmidt bool little_endian, 32053018216SPaolo Bonzini const char *kernel_cmdline, 32153018216SPaolo Bonzini uint32_t epow_irq) 32253018216SPaolo Bonzini { 32353018216SPaolo Bonzini void *fdt; 32453018216SPaolo Bonzini uint32_t start_prop = cpu_to_be32(initrd_base); 32553018216SPaolo Bonzini uint32_t end_prop = cpu_to_be32(initrd_base + initrd_size); 326a1d59c0fSAlexey Kardashevskiy GString *hypertas = g_string_sized_new(256); 327a1d59c0fSAlexey Kardashevskiy GString *qemu_hypertas = g_string_sized_new(256); 32853018216SPaolo Bonzini uint32_t refpoints[] = {cpu_to_be32(0x4), cpu_to_be32(0x4)}; 3299e734e3dSBharata B Rao uint32_t interrupt_server_ranges_prop[] = {0, cpu_to_be32(max_cpus)}; 33053018216SPaolo Bonzini unsigned char vec5[] = {0x0, 0x0, 0x0, 0x0, 0x0, 0x80}; 331ef951443SNikunj A Dadhania char *buf; 33253018216SPaolo Bonzini 333a1d59c0fSAlexey Kardashevskiy add_str(hypertas, "hcall-pft"); 334a1d59c0fSAlexey Kardashevskiy add_str(hypertas, "hcall-term"); 335a1d59c0fSAlexey Kardashevskiy add_str(hypertas, "hcall-dabr"); 336a1d59c0fSAlexey Kardashevskiy add_str(hypertas, "hcall-interrupt"); 337a1d59c0fSAlexey Kardashevskiy add_str(hypertas, "hcall-tce"); 338a1d59c0fSAlexey Kardashevskiy add_str(hypertas, "hcall-vio"); 339a1d59c0fSAlexey Kardashevskiy add_str(hypertas, "hcall-splpar"); 340a1d59c0fSAlexey Kardashevskiy add_str(hypertas, "hcall-bulk"); 341a1d59c0fSAlexey Kardashevskiy add_str(hypertas, "hcall-set-mode"); 342a1d59c0fSAlexey Kardashevskiy add_str(qemu_hypertas, "hcall-memop1"); 343a1d59c0fSAlexey Kardashevskiy 34453018216SPaolo Bonzini fdt = g_malloc0(FDT_MAX_SIZE); 34553018216SPaolo Bonzini _FDT((fdt_create(fdt, FDT_MAX_SIZE))); 34653018216SPaolo Bonzini 34753018216SPaolo Bonzini if (kernel_size) { 34853018216SPaolo Bonzini _FDT((fdt_add_reservemap_entry(fdt, KERNEL_LOAD_ADDR, kernel_size))); 34953018216SPaolo Bonzini } 35053018216SPaolo Bonzini if (initrd_size) { 35153018216SPaolo Bonzini _FDT((fdt_add_reservemap_entry(fdt, initrd_base, initrd_size))); 35253018216SPaolo Bonzini } 35353018216SPaolo Bonzini _FDT((fdt_finish_reservemap(fdt))); 35453018216SPaolo Bonzini 35553018216SPaolo Bonzini /* Root node */ 35653018216SPaolo Bonzini _FDT((fdt_begin_node(fdt, ""))); 35753018216SPaolo Bonzini _FDT((fdt_property_string(fdt, "device_type", "chrp"))); 35853018216SPaolo Bonzini _FDT((fdt_property_string(fdt, "model", "IBM pSeries (emulated by qemu)"))); 359fa388916SAnthony Liguori _FDT((fdt_property_string(fdt, "compatible", "qemu,pseries"))); 36053018216SPaolo Bonzini 361ef951443SNikunj A Dadhania /* 362ef951443SNikunj A Dadhania * Add info to guest to indentify which host is it being run on 363ef951443SNikunj A Dadhania * and what is the uuid of the guest 364ef951443SNikunj A Dadhania */ 365ef951443SNikunj A Dadhania if (kvmppc_get_host_model(&buf)) { 366ef951443SNikunj A Dadhania _FDT((fdt_property_string(fdt, "host-model", buf))); 367ef951443SNikunj A Dadhania g_free(buf); 368ef951443SNikunj A Dadhania } 369ef951443SNikunj A Dadhania if (kvmppc_get_host_serial(&buf)) { 370ef951443SNikunj A Dadhania _FDT((fdt_property_string(fdt, "host-serial", buf))); 371ef951443SNikunj A Dadhania g_free(buf); 372ef951443SNikunj A Dadhania } 373ef951443SNikunj A Dadhania 374ef951443SNikunj A Dadhania buf = g_strdup_printf(UUID_FMT, qemu_uuid[0], qemu_uuid[1], 375ef951443SNikunj A Dadhania qemu_uuid[2], qemu_uuid[3], qemu_uuid[4], 376ef951443SNikunj A Dadhania qemu_uuid[5], qemu_uuid[6], qemu_uuid[7], 377ef951443SNikunj A Dadhania qemu_uuid[8], qemu_uuid[9], qemu_uuid[10], 378ef951443SNikunj A Dadhania qemu_uuid[11], qemu_uuid[12], qemu_uuid[13], 379ef951443SNikunj A Dadhania qemu_uuid[14], qemu_uuid[15]); 380ef951443SNikunj A Dadhania 381ef951443SNikunj A Dadhania _FDT((fdt_property_string(fdt, "vm,uuid", buf))); 3823dc0a66dSAlexey Kardashevskiy if (qemu_uuid_set) { 3833dc0a66dSAlexey Kardashevskiy _FDT((fdt_property_string(fdt, "system-id", buf))); 3843dc0a66dSAlexey Kardashevskiy } 385ef951443SNikunj A Dadhania g_free(buf); 386ef951443SNikunj A Dadhania 3872c1aaa81SSam Bobroff if (qemu_get_vm_name()) { 3882c1aaa81SSam Bobroff _FDT((fdt_property_string(fdt, "ibm,partition-name", 3892c1aaa81SSam Bobroff qemu_get_vm_name()))); 3902c1aaa81SSam Bobroff } 3912c1aaa81SSam Bobroff 39253018216SPaolo Bonzini _FDT((fdt_property_cell(fdt, "#address-cells", 0x2))); 39353018216SPaolo Bonzini _FDT((fdt_property_cell(fdt, "#size-cells", 0x2))); 39453018216SPaolo Bonzini 39553018216SPaolo Bonzini /* /chosen */ 39653018216SPaolo Bonzini _FDT((fdt_begin_node(fdt, "chosen"))); 39753018216SPaolo Bonzini 39853018216SPaolo Bonzini /* Set Form1_affinity */ 39953018216SPaolo Bonzini _FDT((fdt_property(fdt, "ibm,architecture-vec-5", vec5, sizeof(vec5)))); 40053018216SPaolo Bonzini 40153018216SPaolo Bonzini _FDT((fdt_property_string(fdt, "bootargs", kernel_cmdline))); 40253018216SPaolo Bonzini _FDT((fdt_property(fdt, "linux,initrd-start", 40353018216SPaolo Bonzini &start_prop, sizeof(start_prop)))); 40453018216SPaolo Bonzini _FDT((fdt_property(fdt, "linux,initrd-end", 40553018216SPaolo Bonzini &end_prop, sizeof(end_prop)))); 40653018216SPaolo Bonzini if (kernel_size) { 40753018216SPaolo Bonzini uint64_t kprop[2] = { cpu_to_be64(KERNEL_LOAD_ADDR), 40853018216SPaolo Bonzini cpu_to_be64(kernel_size) }; 40953018216SPaolo Bonzini 41053018216SPaolo Bonzini _FDT((fdt_property(fdt, "qemu,boot-kernel", &kprop, sizeof(kprop)))); 41116457e7fSBenjamin Herrenschmidt if (little_endian) { 41216457e7fSBenjamin Herrenschmidt _FDT((fdt_property(fdt, "qemu,boot-kernel-le", NULL, 0))); 41316457e7fSBenjamin Herrenschmidt } 41453018216SPaolo Bonzini } 415cc84c0f3SAvik Sil if (boot_menu) { 416cc84c0f3SAvik Sil _FDT((fdt_property_cell(fdt, "qemu,boot-menu", boot_menu))); 417cc84c0f3SAvik Sil } 41853018216SPaolo Bonzini _FDT((fdt_property_cell(fdt, "qemu,graphic-width", graphic_width))); 41953018216SPaolo Bonzini _FDT((fdt_property_cell(fdt, "qemu,graphic-height", graphic_height))); 42053018216SPaolo Bonzini _FDT((fdt_property_cell(fdt, "qemu,graphic-depth", graphic_depth))); 42153018216SPaolo Bonzini 42253018216SPaolo Bonzini _FDT((fdt_end_node(fdt))); 42353018216SPaolo Bonzini 42453018216SPaolo Bonzini /* RTAS */ 42553018216SPaolo Bonzini _FDT((fdt_begin_node(fdt, "rtas"))); 42653018216SPaolo Bonzini 427da95324eSAlexey Kardashevskiy if (!kvm_enabled() || kvmppc_spapr_use_multitce()) { 428da95324eSAlexey Kardashevskiy add_str(hypertas, "hcall-multi-tce"); 429da95324eSAlexey Kardashevskiy } 430a1d59c0fSAlexey Kardashevskiy _FDT((fdt_property(fdt, "ibm,hypertas-functions", hypertas->str, 431a1d59c0fSAlexey Kardashevskiy hypertas->len))); 432a1d59c0fSAlexey Kardashevskiy g_string_free(hypertas, TRUE); 433a1d59c0fSAlexey Kardashevskiy _FDT((fdt_property(fdt, "qemu,hypertas-functions", qemu_hypertas->str, 434a1d59c0fSAlexey Kardashevskiy qemu_hypertas->len))); 435a1d59c0fSAlexey Kardashevskiy g_string_free(qemu_hypertas, TRUE); 43653018216SPaolo Bonzini 43753018216SPaolo Bonzini _FDT((fdt_property(fdt, "ibm,associativity-reference-points", 43853018216SPaolo Bonzini refpoints, sizeof(refpoints)))); 43953018216SPaolo Bonzini 44053018216SPaolo Bonzini _FDT((fdt_property_cell(fdt, "rtas-error-log-max", RTAS_ERROR_LOG_MAX))); 44179853e18STyrel Datwyler _FDT((fdt_property_cell(fdt, "rtas-event-scan-rate", 44279853e18STyrel Datwyler RTAS_EVENT_SCAN_RATE))); 44353018216SPaolo Bonzini 444226419d6SMichael S. Tsirkin if (msi_nonbroken) { 445a95f9922SSam Bobroff _FDT((fdt_property(fdt, "ibm,change-msix-capable", NULL, 0))); 446a95f9922SSam Bobroff } 447a95f9922SSam Bobroff 4482e14072fSNikunj A Dadhania /* 4499d632f5fSzhanghailiang * According to PAPR, rtas ibm,os-term does not guarantee a return 4502e14072fSNikunj A Dadhania * back to the guest cpu. 4512e14072fSNikunj A Dadhania * 4522e14072fSNikunj A Dadhania * While an additional ibm,extended-os-term property indicates that 4532e14072fSNikunj A Dadhania * rtas call return will always occur. Set this property. 4542e14072fSNikunj A Dadhania */ 4552e14072fSNikunj A Dadhania _FDT((fdt_property(fdt, "ibm,extended-os-term", NULL, 0))); 4562e14072fSNikunj A Dadhania 45753018216SPaolo Bonzini _FDT((fdt_end_node(fdt))); 45853018216SPaolo Bonzini 45953018216SPaolo Bonzini /* interrupt controller */ 46053018216SPaolo Bonzini _FDT((fdt_begin_node(fdt, "interrupt-controller"))); 46153018216SPaolo Bonzini 46253018216SPaolo Bonzini _FDT((fdt_property_string(fdt, "device_type", 46353018216SPaolo Bonzini "PowerPC-External-Interrupt-Presentation"))); 46453018216SPaolo Bonzini _FDT((fdt_property_string(fdt, "compatible", "IBM,ppc-xicp"))); 46553018216SPaolo Bonzini _FDT((fdt_property(fdt, "interrupt-controller", NULL, 0))); 46653018216SPaolo Bonzini _FDT((fdt_property(fdt, "ibm,interrupt-server-ranges", 46753018216SPaolo Bonzini interrupt_server_ranges_prop, 46853018216SPaolo Bonzini sizeof(interrupt_server_ranges_prop)))); 46953018216SPaolo Bonzini _FDT((fdt_property_cell(fdt, "#interrupt-cells", 2))); 47053018216SPaolo Bonzini _FDT((fdt_property_cell(fdt, "linux,phandle", PHANDLE_XICP))); 47153018216SPaolo Bonzini _FDT((fdt_property_cell(fdt, "phandle", PHANDLE_XICP))); 47253018216SPaolo Bonzini 47353018216SPaolo Bonzini _FDT((fdt_end_node(fdt))); 47453018216SPaolo Bonzini 47553018216SPaolo Bonzini /* vdevice */ 47653018216SPaolo Bonzini _FDT((fdt_begin_node(fdt, "vdevice"))); 47753018216SPaolo Bonzini 47853018216SPaolo Bonzini _FDT((fdt_property_string(fdt, "device_type", "vdevice"))); 47953018216SPaolo Bonzini _FDT((fdt_property_string(fdt, "compatible", "IBM,vdevice"))); 48053018216SPaolo Bonzini _FDT((fdt_property_cell(fdt, "#address-cells", 0x1))); 48153018216SPaolo Bonzini _FDT((fdt_property_cell(fdt, "#size-cells", 0x0))); 48253018216SPaolo Bonzini _FDT((fdt_property_cell(fdt, "#interrupt-cells", 0x2))); 48353018216SPaolo Bonzini _FDT((fdt_property(fdt, "interrupt-controller", NULL, 0))); 48453018216SPaolo Bonzini 48553018216SPaolo Bonzini _FDT((fdt_end_node(fdt))); 48653018216SPaolo Bonzini 48753018216SPaolo Bonzini /* event-sources */ 48853018216SPaolo Bonzini spapr_events_fdt_skel(fdt, epow_irq); 48953018216SPaolo Bonzini 490f7d69146SAlexander Graf /* /hypervisor node */ 491f7d69146SAlexander Graf if (kvm_enabled()) { 492f7d69146SAlexander Graf uint8_t hypercall[16]; 493f7d69146SAlexander Graf 494f7d69146SAlexander Graf /* indicate KVM hypercall interface */ 495f7d69146SAlexander Graf _FDT((fdt_begin_node(fdt, "hypervisor"))); 496f7d69146SAlexander Graf _FDT((fdt_property_string(fdt, "compatible", "linux,kvm"))); 497f7d69146SAlexander Graf if (kvmppc_has_cap_fixup_hcalls()) { 498f7d69146SAlexander Graf /* 499f7d69146SAlexander Graf * Older KVM versions with older guest kernels were broken with the 500f7d69146SAlexander Graf * magic page, don't allow the guest to map it. 501f7d69146SAlexander Graf */ 5020ddbd053SAlexey Kardashevskiy if (!kvmppc_get_hypercall(first_cpu->env_ptr, hypercall, 5030ddbd053SAlexey Kardashevskiy sizeof(hypercall))) { 504f7d69146SAlexander Graf _FDT((fdt_property(fdt, "hcall-instructions", hypercall, 505f7d69146SAlexander Graf sizeof(hypercall)))); 506f7d69146SAlexander Graf } 5070ddbd053SAlexey Kardashevskiy } 508f7d69146SAlexander Graf _FDT((fdt_end_node(fdt))); 509f7d69146SAlexander Graf } 510f7d69146SAlexander Graf 51153018216SPaolo Bonzini _FDT((fdt_end_node(fdt))); /* close root node */ 51253018216SPaolo Bonzini _FDT((fdt_finish(fdt))); 51353018216SPaolo Bonzini 51453018216SPaolo Bonzini return fdt; 51553018216SPaolo Bonzini } 51653018216SPaolo Bonzini 51703d196b7SBharata B Rao static int spapr_populate_memory_node(void *fdt, int nodeid, hwaddr start, 51826a8c353SAlexey Kardashevskiy hwaddr size) 51926a8c353SAlexey Kardashevskiy { 52026a8c353SAlexey Kardashevskiy uint32_t associativity[] = { 52126a8c353SAlexey Kardashevskiy cpu_to_be32(0x4), /* length */ 52226a8c353SAlexey Kardashevskiy cpu_to_be32(0x0), cpu_to_be32(0x0), 523c3b4f589SAlexey Kardashevskiy cpu_to_be32(0x0), cpu_to_be32(nodeid) 52426a8c353SAlexey Kardashevskiy }; 52526a8c353SAlexey Kardashevskiy char mem_name[32]; 52626a8c353SAlexey Kardashevskiy uint64_t mem_reg_property[2]; 52726a8c353SAlexey Kardashevskiy int off; 52826a8c353SAlexey Kardashevskiy 52926a8c353SAlexey Kardashevskiy mem_reg_property[0] = cpu_to_be64(start); 53026a8c353SAlexey Kardashevskiy mem_reg_property[1] = cpu_to_be64(size); 53126a8c353SAlexey Kardashevskiy 53226a8c353SAlexey Kardashevskiy sprintf(mem_name, "memory@" TARGET_FMT_lx, start); 53326a8c353SAlexey Kardashevskiy off = fdt_add_subnode(fdt, 0, mem_name); 53426a8c353SAlexey Kardashevskiy _FDT(off); 53526a8c353SAlexey Kardashevskiy _FDT((fdt_setprop_string(fdt, off, "device_type", "memory"))); 53626a8c353SAlexey Kardashevskiy _FDT((fdt_setprop(fdt, off, "reg", mem_reg_property, 53726a8c353SAlexey Kardashevskiy sizeof(mem_reg_property)))); 53826a8c353SAlexey Kardashevskiy _FDT((fdt_setprop(fdt, off, "ibm,associativity", associativity, 53926a8c353SAlexey Kardashevskiy sizeof(associativity)))); 54003d196b7SBharata B Rao return off; 54126a8c353SAlexey Kardashevskiy } 54226a8c353SAlexey Kardashevskiy 54328e02042SDavid Gibson static int spapr_populate_memory(sPAPRMachineState *spapr, void *fdt) 54453018216SPaolo Bonzini { 545fb164994SDavid Gibson MachineState *machine = MACHINE(spapr); 5467db8a127SAlexey Kardashevskiy hwaddr mem_start, node_size; 5477db8a127SAlexey Kardashevskiy int i, nb_nodes = nb_numa_nodes; 5487db8a127SAlexey Kardashevskiy NodeInfo *nodes = numa_info; 5497db8a127SAlexey Kardashevskiy NodeInfo ramnode; 55053018216SPaolo Bonzini 5517db8a127SAlexey Kardashevskiy /* No NUMA nodes, assume there is just one node with whole RAM */ 5527db8a127SAlexey Kardashevskiy if (!nb_numa_nodes) { 5537db8a127SAlexey Kardashevskiy nb_nodes = 1; 554fb164994SDavid Gibson ramnode.node_mem = machine->ram_size; 5557db8a127SAlexey Kardashevskiy nodes = &ramnode; 5565fe269b1SPaul Mackerras } 55753018216SPaolo Bonzini 5587db8a127SAlexey Kardashevskiy for (i = 0, mem_start = 0; i < nb_nodes; ++i) { 5597db8a127SAlexey Kardashevskiy if (!nodes[i].node_mem) { 5607db8a127SAlexey Kardashevskiy continue; 56153018216SPaolo Bonzini } 562fb164994SDavid Gibson if (mem_start >= machine->ram_size) { 5635fe269b1SPaul Mackerras node_size = 0; 5645fe269b1SPaul Mackerras } else { 5657db8a127SAlexey Kardashevskiy node_size = nodes[i].node_mem; 566fb164994SDavid Gibson if (node_size > machine->ram_size - mem_start) { 567fb164994SDavid Gibson node_size = machine->ram_size - mem_start; 5685fe269b1SPaul Mackerras } 5695fe269b1SPaul Mackerras } 5707db8a127SAlexey Kardashevskiy if (!mem_start) { 5717db8a127SAlexey Kardashevskiy /* ppc_spapr_init() checks for rma_size <= node0_size already */ 572e8f986fcSBharata B Rao spapr_populate_memory_node(fdt, i, 0, spapr->rma_size); 5737db8a127SAlexey Kardashevskiy mem_start += spapr->rma_size; 5747db8a127SAlexey Kardashevskiy node_size -= spapr->rma_size; 5757db8a127SAlexey Kardashevskiy } 5766010818cSAlexey Kardashevskiy for ( ; node_size; ) { 5776010818cSAlexey Kardashevskiy hwaddr sizetmp = pow2floor(node_size); 5786010818cSAlexey Kardashevskiy 5796010818cSAlexey Kardashevskiy /* mem_start != 0 here */ 5806010818cSAlexey Kardashevskiy if (ctzl(mem_start) < ctzl(sizetmp)) { 5816010818cSAlexey Kardashevskiy sizetmp = 1ULL << ctzl(mem_start); 5826010818cSAlexey Kardashevskiy } 5836010818cSAlexey Kardashevskiy 5846010818cSAlexey Kardashevskiy spapr_populate_memory_node(fdt, i, mem_start, sizetmp); 5856010818cSAlexey Kardashevskiy node_size -= sizetmp; 5866010818cSAlexey Kardashevskiy mem_start += sizetmp; 5876010818cSAlexey Kardashevskiy } 58853018216SPaolo Bonzini } 58953018216SPaolo Bonzini 59053018216SPaolo Bonzini return 0; 59153018216SPaolo Bonzini } 59253018216SPaolo Bonzini 5930da6f3feSBharata B Rao static void spapr_populate_cpu_dt(CPUState *cs, void *fdt, int offset, 5940da6f3feSBharata B Rao sPAPRMachineState *spapr) 5950da6f3feSBharata B Rao { 5960da6f3feSBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(cs); 5970da6f3feSBharata B Rao CPUPPCState *env = &cpu->env; 5980da6f3feSBharata B Rao PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(cs); 5990da6f3feSBharata B Rao int index = ppc_get_vcpu_dt_id(cpu); 6000da6f3feSBharata B Rao uint32_t segs[] = {cpu_to_be32(28), cpu_to_be32(40), 6010da6f3feSBharata B Rao 0xffffffff, 0xffffffff}; 602afd10a0fSBharata B Rao uint32_t tbfreq = kvm_enabled() ? kvmppc_get_tbfreq() 603afd10a0fSBharata B Rao : SPAPR_TIMEBASE_FREQ; 6040da6f3feSBharata B Rao uint32_t cpufreq = kvm_enabled() ? kvmppc_get_clockfreq() : 1000000000; 6050da6f3feSBharata B Rao uint32_t page_sizes_prop[64]; 6060da6f3feSBharata B Rao size_t page_sizes_prop_size; 60722419c2aSDavid Gibson uint32_t vcpus_per_socket = smp_threads * smp_cores; 6080da6f3feSBharata B Rao uint32_t pft_size_prop[] = {0, cpu_to_be32(spapr->htab_shift)}; 609af81cf32SBharata B Rao sPAPRDRConnector *drc; 610af81cf32SBharata B Rao sPAPRDRConnectorClass *drck; 611af81cf32SBharata B Rao int drc_index; 612af81cf32SBharata B Rao 613af81cf32SBharata B Rao drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_CPU, index); 614af81cf32SBharata B Rao if (drc) { 615af81cf32SBharata B Rao drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 616af81cf32SBharata B Rao drc_index = drck->get_index(drc); 617af81cf32SBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,my-drc-index", drc_index))); 618af81cf32SBharata B Rao } 6190da6f3feSBharata B Rao 62090da0d5aSBenjamin Herrenschmidt /* Note: we keep CI large pages off for now because a 64K capable guest 62190da0d5aSBenjamin Herrenschmidt * provisioned with large pages might otherwise try to map a qemu 62290da0d5aSBenjamin Herrenschmidt * framebuffer (or other kind of memory mapped PCI BAR) using 64K pages 62390da0d5aSBenjamin Herrenschmidt * even if that qemu runs on a 4k host. 62490da0d5aSBenjamin Herrenschmidt * 62590da0d5aSBenjamin Herrenschmidt * We can later add this bit back when we are confident this is not 62690da0d5aSBenjamin Herrenschmidt * an issue (!HV KVM or 64K host) 62790da0d5aSBenjamin Herrenschmidt */ 62890da0d5aSBenjamin Herrenschmidt uint8_t pa_features_206[] = { 6, 0, 62990da0d5aSBenjamin Herrenschmidt 0xf6, 0x1f, 0xc7, 0x00, 0x80, 0xc0 }; 63090da0d5aSBenjamin Herrenschmidt uint8_t pa_features_207[] = { 24, 0, 63190da0d5aSBenjamin Herrenschmidt 0xf6, 0x1f, 0xc7, 0xc0, 0x80, 0xf0, 63290da0d5aSBenjamin Herrenschmidt 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 63390da0d5aSBenjamin Herrenschmidt 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 63490da0d5aSBenjamin Herrenschmidt 0x80, 0x00, 0x80, 0x00, 0x80, 0x00 }; 63590da0d5aSBenjamin Herrenschmidt uint8_t *pa_features; 63690da0d5aSBenjamin Herrenschmidt size_t pa_size; 63790da0d5aSBenjamin Herrenschmidt 6380da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "reg", index))); 6390da6f3feSBharata B Rao _FDT((fdt_setprop_string(fdt, offset, "device_type", "cpu"))); 6400da6f3feSBharata B Rao 6410da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "cpu-version", env->spr[SPR_PVR]))); 6420da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "d-cache-block-size", 6430da6f3feSBharata B Rao env->dcache_line_size))); 6440da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "d-cache-line-size", 6450da6f3feSBharata B Rao env->dcache_line_size))); 6460da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "i-cache-block-size", 6470da6f3feSBharata B Rao env->icache_line_size))); 6480da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "i-cache-line-size", 6490da6f3feSBharata B Rao env->icache_line_size))); 6500da6f3feSBharata B Rao 6510da6f3feSBharata B Rao if (pcc->l1_dcache_size) { 6520da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "d-cache-size", 6530da6f3feSBharata B Rao pcc->l1_dcache_size))); 6540da6f3feSBharata B Rao } else { 6550da6f3feSBharata B Rao fprintf(stderr, "Warning: Unknown L1 dcache size for cpu\n"); 6560da6f3feSBharata B Rao } 6570da6f3feSBharata B Rao if (pcc->l1_icache_size) { 6580da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "i-cache-size", 6590da6f3feSBharata B Rao pcc->l1_icache_size))); 6600da6f3feSBharata B Rao } else { 6610da6f3feSBharata B Rao fprintf(stderr, "Warning: Unknown L1 icache size for cpu\n"); 6620da6f3feSBharata B Rao } 6630da6f3feSBharata B Rao 6640da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "timebase-frequency", tbfreq))); 6650da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "clock-frequency", cpufreq))); 666fd5da5c4SThomas Huth _FDT((fdt_setprop_cell(fdt, offset, "slb-size", env->slb_nr))); 6670da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,slb-size", env->slb_nr))); 6680da6f3feSBharata B Rao _FDT((fdt_setprop_string(fdt, offset, "status", "okay"))); 6690da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "64-bit", NULL, 0))); 6700da6f3feSBharata B Rao 6710da6f3feSBharata B Rao if (env->spr_cb[SPR_PURR].oea_read) { 6720da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,purr", NULL, 0))); 6730da6f3feSBharata B Rao } 6740da6f3feSBharata B Rao 6750da6f3feSBharata B Rao if (env->mmu_model & POWERPC_MMU_1TSEG) { 6760da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,processor-segment-sizes", 6770da6f3feSBharata B Rao segs, sizeof(segs)))); 6780da6f3feSBharata B Rao } 6790da6f3feSBharata B Rao 6800da6f3feSBharata B Rao /* Advertise VMX/VSX (vector extensions) if available 6810da6f3feSBharata B Rao * 0 / no property == no vector extensions 6820da6f3feSBharata B Rao * 1 == VMX / Altivec available 6830da6f3feSBharata B Rao * 2 == VSX available */ 6840da6f3feSBharata B Rao if (env->insns_flags & PPC_ALTIVEC) { 6850da6f3feSBharata B Rao uint32_t vmx = (env->insns_flags2 & PPC2_VSX) ? 2 : 1; 6860da6f3feSBharata B Rao 6870da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,vmx", vmx))); 6880da6f3feSBharata B Rao } 6890da6f3feSBharata B Rao 6900da6f3feSBharata B Rao /* Advertise DFP (Decimal Floating Point) if available 6910da6f3feSBharata B Rao * 0 / no property == no DFP 6920da6f3feSBharata B Rao * 1 == DFP available */ 6930da6f3feSBharata B Rao if (env->insns_flags2 & PPC2_DFP) { 6940da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,dfp", 1))); 6950da6f3feSBharata B Rao } 6960da6f3feSBharata B Rao 6970da6f3feSBharata B Rao page_sizes_prop_size = create_page_sizes_prop(env, page_sizes_prop, 6980da6f3feSBharata B Rao sizeof(page_sizes_prop)); 6990da6f3feSBharata B Rao if (page_sizes_prop_size) { 7000da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,segment-page-sizes", 7010da6f3feSBharata B Rao page_sizes_prop, page_sizes_prop_size))); 7020da6f3feSBharata B Rao } 7030da6f3feSBharata B Rao 70490da0d5aSBenjamin Herrenschmidt /* Do the ibm,pa-features property, adjust it for ci-large-pages */ 70590da0d5aSBenjamin Herrenschmidt if (env->mmu_model == POWERPC_MMU_2_06) { 70690da0d5aSBenjamin Herrenschmidt pa_features = pa_features_206; 70790da0d5aSBenjamin Herrenschmidt pa_size = sizeof(pa_features_206); 70890da0d5aSBenjamin Herrenschmidt } else /* env->mmu_model == POWERPC_MMU_2_07 */ { 70990da0d5aSBenjamin Herrenschmidt pa_features = pa_features_207; 71090da0d5aSBenjamin Herrenschmidt pa_size = sizeof(pa_features_207); 71190da0d5aSBenjamin Herrenschmidt } 71290da0d5aSBenjamin Herrenschmidt if (env->ci_large_pages) { 71390da0d5aSBenjamin Herrenschmidt pa_features[3] |= 0x20; 71490da0d5aSBenjamin Herrenschmidt } 71590da0d5aSBenjamin Herrenschmidt _FDT((fdt_setprop(fdt, offset, "ibm,pa-features", pa_features, pa_size))); 71690da0d5aSBenjamin Herrenschmidt 7170da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,chip-id", 71822419c2aSDavid Gibson cs->cpu_index / vcpus_per_socket))); 7190da6f3feSBharata B Rao 7200da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,pft-size", 7210da6f3feSBharata B Rao pft_size_prop, sizeof(pft_size_prop)))); 7220da6f3feSBharata B Rao 7230da6f3feSBharata B Rao _FDT(spapr_fixup_cpu_numa_dt(fdt, offset, cs)); 7240da6f3feSBharata B Rao 7250da6f3feSBharata B Rao _FDT(spapr_fixup_cpu_smt_dt(fdt, offset, cpu, 7260da6f3feSBharata B Rao ppc_get_compat_smt_threads(cpu))); 7270da6f3feSBharata B Rao } 7280da6f3feSBharata B Rao 7290da6f3feSBharata B Rao static void spapr_populate_cpus_dt_node(void *fdt, sPAPRMachineState *spapr) 7300da6f3feSBharata B Rao { 7310da6f3feSBharata B Rao CPUState *cs; 7320da6f3feSBharata B Rao int cpus_offset; 7330da6f3feSBharata B Rao char *nodename; 7340da6f3feSBharata B Rao int smt = kvmppc_smt_threads(); 7350da6f3feSBharata B Rao 7360da6f3feSBharata B Rao cpus_offset = fdt_add_subnode(fdt, 0, "cpus"); 7370da6f3feSBharata B Rao _FDT(cpus_offset); 7380da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, cpus_offset, "#address-cells", 0x1))); 7390da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, cpus_offset, "#size-cells", 0x0))); 7400da6f3feSBharata B Rao 7410da6f3feSBharata B Rao /* 7420da6f3feSBharata B Rao * We walk the CPUs in reverse order to ensure that CPU DT nodes 7430da6f3feSBharata B Rao * created by fdt_add_subnode() end up in the right order in FDT 7440da6f3feSBharata B Rao * for the guest kernel the enumerate the CPUs correctly. 7450da6f3feSBharata B Rao */ 7460da6f3feSBharata B Rao CPU_FOREACH_REVERSE(cs) { 7470da6f3feSBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(cs); 7480da6f3feSBharata B Rao int index = ppc_get_vcpu_dt_id(cpu); 7490da6f3feSBharata B Rao DeviceClass *dc = DEVICE_GET_CLASS(cs); 7500da6f3feSBharata B Rao int offset; 7510da6f3feSBharata B Rao 7520da6f3feSBharata B Rao if ((index % smt) != 0) { 7530da6f3feSBharata B Rao continue; 7540da6f3feSBharata B Rao } 7550da6f3feSBharata B Rao 7560da6f3feSBharata B Rao nodename = g_strdup_printf("%s@%x", dc->fw_name, index); 7570da6f3feSBharata B Rao offset = fdt_add_subnode(fdt, cpus_offset, nodename); 7580da6f3feSBharata B Rao g_free(nodename); 7590da6f3feSBharata B Rao _FDT(offset); 7600da6f3feSBharata B Rao spapr_populate_cpu_dt(cs, fdt, offset, spapr); 7610da6f3feSBharata B Rao } 7620da6f3feSBharata B Rao 7630da6f3feSBharata B Rao } 7640da6f3feSBharata B Rao 76503d196b7SBharata B Rao /* 76603d196b7SBharata B Rao * Adds ibm,dynamic-reconfiguration-memory node. 76703d196b7SBharata B Rao * Refer to docs/specs/ppc-spapr-hotplug.txt for the documentation 76803d196b7SBharata B Rao * of this device tree node. 76903d196b7SBharata B Rao */ 77003d196b7SBharata B Rao static int spapr_populate_drconf_memory(sPAPRMachineState *spapr, void *fdt) 77103d196b7SBharata B Rao { 77203d196b7SBharata B Rao MachineState *machine = MACHINE(spapr); 77303d196b7SBharata B Rao int ret, i, offset; 77403d196b7SBharata B Rao uint64_t lmb_size = SPAPR_MEMORY_BLOCK_SIZE; 77503d196b7SBharata B Rao uint32_t prop_lmb_size[] = {0, cpu_to_be32(lmb_size)}; 776d0e5a8f2SBharata B Rao uint32_t hotplug_lmb_start = spapr->hotplug_memory.base / lmb_size; 777d0e5a8f2SBharata B Rao uint32_t nr_lmbs = (spapr->hotplug_memory.base + 778d0e5a8f2SBharata B Rao memory_region_size(&spapr->hotplug_memory.mr)) / 779d0e5a8f2SBharata B Rao lmb_size; 78003d196b7SBharata B Rao uint32_t *int_buf, *cur_index, buf_len; 7816663864eSBharata B Rao int nr_nodes = nb_numa_nodes ? nb_numa_nodes : 1; 78203d196b7SBharata B Rao 783ef001f06SThomas Huth /* 784d0e5a8f2SBharata B Rao * Don't create the node if there is no hotpluggable memory 78516c25aefSBharata B Rao */ 786d0e5a8f2SBharata B Rao if (machine->ram_size == machine->maxram_size) { 78716c25aefSBharata B Rao return 0; 78816c25aefSBharata B Rao } 78916c25aefSBharata B Rao 79016c25aefSBharata B Rao /* 791ef001f06SThomas Huth * Allocate enough buffer size to fit in ibm,dynamic-memory 792ef001f06SThomas Huth * or ibm,associativity-lookup-arrays 793ef001f06SThomas Huth */ 794ef001f06SThomas Huth buf_len = MAX(nr_lmbs * SPAPR_DR_LMB_LIST_ENTRY_SIZE + 1, nr_nodes * 4 + 2) 795ef001f06SThomas Huth * sizeof(uint32_t); 79603d196b7SBharata B Rao cur_index = int_buf = g_malloc0(buf_len); 79703d196b7SBharata B Rao 79803d196b7SBharata B Rao offset = fdt_add_subnode(fdt, 0, "ibm,dynamic-reconfiguration-memory"); 79903d196b7SBharata B Rao 80003d196b7SBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,lmb-size", prop_lmb_size, 80103d196b7SBharata B Rao sizeof(prop_lmb_size)); 80203d196b7SBharata B Rao if (ret < 0) { 80303d196b7SBharata B Rao goto out; 80403d196b7SBharata B Rao } 80503d196b7SBharata B Rao 80603d196b7SBharata B Rao ret = fdt_setprop_cell(fdt, offset, "ibm,memory-flags-mask", 0xff); 80703d196b7SBharata B Rao if (ret < 0) { 80803d196b7SBharata B Rao goto out; 80903d196b7SBharata B Rao } 81003d196b7SBharata B Rao 81103d196b7SBharata B Rao ret = fdt_setprop_cell(fdt, offset, "ibm,memory-preservation-time", 0x0); 81203d196b7SBharata B Rao if (ret < 0) { 81303d196b7SBharata B Rao goto out; 81403d196b7SBharata B Rao } 81503d196b7SBharata B Rao 81603d196b7SBharata B Rao /* ibm,dynamic-memory */ 81703d196b7SBharata B Rao int_buf[0] = cpu_to_be32(nr_lmbs); 81803d196b7SBharata B Rao cur_index++; 81903d196b7SBharata B Rao for (i = 0; i < nr_lmbs; i++) { 820d0e5a8f2SBharata B Rao uint64_t addr = i * lmb_size; 82103d196b7SBharata B Rao uint32_t *dynamic_memory = cur_index; 82203d196b7SBharata B Rao 823d0e5a8f2SBharata B Rao if (i >= hotplug_lmb_start) { 824d0e5a8f2SBharata B Rao sPAPRDRConnector *drc; 825d0e5a8f2SBharata B Rao sPAPRDRConnectorClass *drck; 826d0e5a8f2SBharata B Rao 827d0e5a8f2SBharata B Rao drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_LMB, i); 82803d196b7SBharata B Rao g_assert(drc); 82903d196b7SBharata B Rao drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 83003d196b7SBharata B Rao 83103d196b7SBharata B Rao dynamic_memory[0] = cpu_to_be32(addr >> 32); 83203d196b7SBharata B Rao dynamic_memory[1] = cpu_to_be32(addr & 0xffffffff); 83303d196b7SBharata B Rao dynamic_memory[2] = cpu_to_be32(drck->get_index(drc)); 83403d196b7SBharata B Rao dynamic_memory[3] = cpu_to_be32(0); /* reserved */ 83503d196b7SBharata B Rao dynamic_memory[4] = cpu_to_be32(numa_get_node(addr, NULL)); 836d0e5a8f2SBharata B Rao if (memory_region_present(get_system_memory(), addr)) { 83703d196b7SBharata B Rao dynamic_memory[5] = cpu_to_be32(SPAPR_LMB_FLAGS_ASSIGNED); 83803d196b7SBharata B Rao } else { 83903d196b7SBharata B Rao dynamic_memory[5] = cpu_to_be32(0); 84003d196b7SBharata B Rao } 841d0e5a8f2SBharata B Rao } else { 842d0e5a8f2SBharata B Rao /* 843d0e5a8f2SBharata B Rao * LMB information for RMA, boot time RAM and gap b/n RAM and 844d0e5a8f2SBharata B Rao * hotplug memory region -- all these are marked as reserved 845d0e5a8f2SBharata B Rao * and as having no valid DRC. 846d0e5a8f2SBharata B Rao */ 847d0e5a8f2SBharata B Rao dynamic_memory[0] = cpu_to_be32(addr >> 32); 848d0e5a8f2SBharata B Rao dynamic_memory[1] = cpu_to_be32(addr & 0xffffffff); 849d0e5a8f2SBharata B Rao dynamic_memory[2] = cpu_to_be32(0); 850d0e5a8f2SBharata B Rao dynamic_memory[3] = cpu_to_be32(0); /* reserved */ 851d0e5a8f2SBharata B Rao dynamic_memory[4] = cpu_to_be32(-1); 852d0e5a8f2SBharata B Rao dynamic_memory[5] = cpu_to_be32(SPAPR_LMB_FLAGS_RESERVED | 853d0e5a8f2SBharata B Rao SPAPR_LMB_FLAGS_DRC_INVALID); 854d0e5a8f2SBharata B Rao } 85503d196b7SBharata B Rao 85603d196b7SBharata B Rao cur_index += SPAPR_DR_LMB_LIST_ENTRY_SIZE; 85703d196b7SBharata B Rao } 85803d196b7SBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,dynamic-memory", int_buf, buf_len); 85903d196b7SBharata B Rao if (ret < 0) { 86003d196b7SBharata B Rao goto out; 86103d196b7SBharata B Rao } 86203d196b7SBharata B Rao 86303d196b7SBharata B Rao /* ibm,associativity-lookup-arrays */ 86403d196b7SBharata B Rao cur_index = int_buf; 8656663864eSBharata B Rao int_buf[0] = cpu_to_be32(nr_nodes); 86603d196b7SBharata B Rao int_buf[1] = cpu_to_be32(4); /* Number of entries per associativity list */ 86703d196b7SBharata B Rao cur_index += 2; 8686663864eSBharata B Rao for (i = 0; i < nr_nodes; i++) { 86903d196b7SBharata B Rao uint32_t associativity[] = { 87003d196b7SBharata B Rao cpu_to_be32(0x0), 87103d196b7SBharata B Rao cpu_to_be32(0x0), 87203d196b7SBharata B Rao cpu_to_be32(0x0), 87303d196b7SBharata B Rao cpu_to_be32(i) 87403d196b7SBharata B Rao }; 87503d196b7SBharata B Rao memcpy(cur_index, associativity, sizeof(associativity)); 87603d196b7SBharata B Rao cur_index += 4; 87703d196b7SBharata B Rao } 87803d196b7SBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,associativity-lookup-arrays", int_buf, 87903d196b7SBharata B Rao (cur_index - int_buf) * sizeof(uint32_t)); 88003d196b7SBharata B Rao out: 88103d196b7SBharata B Rao g_free(int_buf); 88203d196b7SBharata B Rao return ret; 88303d196b7SBharata B Rao } 88403d196b7SBharata B Rao 88503d196b7SBharata B Rao int spapr_h_cas_compose_response(sPAPRMachineState *spapr, 88603d196b7SBharata B Rao target_ulong addr, target_ulong size, 88703d196b7SBharata B Rao bool cpu_update, bool memory_update) 88803d196b7SBharata B Rao { 88903d196b7SBharata B Rao void *fdt, *fdt_skel; 89003d196b7SBharata B Rao sPAPRDeviceTreeUpdateHeader hdr = { .version_id = 1 }; 89103d196b7SBharata B Rao sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(qdev_get_machine()); 89203d196b7SBharata B Rao 89303d196b7SBharata B Rao size -= sizeof(hdr); 89403d196b7SBharata B Rao 89503d196b7SBharata B Rao /* Create sceleton */ 89603d196b7SBharata B Rao fdt_skel = g_malloc0(size); 89703d196b7SBharata B Rao _FDT((fdt_create(fdt_skel, size))); 89803d196b7SBharata B Rao _FDT((fdt_begin_node(fdt_skel, ""))); 89903d196b7SBharata B Rao _FDT((fdt_end_node(fdt_skel))); 90003d196b7SBharata B Rao _FDT((fdt_finish(fdt_skel))); 90103d196b7SBharata B Rao fdt = g_malloc0(size); 90203d196b7SBharata B Rao _FDT((fdt_open_into(fdt_skel, fdt, size))); 90303d196b7SBharata B Rao g_free(fdt_skel); 90403d196b7SBharata B Rao 90503d196b7SBharata B Rao /* Fixup cpu nodes */ 90603d196b7SBharata B Rao if (cpu_update) { 90703d196b7SBharata B Rao _FDT((spapr_fixup_cpu_dt(fdt, spapr))); 90803d196b7SBharata B Rao } 90903d196b7SBharata B Rao 91016c25aefSBharata B Rao /* Generate ibm,dynamic-reconfiguration-memory node if required */ 91103d196b7SBharata B Rao if (memory_update && smc->dr_lmb_enabled) { 91203d196b7SBharata B Rao _FDT((spapr_populate_drconf_memory(spapr, fdt))); 91303d196b7SBharata B Rao } 91403d196b7SBharata B Rao 91503d196b7SBharata B Rao /* Pack resulting tree */ 91603d196b7SBharata B Rao _FDT((fdt_pack(fdt))); 91703d196b7SBharata B Rao 91803d196b7SBharata B Rao if (fdt_totalsize(fdt) + sizeof(hdr) > size) { 91903d196b7SBharata B Rao trace_spapr_cas_failed(size); 92003d196b7SBharata B Rao return -1; 92103d196b7SBharata B Rao } 92203d196b7SBharata B Rao 92303d196b7SBharata B Rao cpu_physical_memory_write(addr, &hdr, sizeof(hdr)); 92403d196b7SBharata B Rao cpu_physical_memory_write(addr + sizeof(hdr), fdt, fdt_totalsize(fdt)); 92503d196b7SBharata B Rao trace_spapr_cas_continue(fdt_totalsize(fdt) + sizeof(hdr)); 92603d196b7SBharata B Rao g_free(fdt); 92703d196b7SBharata B Rao 92803d196b7SBharata B Rao return 0; 92903d196b7SBharata B Rao } 93003d196b7SBharata B Rao 93128e02042SDavid Gibson static void spapr_finalize_fdt(sPAPRMachineState *spapr, 93253018216SPaolo Bonzini hwaddr fdt_addr, 93353018216SPaolo Bonzini hwaddr rtas_addr, 93453018216SPaolo Bonzini hwaddr rtas_size) 93553018216SPaolo Bonzini { 9365b2128d2SAlexander Graf MachineState *machine = MACHINE(qdev_get_machine()); 937c20d332aSBharata B Rao sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(machine); 9385b2128d2SAlexander Graf const char *boot_device = machine->boot_order; 93971461b0fSAlexey Kardashevskiy int ret, i; 94071461b0fSAlexey Kardashevskiy size_t cb = 0; 94171461b0fSAlexey Kardashevskiy char *bootlist; 94253018216SPaolo Bonzini void *fdt; 94353018216SPaolo Bonzini sPAPRPHBState *phb; 94453018216SPaolo Bonzini 94553018216SPaolo Bonzini fdt = g_malloc(FDT_MAX_SIZE); 94653018216SPaolo Bonzini 94753018216SPaolo Bonzini /* open out the base tree into a temp buffer for the final tweaks */ 94853018216SPaolo Bonzini _FDT((fdt_open_into(spapr->fdt_skel, fdt, FDT_MAX_SIZE))); 94953018216SPaolo Bonzini 950e8f986fcSBharata B Rao ret = spapr_populate_memory(spapr, fdt); 951e8f986fcSBharata B Rao if (ret < 0) { 952e8f986fcSBharata B Rao fprintf(stderr, "couldn't setup memory nodes in fdt\n"); 953e8f986fcSBharata B Rao exit(1); 95453018216SPaolo Bonzini } 95553018216SPaolo Bonzini 95653018216SPaolo Bonzini ret = spapr_populate_vdevice(spapr->vio_bus, fdt); 95753018216SPaolo Bonzini if (ret < 0) { 95853018216SPaolo Bonzini fprintf(stderr, "couldn't setup vio devices in fdt\n"); 95953018216SPaolo Bonzini exit(1); 96053018216SPaolo Bonzini } 96153018216SPaolo Bonzini 9624d9392beSThomas Huth if (object_resolve_path_type("", TYPE_SPAPR_RNG, NULL)) { 9634d9392beSThomas Huth ret = spapr_rng_populate_dt(fdt); 9644d9392beSThomas Huth if (ret < 0) { 9654d9392beSThomas Huth fprintf(stderr, "could not set up rng device in the fdt\n"); 9664d9392beSThomas Huth exit(1); 9674d9392beSThomas Huth } 9684d9392beSThomas Huth } 9694d9392beSThomas Huth 97053018216SPaolo Bonzini QLIST_FOREACH(phb, &spapr->phbs, list) { 97153018216SPaolo Bonzini ret = spapr_populate_pci_dt(phb, PHANDLE_XICP, fdt); 97253018216SPaolo Bonzini if (ret < 0) { 973da34fed7SThomas Huth error_report("couldn't setup PCI devices in fdt"); 97453018216SPaolo Bonzini exit(1); 97553018216SPaolo Bonzini } 976da34fed7SThomas Huth } 97753018216SPaolo Bonzini 97853018216SPaolo Bonzini /* RTAS */ 97953018216SPaolo Bonzini ret = spapr_rtas_device_tree_setup(fdt, rtas_addr, rtas_size); 98053018216SPaolo Bonzini if (ret < 0) { 98153018216SPaolo Bonzini fprintf(stderr, "Couldn't set up RTAS device tree properties\n"); 98253018216SPaolo Bonzini } 98353018216SPaolo Bonzini 9840da6f3feSBharata B Rao /* cpus */ 9850da6f3feSBharata B Rao spapr_populate_cpus_dt_node(fdt, spapr); 98653018216SPaolo Bonzini 98771461b0fSAlexey Kardashevskiy bootlist = get_boot_devices_list(&cb, true); 98871461b0fSAlexey Kardashevskiy if (cb && bootlist) { 98971461b0fSAlexey Kardashevskiy int offset = fdt_path_offset(fdt, "/chosen"); 99071461b0fSAlexey Kardashevskiy if (offset < 0) { 99171461b0fSAlexey Kardashevskiy exit(1); 99271461b0fSAlexey Kardashevskiy } 99371461b0fSAlexey Kardashevskiy for (i = 0; i < cb; i++) { 99471461b0fSAlexey Kardashevskiy if (bootlist[i] == '\n') { 99571461b0fSAlexey Kardashevskiy bootlist[i] = ' '; 99671461b0fSAlexey Kardashevskiy } 99771461b0fSAlexey Kardashevskiy 99871461b0fSAlexey Kardashevskiy } 99971461b0fSAlexey Kardashevskiy ret = fdt_setprop_string(fdt, offset, "qemu,boot-list", bootlist); 100071461b0fSAlexey Kardashevskiy } 100171461b0fSAlexey Kardashevskiy 10025b2128d2SAlexander Graf if (boot_device && strlen(boot_device)) { 10035b2128d2SAlexander Graf int offset = fdt_path_offset(fdt, "/chosen"); 10045b2128d2SAlexander Graf 10055b2128d2SAlexander Graf if (offset < 0) { 10065b2128d2SAlexander Graf exit(1); 10075b2128d2SAlexander Graf } 10085b2128d2SAlexander Graf fdt_setprop_string(fdt, offset, "qemu,boot-device", boot_device); 10095b2128d2SAlexander Graf } 10105b2128d2SAlexander Graf 101153018216SPaolo Bonzini if (!spapr->has_graphics) { 101253018216SPaolo Bonzini spapr_populate_chosen_stdout(fdt, spapr->vio_bus); 101353018216SPaolo Bonzini } 101453018216SPaolo Bonzini 1015c20d332aSBharata B Rao if (smc->dr_lmb_enabled) { 1016c20d332aSBharata B Rao _FDT(spapr_drc_populate_dt(fdt, 0, NULL, SPAPR_DR_CONNECTOR_TYPE_LMB)); 1017c20d332aSBharata B Rao } 1018c20d332aSBharata B Rao 1019af81cf32SBharata B Rao if (smc->dr_cpu_enabled) { 1020af81cf32SBharata B Rao int offset = fdt_path_offset(fdt, "/cpus"); 1021af81cf32SBharata B Rao ret = spapr_drc_populate_dt(fdt, offset, NULL, 1022af81cf32SBharata B Rao SPAPR_DR_CONNECTOR_TYPE_CPU); 1023af81cf32SBharata B Rao if (ret < 0) { 1024af81cf32SBharata B Rao error_report("Couldn't set up CPU DR device tree properties"); 1025af81cf32SBharata B Rao exit(1); 1026af81cf32SBharata B Rao } 1027af81cf32SBharata B Rao } 1028af81cf32SBharata B Rao 102953018216SPaolo Bonzini _FDT((fdt_pack(fdt))); 103053018216SPaolo Bonzini 103153018216SPaolo Bonzini if (fdt_totalsize(fdt) > FDT_MAX_SIZE) { 1032730fce59SThomas Huth error_report("FDT too big ! 0x%x bytes (max is 0x%x)", 103353018216SPaolo Bonzini fdt_totalsize(fdt), FDT_MAX_SIZE); 103453018216SPaolo Bonzini exit(1); 103553018216SPaolo Bonzini } 103653018216SPaolo Bonzini 1037ad440b4aSAndrew Jones qemu_fdt_dumpdtb(fdt, fdt_totalsize(fdt)); 103853018216SPaolo Bonzini cpu_physical_memory_write(fdt_addr, fdt, fdt_totalsize(fdt)); 103953018216SPaolo Bonzini 1040a21a7a70SGonglei g_free(bootlist); 104153018216SPaolo Bonzini g_free(fdt); 104253018216SPaolo Bonzini } 104353018216SPaolo Bonzini 104453018216SPaolo Bonzini static uint64_t translate_kernel_address(void *opaque, uint64_t addr) 104553018216SPaolo Bonzini { 104653018216SPaolo Bonzini return (addr & 0x0fffffff) + KERNEL_LOAD_ADDR; 104753018216SPaolo Bonzini } 104853018216SPaolo Bonzini 104953018216SPaolo Bonzini static void emulate_spapr_hypercall(PowerPCCPU *cpu) 105053018216SPaolo Bonzini { 105153018216SPaolo Bonzini CPUPPCState *env = &cpu->env; 105253018216SPaolo Bonzini 105353018216SPaolo Bonzini if (msr_pr) { 105453018216SPaolo Bonzini hcall_dprintf("Hypercall made with MSR[PR]=1\n"); 105553018216SPaolo Bonzini env->gpr[3] = H_PRIVILEGE; 105653018216SPaolo Bonzini } else { 105753018216SPaolo Bonzini env->gpr[3] = spapr_hypercall(cpu, env->gpr[3], &env->gpr[4]); 105853018216SPaolo Bonzini } 105953018216SPaolo Bonzini } 106053018216SPaolo Bonzini 1061e6b8fd24SSamuel Mendoza-Jonas #define HPTE(_table, _i) (void *)(((uint64_t *)(_table)) + ((_i) * 2)) 1062e6b8fd24SSamuel Mendoza-Jonas #define HPTE_VALID(_hpte) (tswap64(*((uint64_t *)(_hpte))) & HPTE64_V_VALID) 1063e6b8fd24SSamuel Mendoza-Jonas #define HPTE_DIRTY(_hpte) (tswap64(*((uint64_t *)(_hpte))) & HPTE64_V_HPTE_DIRTY) 1064e6b8fd24SSamuel Mendoza-Jonas #define CLEAN_HPTE(_hpte) ((*(uint64_t *)(_hpte)) &= tswap64(~HPTE64_V_HPTE_DIRTY)) 1065e6b8fd24SSamuel Mendoza-Jonas #define DIRTY_HPTE(_hpte) ((*(uint64_t *)(_hpte)) |= tswap64(HPTE64_V_HPTE_DIRTY)) 1066e6b8fd24SSamuel Mendoza-Jonas 1067715c5407SDavid Gibson /* 1068715c5407SDavid Gibson * Get the fd to access the kernel htab, re-opening it if necessary 1069715c5407SDavid Gibson */ 1070715c5407SDavid Gibson static int get_htab_fd(sPAPRMachineState *spapr) 1071715c5407SDavid Gibson { 1072715c5407SDavid Gibson if (spapr->htab_fd >= 0) { 1073715c5407SDavid Gibson return spapr->htab_fd; 1074715c5407SDavid Gibson } 1075715c5407SDavid Gibson 1076715c5407SDavid Gibson spapr->htab_fd = kvmppc_get_htab_fd(false); 1077715c5407SDavid Gibson if (spapr->htab_fd < 0) { 1078715c5407SDavid Gibson error_report("Unable to open fd for reading hash table from KVM: %s", 1079715c5407SDavid Gibson strerror(errno)); 1080715c5407SDavid Gibson } 1081715c5407SDavid Gibson 1082715c5407SDavid Gibson return spapr->htab_fd; 1083715c5407SDavid Gibson } 1084715c5407SDavid Gibson 1085715c5407SDavid Gibson static void close_htab_fd(sPAPRMachineState *spapr) 1086715c5407SDavid Gibson { 1087715c5407SDavid Gibson if (spapr->htab_fd >= 0) { 1088715c5407SDavid Gibson close(spapr->htab_fd); 1089715c5407SDavid Gibson } 1090715c5407SDavid Gibson spapr->htab_fd = -1; 1091715c5407SDavid Gibson } 1092715c5407SDavid Gibson 10938dfe8e7fSDavid Gibson static int spapr_hpt_shift_for_ramsize(uint64_t ramsize) 10948dfe8e7fSDavid Gibson { 10958dfe8e7fSDavid Gibson int shift; 10968dfe8e7fSDavid Gibson 10978dfe8e7fSDavid Gibson /* We aim for a hash table of size 1/128 the size of RAM (rounded 10988dfe8e7fSDavid Gibson * up). The PAPR recommendation is actually 1/64 of RAM size, but 10998dfe8e7fSDavid Gibson * that's much more than is needed for Linux guests */ 11008dfe8e7fSDavid Gibson shift = ctz64(pow2ceil(ramsize)) - 7; 11018dfe8e7fSDavid Gibson shift = MAX(shift, 18); /* Minimum architected size */ 11028dfe8e7fSDavid Gibson shift = MIN(shift, 46); /* Maximum architected size */ 11038dfe8e7fSDavid Gibson return shift; 11048dfe8e7fSDavid Gibson } 11058dfe8e7fSDavid Gibson 1106c5f54f3eSDavid Gibson static void spapr_reallocate_hpt(sPAPRMachineState *spapr, int shift, 1107c5f54f3eSDavid Gibson Error **errp) 110853018216SPaolo Bonzini { 1109c5f54f3eSDavid Gibson long rc; 111053018216SPaolo Bonzini 1111c5f54f3eSDavid Gibson /* Clean up any HPT info from a previous boot */ 1112c5f54f3eSDavid Gibson g_free(spapr->htab); 1113c5f54f3eSDavid Gibson spapr->htab = NULL; 1114c5f54f3eSDavid Gibson spapr->htab_shift = 0; 1115c5f54f3eSDavid Gibson close_htab_fd(spapr); 111653018216SPaolo Bonzini 1117c5f54f3eSDavid Gibson rc = kvmppc_reset_htab(shift); 1118c5f54f3eSDavid Gibson if (rc < 0) { 1119c5f54f3eSDavid Gibson /* kernel-side HPT needed, but couldn't allocate one */ 1120c5f54f3eSDavid Gibson error_setg_errno(errp, errno, 1121c5f54f3eSDavid Gibson "Failed to allocate KVM HPT of order %d (try smaller maxmem?)", 1122c5f54f3eSDavid Gibson shift); 1123c5f54f3eSDavid Gibson /* This is almost certainly fatal, but if the caller really 1124c5f54f3eSDavid Gibson * wants to carry on with shift == 0, it's welcome to try */ 1125c5f54f3eSDavid Gibson } else if (rc > 0) { 1126c5f54f3eSDavid Gibson /* kernel-side HPT allocated */ 1127c5f54f3eSDavid Gibson if (rc != shift) { 1128c5f54f3eSDavid Gibson error_setg(errp, 1129c5f54f3eSDavid Gibson "Requested order %d HPT, but kernel allocated order %ld (try smaller maxmem?)", 1130c5f54f3eSDavid Gibson shift, rc); 11317735fedaSBharata B Rao } 11327735fedaSBharata B Rao 113353018216SPaolo Bonzini spapr->htab_shift = shift; 1134c18ad9a5SDavid Gibson spapr->htab = NULL; 1135b817772aSBharata B Rao } else { 1136c5f54f3eSDavid Gibson /* kernel-side HPT not needed, allocate in userspace instead */ 1137c5f54f3eSDavid Gibson size_t size = 1ULL << shift; 1138c5f54f3eSDavid Gibson int i; 113901a57972SSamuel Mendoza-Jonas 1140c5f54f3eSDavid Gibson spapr->htab = qemu_memalign(size, size); 1141c5f54f3eSDavid Gibson if (!spapr->htab) { 1142c5f54f3eSDavid Gibson error_setg_errno(errp, errno, 1143c5f54f3eSDavid Gibson "Could not allocate HPT of order %d", shift); 1144c5f54f3eSDavid Gibson return; 1145b817772aSBharata B Rao } 1146b817772aSBharata B Rao 1147c5f54f3eSDavid Gibson memset(spapr->htab, 0, size); 1148c5f54f3eSDavid Gibson spapr->htab_shift = shift; 1149b817772aSBharata B Rao 1150c5f54f3eSDavid Gibson for (i = 0; i < size / HASH_PTE_SIZE_64; i++) { 1151c5f54f3eSDavid Gibson DIRTY_HPTE(HPTE(spapr->htab, i)); 11527735fedaSBharata B Rao } 115353018216SPaolo Bonzini } 115453018216SPaolo Bonzini } 115553018216SPaolo Bonzini 11569e3f9733SAlexander Graf static int find_unknown_sysbus_device(SysBusDevice *sbdev, void *opaque) 11579e3f9733SAlexander Graf { 11589e3f9733SAlexander Graf bool matched = false; 11599e3f9733SAlexander Graf 11609e3f9733SAlexander Graf if (object_dynamic_cast(OBJECT(sbdev), TYPE_SPAPR_PCI_HOST_BRIDGE)) { 11619e3f9733SAlexander Graf matched = true; 11629e3f9733SAlexander Graf } 11639e3f9733SAlexander Graf 11649e3f9733SAlexander Graf if (!matched) { 11659e3f9733SAlexander Graf error_report("Device %s is not supported by this machine yet.", 11669e3f9733SAlexander Graf qdev_fw_name(DEVICE(sbdev))); 11679e3f9733SAlexander Graf exit(1); 11689e3f9733SAlexander Graf } 11699e3f9733SAlexander Graf 11709e3f9733SAlexander Graf return 0; 11719e3f9733SAlexander Graf } 11729e3f9733SAlexander Graf 117353018216SPaolo Bonzini static void ppc_spapr_reset(void) 117453018216SPaolo Bonzini { 1175c5f54f3eSDavid Gibson MachineState *machine = MACHINE(qdev_get_machine()); 1176c5f54f3eSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(machine); 1177182735efSAndreas Färber PowerPCCPU *first_ppc_cpu; 1178b7d1f77aSBenjamin Herrenschmidt uint32_t rtas_limit; 1179259186a7SAndreas Färber 11809e3f9733SAlexander Graf /* Check for unknown sysbus devices */ 11819e3f9733SAlexander Graf foreach_dynamic_sysbus_device(find_unknown_sysbus_device, NULL); 11829e3f9733SAlexander Graf 1183c5f54f3eSDavid Gibson /* Allocate and/or reset the hash page table */ 1184c5f54f3eSDavid Gibson spapr_reallocate_hpt(spapr, 1185c5f54f3eSDavid Gibson spapr_hpt_shift_for_ramsize(machine->maxram_size), 1186c5f54f3eSDavid Gibson &error_fatal); 1187c5f54f3eSDavid Gibson 1188c5f54f3eSDavid Gibson /* Update the RMA size if necessary */ 1189c5f54f3eSDavid Gibson if (spapr->vrma_adjust) { 1190c5f54f3eSDavid Gibson spapr->rma_size = kvmppc_rma_size(spapr_node0_size(), 1191c5f54f3eSDavid Gibson spapr->htab_shift); 1192c5f54f3eSDavid Gibson } 119353018216SPaolo Bonzini 119453018216SPaolo Bonzini qemu_devices_reset(); 119553018216SPaolo Bonzini 1196b7d1f77aSBenjamin Herrenschmidt /* 1197b7d1f77aSBenjamin Herrenschmidt * We place the device tree and RTAS just below either the top of the RMA, 1198b7d1f77aSBenjamin Herrenschmidt * or just below 2GB, whichever is lowere, so that it can be 1199b7d1f77aSBenjamin Herrenschmidt * processed with 32-bit real mode code if necessary 1200b7d1f77aSBenjamin Herrenschmidt */ 1201b7d1f77aSBenjamin Herrenschmidt rtas_limit = MIN(spapr->rma_size, RTAS_MAX_ADDR); 1202b7d1f77aSBenjamin Herrenschmidt spapr->rtas_addr = rtas_limit - RTAS_MAX_SIZE; 1203b7d1f77aSBenjamin Herrenschmidt spapr->fdt_addr = spapr->rtas_addr - FDT_MAX_SIZE; 1204b7d1f77aSBenjamin Herrenschmidt 120553018216SPaolo Bonzini /* Load the fdt */ 120653018216SPaolo Bonzini spapr_finalize_fdt(spapr, spapr->fdt_addr, spapr->rtas_addr, 120753018216SPaolo Bonzini spapr->rtas_size); 120853018216SPaolo Bonzini 1209b7d1f77aSBenjamin Herrenschmidt /* Copy RTAS over */ 1210b7d1f77aSBenjamin Herrenschmidt cpu_physical_memory_write(spapr->rtas_addr, spapr->rtas_blob, 1211b7d1f77aSBenjamin Herrenschmidt spapr->rtas_size); 1212b7d1f77aSBenjamin Herrenschmidt 121353018216SPaolo Bonzini /* Set up the entry state */ 1214182735efSAndreas Färber first_ppc_cpu = POWERPC_CPU(first_cpu); 1215182735efSAndreas Färber first_ppc_cpu->env.gpr[3] = spapr->fdt_addr; 1216182735efSAndreas Färber first_ppc_cpu->env.gpr[5] = 0; 1217182735efSAndreas Färber first_cpu->halted = 0; 12181b718907SDavid Gibson first_ppc_cpu->env.nip = SPAPR_ENTRY_POINT; 121953018216SPaolo Bonzini 122053018216SPaolo Bonzini } 122153018216SPaolo Bonzini 122228e02042SDavid Gibson static void spapr_create_nvram(sPAPRMachineState *spapr) 122353018216SPaolo Bonzini { 12242ff3de68SMarkus Armbruster DeviceState *dev = qdev_create(&spapr->vio_bus->bus, "spapr-nvram"); 12253978b863SPaolo Bonzini DriveInfo *dinfo = drive_get(IF_PFLASH, 0, 0); 122653018216SPaolo Bonzini 12273978b863SPaolo Bonzini if (dinfo) { 12286231a6daSMarkus Armbruster qdev_prop_set_drive(dev, "drive", blk_by_legacy_dinfo(dinfo), 12296231a6daSMarkus Armbruster &error_fatal); 123053018216SPaolo Bonzini } 123153018216SPaolo Bonzini 123253018216SPaolo Bonzini qdev_init_nofail(dev); 123353018216SPaolo Bonzini 123453018216SPaolo Bonzini spapr->nvram = (struct sPAPRNVRAM *)dev; 123553018216SPaolo Bonzini } 123653018216SPaolo Bonzini 123728e02042SDavid Gibson static void spapr_rtc_create(sPAPRMachineState *spapr) 123828df36a1SDavid Gibson { 123928df36a1SDavid Gibson DeviceState *dev = qdev_create(NULL, TYPE_SPAPR_RTC); 124028df36a1SDavid Gibson 124128df36a1SDavid Gibson qdev_init_nofail(dev); 124228df36a1SDavid Gibson spapr->rtc = dev; 124374e5ae28SDavid Gibson 124474e5ae28SDavid Gibson object_property_add_alias(qdev_get_machine(), "rtc-time", 124574e5ae28SDavid Gibson OBJECT(spapr->rtc), "date", NULL); 124628df36a1SDavid Gibson } 124728df36a1SDavid Gibson 124853018216SPaolo Bonzini /* Returns whether we want to use VGA or not */ 124914c6a894SDavid Gibson static bool spapr_vga_init(PCIBus *pci_bus, Error **errp) 125053018216SPaolo Bonzini { 125153018216SPaolo Bonzini switch (vga_interface_type) { 125253018216SPaolo Bonzini case VGA_NONE: 12537effdaa3SMark Wu return false; 12547effdaa3SMark Wu case VGA_DEVICE: 12557effdaa3SMark Wu return true; 125653018216SPaolo Bonzini case VGA_STD: 1257b798c190SBenjamin Herrenschmidt case VGA_VIRTIO: 125853018216SPaolo Bonzini return pci_vga_init(pci_bus) != NULL; 125953018216SPaolo Bonzini default: 126014c6a894SDavid Gibson error_setg(errp, 126114c6a894SDavid Gibson "Unsupported VGA mode, only -vga std or -vga virtio is supported"); 126214c6a894SDavid Gibson return false; 126353018216SPaolo Bonzini } 126453018216SPaolo Bonzini } 126553018216SPaolo Bonzini 1266880ae7deSDavid Gibson static int spapr_post_load(void *opaque, int version_id) 1267880ae7deSDavid Gibson { 126828e02042SDavid Gibson sPAPRMachineState *spapr = (sPAPRMachineState *)opaque; 1269880ae7deSDavid Gibson int err = 0; 1270880ae7deSDavid Gibson 1271631b22eaSStefan Weil /* In earlier versions, there was no separate qdev for the PAPR 1272880ae7deSDavid Gibson * RTC, so the RTC offset was stored directly in sPAPREnvironment. 1273880ae7deSDavid Gibson * So when migrating from those versions, poke the incoming offset 1274880ae7deSDavid Gibson * value into the RTC device */ 1275880ae7deSDavid Gibson if (version_id < 3) { 1276880ae7deSDavid Gibson err = spapr_rtc_import_offset(spapr->rtc, spapr->rtc_offset); 1277880ae7deSDavid Gibson } 1278880ae7deSDavid Gibson 1279880ae7deSDavid Gibson return err; 1280880ae7deSDavid Gibson } 1281880ae7deSDavid Gibson 1282880ae7deSDavid Gibson static bool version_before_3(void *opaque, int version_id) 1283880ae7deSDavid Gibson { 1284880ae7deSDavid Gibson return version_id < 3; 1285880ae7deSDavid Gibson } 1286880ae7deSDavid Gibson 12874be21d56SDavid Gibson static const VMStateDescription vmstate_spapr = { 12884be21d56SDavid Gibson .name = "spapr", 1289880ae7deSDavid Gibson .version_id = 3, 12904be21d56SDavid Gibson .minimum_version_id = 1, 1291880ae7deSDavid Gibson .post_load = spapr_post_load, 12924be21d56SDavid Gibson .fields = (VMStateField[]) { 1293880ae7deSDavid Gibson /* used to be @next_irq */ 1294880ae7deSDavid Gibson VMSTATE_UNUSED_BUFFER(version_before_3, 0, 4), 12954be21d56SDavid Gibson 12964be21d56SDavid Gibson /* RTC offset */ 129728e02042SDavid Gibson VMSTATE_UINT64_TEST(rtc_offset, sPAPRMachineState, version_before_3), 1298880ae7deSDavid Gibson 129928e02042SDavid Gibson VMSTATE_PPC_TIMEBASE_V(tb, sPAPRMachineState, 2), 13004be21d56SDavid Gibson VMSTATE_END_OF_LIST() 13014be21d56SDavid Gibson }, 13024be21d56SDavid Gibson }; 13034be21d56SDavid Gibson 13044be21d56SDavid Gibson static int htab_save_setup(QEMUFile *f, void *opaque) 13054be21d56SDavid Gibson { 130628e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 13074be21d56SDavid Gibson 13084be21d56SDavid Gibson /* "Iteration" header */ 13094be21d56SDavid Gibson qemu_put_be32(f, spapr->htab_shift); 13104be21d56SDavid Gibson 1311e68cb8b4SAlexey Kardashevskiy if (spapr->htab) { 1312e68cb8b4SAlexey Kardashevskiy spapr->htab_save_index = 0; 1313e68cb8b4SAlexey Kardashevskiy spapr->htab_first_pass = true; 1314e68cb8b4SAlexey Kardashevskiy } else { 1315e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 13164be21d56SDavid Gibson } 13174be21d56SDavid Gibson 1318e68cb8b4SAlexey Kardashevskiy 1319e68cb8b4SAlexey Kardashevskiy return 0; 1320e68cb8b4SAlexey Kardashevskiy } 13214be21d56SDavid Gibson 132228e02042SDavid Gibson static void htab_save_first_pass(QEMUFile *f, sPAPRMachineState *spapr, 13234be21d56SDavid Gibson int64_t max_ns) 13244be21d56SDavid Gibson { 1325378bc217SDavid Gibson bool has_timeout = max_ns != -1; 13264be21d56SDavid Gibson int htabslots = HTAB_SIZE(spapr) / HASH_PTE_SIZE_64; 13274be21d56SDavid Gibson int index = spapr->htab_save_index; 1328bc72ad67SAlex Bligh int64_t starttime = qemu_clock_get_ns(QEMU_CLOCK_REALTIME); 13294be21d56SDavid Gibson 13304be21d56SDavid Gibson assert(spapr->htab_first_pass); 13314be21d56SDavid Gibson 13324be21d56SDavid Gibson do { 13334be21d56SDavid Gibson int chunkstart; 13344be21d56SDavid Gibson 13354be21d56SDavid Gibson /* Consume invalid HPTEs */ 13364be21d56SDavid Gibson while ((index < htabslots) 13374be21d56SDavid Gibson && !HPTE_VALID(HPTE(spapr->htab, index))) { 13384be21d56SDavid Gibson index++; 13394be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 13404be21d56SDavid Gibson } 13414be21d56SDavid Gibson 13424be21d56SDavid Gibson /* Consume valid HPTEs */ 13434be21d56SDavid Gibson chunkstart = index; 1344338c25b6SSamuel Mendoza-Jonas while ((index < htabslots) && (index - chunkstart < USHRT_MAX) 13454be21d56SDavid Gibson && HPTE_VALID(HPTE(spapr->htab, index))) { 13464be21d56SDavid Gibson index++; 13474be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 13484be21d56SDavid Gibson } 13494be21d56SDavid Gibson 13504be21d56SDavid Gibson if (index > chunkstart) { 13514be21d56SDavid Gibson int n_valid = index - chunkstart; 13524be21d56SDavid Gibson 13534be21d56SDavid Gibson qemu_put_be32(f, chunkstart); 13544be21d56SDavid Gibson qemu_put_be16(f, n_valid); 13554be21d56SDavid Gibson qemu_put_be16(f, 0); 13564be21d56SDavid Gibson qemu_put_buffer(f, HPTE(spapr->htab, chunkstart), 13574be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_valid); 13584be21d56SDavid Gibson 1359378bc217SDavid Gibson if (has_timeout && 1360378bc217SDavid Gibson (qemu_clock_get_ns(QEMU_CLOCK_REALTIME) - starttime) > max_ns) { 13614be21d56SDavid Gibson break; 13624be21d56SDavid Gibson } 13634be21d56SDavid Gibson } 13644be21d56SDavid Gibson } while ((index < htabslots) && !qemu_file_rate_limit(f)); 13654be21d56SDavid Gibson 13664be21d56SDavid Gibson if (index >= htabslots) { 13674be21d56SDavid Gibson assert(index == htabslots); 13684be21d56SDavid Gibson index = 0; 13694be21d56SDavid Gibson spapr->htab_first_pass = false; 13704be21d56SDavid Gibson } 13714be21d56SDavid Gibson spapr->htab_save_index = index; 13724be21d56SDavid Gibson } 13734be21d56SDavid Gibson 137428e02042SDavid Gibson static int htab_save_later_pass(QEMUFile *f, sPAPRMachineState *spapr, 13754be21d56SDavid Gibson int64_t max_ns) 13764be21d56SDavid Gibson { 13774be21d56SDavid Gibson bool final = max_ns < 0; 13784be21d56SDavid Gibson int htabslots = HTAB_SIZE(spapr) / HASH_PTE_SIZE_64; 13794be21d56SDavid Gibson int examined = 0, sent = 0; 13804be21d56SDavid Gibson int index = spapr->htab_save_index; 1381bc72ad67SAlex Bligh int64_t starttime = qemu_clock_get_ns(QEMU_CLOCK_REALTIME); 13824be21d56SDavid Gibson 13834be21d56SDavid Gibson assert(!spapr->htab_first_pass); 13844be21d56SDavid Gibson 13854be21d56SDavid Gibson do { 13864be21d56SDavid Gibson int chunkstart, invalidstart; 13874be21d56SDavid Gibson 13884be21d56SDavid Gibson /* Consume non-dirty HPTEs */ 13894be21d56SDavid Gibson while ((index < htabslots) 13904be21d56SDavid Gibson && !HPTE_DIRTY(HPTE(spapr->htab, index))) { 13914be21d56SDavid Gibson index++; 13924be21d56SDavid Gibson examined++; 13934be21d56SDavid Gibson } 13944be21d56SDavid Gibson 13954be21d56SDavid Gibson chunkstart = index; 13964be21d56SDavid Gibson /* Consume valid dirty HPTEs */ 1397338c25b6SSamuel Mendoza-Jonas while ((index < htabslots) && (index - chunkstart < USHRT_MAX) 13984be21d56SDavid Gibson && HPTE_DIRTY(HPTE(spapr->htab, index)) 13994be21d56SDavid Gibson && HPTE_VALID(HPTE(spapr->htab, index))) { 14004be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 14014be21d56SDavid Gibson index++; 14024be21d56SDavid Gibson examined++; 14034be21d56SDavid Gibson } 14044be21d56SDavid Gibson 14054be21d56SDavid Gibson invalidstart = index; 14064be21d56SDavid Gibson /* Consume invalid dirty HPTEs */ 1407338c25b6SSamuel Mendoza-Jonas while ((index < htabslots) && (index - invalidstart < USHRT_MAX) 14084be21d56SDavid Gibson && HPTE_DIRTY(HPTE(spapr->htab, index)) 14094be21d56SDavid Gibson && !HPTE_VALID(HPTE(spapr->htab, index))) { 14104be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 14114be21d56SDavid Gibson index++; 14124be21d56SDavid Gibson examined++; 14134be21d56SDavid Gibson } 14144be21d56SDavid Gibson 14154be21d56SDavid Gibson if (index > chunkstart) { 14164be21d56SDavid Gibson int n_valid = invalidstart - chunkstart; 14174be21d56SDavid Gibson int n_invalid = index - invalidstart; 14184be21d56SDavid Gibson 14194be21d56SDavid Gibson qemu_put_be32(f, chunkstart); 14204be21d56SDavid Gibson qemu_put_be16(f, n_valid); 14214be21d56SDavid Gibson qemu_put_be16(f, n_invalid); 14224be21d56SDavid Gibson qemu_put_buffer(f, HPTE(spapr->htab, chunkstart), 14234be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_valid); 14244be21d56SDavid Gibson sent += index - chunkstart; 14254be21d56SDavid Gibson 1426bc72ad67SAlex Bligh if (!final && (qemu_clock_get_ns(QEMU_CLOCK_REALTIME) - starttime) > max_ns) { 14274be21d56SDavid Gibson break; 14284be21d56SDavid Gibson } 14294be21d56SDavid Gibson } 14304be21d56SDavid Gibson 14314be21d56SDavid Gibson if (examined >= htabslots) { 14324be21d56SDavid Gibson break; 14334be21d56SDavid Gibson } 14344be21d56SDavid Gibson 14354be21d56SDavid Gibson if (index >= htabslots) { 14364be21d56SDavid Gibson assert(index == htabslots); 14374be21d56SDavid Gibson index = 0; 14384be21d56SDavid Gibson } 14394be21d56SDavid Gibson } while ((examined < htabslots) && (!qemu_file_rate_limit(f) || final)); 14404be21d56SDavid Gibson 14414be21d56SDavid Gibson if (index >= htabslots) { 14424be21d56SDavid Gibson assert(index == htabslots); 14434be21d56SDavid Gibson index = 0; 14444be21d56SDavid Gibson } 14454be21d56SDavid Gibson 14464be21d56SDavid Gibson spapr->htab_save_index = index; 14474be21d56SDavid Gibson 1448e68cb8b4SAlexey Kardashevskiy return (examined >= htabslots) && (sent == 0) ? 1 : 0; 14494be21d56SDavid Gibson } 14504be21d56SDavid Gibson 1451e68cb8b4SAlexey Kardashevskiy #define MAX_ITERATION_NS 5000000 /* 5 ms */ 1452e68cb8b4SAlexey Kardashevskiy #define MAX_KVM_BUF_SIZE 2048 1453e68cb8b4SAlexey Kardashevskiy 14544be21d56SDavid Gibson static int htab_save_iterate(QEMUFile *f, void *opaque) 14554be21d56SDavid Gibson { 145628e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 1457715c5407SDavid Gibson int fd; 1458e68cb8b4SAlexey Kardashevskiy int rc = 0; 14594be21d56SDavid Gibson 14604be21d56SDavid Gibson /* Iteration header */ 14614be21d56SDavid Gibson qemu_put_be32(f, 0); 14624be21d56SDavid Gibson 1463e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1464e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 1465e68cb8b4SAlexey Kardashevskiy 1466715c5407SDavid Gibson fd = get_htab_fd(spapr); 1467715c5407SDavid Gibson if (fd < 0) { 1468715c5407SDavid Gibson return fd; 146901a57972SSamuel Mendoza-Jonas } 147001a57972SSamuel Mendoza-Jonas 1471715c5407SDavid Gibson rc = kvmppc_save_htab(f, fd, MAX_KVM_BUF_SIZE, MAX_ITERATION_NS); 1472e68cb8b4SAlexey Kardashevskiy if (rc < 0) { 1473e68cb8b4SAlexey Kardashevskiy return rc; 1474e68cb8b4SAlexey Kardashevskiy } 1475e68cb8b4SAlexey Kardashevskiy } else if (spapr->htab_first_pass) { 14764be21d56SDavid Gibson htab_save_first_pass(f, spapr, MAX_ITERATION_NS); 14774be21d56SDavid Gibson } else { 1478e68cb8b4SAlexey Kardashevskiy rc = htab_save_later_pass(f, spapr, MAX_ITERATION_NS); 14794be21d56SDavid Gibson } 14804be21d56SDavid Gibson 14814be21d56SDavid Gibson /* End marker */ 14824be21d56SDavid Gibson qemu_put_be32(f, 0); 14834be21d56SDavid Gibson qemu_put_be16(f, 0); 14844be21d56SDavid Gibson qemu_put_be16(f, 0); 14854be21d56SDavid Gibson 1486e68cb8b4SAlexey Kardashevskiy return rc; 14874be21d56SDavid Gibson } 14884be21d56SDavid Gibson 14894be21d56SDavid Gibson static int htab_save_complete(QEMUFile *f, void *opaque) 14904be21d56SDavid Gibson { 149128e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 1492715c5407SDavid Gibson int fd; 14934be21d56SDavid Gibson 14944be21d56SDavid Gibson /* Iteration header */ 14954be21d56SDavid Gibson qemu_put_be32(f, 0); 14964be21d56SDavid Gibson 1497e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1498e68cb8b4SAlexey Kardashevskiy int rc; 1499e68cb8b4SAlexey Kardashevskiy 1500e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 1501e68cb8b4SAlexey Kardashevskiy 1502715c5407SDavid Gibson fd = get_htab_fd(spapr); 1503715c5407SDavid Gibson if (fd < 0) { 1504715c5407SDavid Gibson return fd; 150501a57972SSamuel Mendoza-Jonas } 150601a57972SSamuel Mendoza-Jonas 1507715c5407SDavid Gibson rc = kvmppc_save_htab(f, fd, MAX_KVM_BUF_SIZE, -1); 1508e68cb8b4SAlexey Kardashevskiy if (rc < 0) { 1509e68cb8b4SAlexey Kardashevskiy return rc; 1510e68cb8b4SAlexey Kardashevskiy } 1511715c5407SDavid Gibson close_htab_fd(spapr); 1512e68cb8b4SAlexey Kardashevskiy } else { 1513378bc217SDavid Gibson if (spapr->htab_first_pass) { 1514378bc217SDavid Gibson htab_save_first_pass(f, spapr, -1); 1515378bc217SDavid Gibson } 15164be21d56SDavid Gibson htab_save_later_pass(f, spapr, -1); 1517e68cb8b4SAlexey Kardashevskiy } 15184be21d56SDavid Gibson 15194be21d56SDavid Gibson /* End marker */ 15204be21d56SDavid Gibson qemu_put_be32(f, 0); 15214be21d56SDavid Gibson qemu_put_be16(f, 0); 15224be21d56SDavid Gibson qemu_put_be16(f, 0); 15234be21d56SDavid Gibson 15244be21d56SDavid Gibson return 0; 15254be21d56SDavid Gibson } 15264be21d56SDavid Gibson 15274be21d56SDavid Gibson static int htab_load(QEMUFile *f, void *opaque, int version_id) 15284be21d56SDavid Gibson { 152928e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 15304be21d56SDavid Gibson uint32_t section_hdr; 1531e68cb8b4SAlexey Kardashevskiy int fd = -1; 15324be21d56SDavid Gibson 15334be21d56SDavid Gibson if (version_id < 1 || version_id > 1) { 153498a5d100SDavid Gibson error_report("htab_load() bad version"); 15354be21d56SDavid Gibson return -EINVAL; 15364be21d56SDavid Gibson } 15374be21d56SDavid Gibson 15384be21d56SDavid Gibson section_hdr = qemu_get_be32(f); 15394be21d56SDavid Gibson 15404be21d56SDavid Gibson if (section_hdr) { 15419897e462SGreg Kurz Error *local_err = NULL; 1542c5f54f3eSDavid Gibson 1543c5f54f3eSDavid Gibson /* First section gives the htab size */ 1544c5f54f3eSDavid Gibson spapr_reallocate_hpt(spapr, section_hdr, &local_err); 1545c5f54f3eSDavid Gibson if (local_err) { 1546c5f54f3eSDavid Gibson error_report_err(local_err); 15474be21d56SDavid Gibson return -EINVAL; 15484be21d56SDavid Gibson } 15494be21d56SDavid Gibson return 0; 15504be21d56SDavid Gibson } 15514be21d56SDavid Gibson 1552e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1553e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 1554e68cb8b4SAlexey Kardashevskiy 1555e68cb8b4SAlexey Kardashevskiy fd = kvmppc_get_htab_fd(true); 1556e68cb8b4SAlexey Kardashevskiy if (fd < 0) { 155798a5d100SDavid Gibson error_report("Unable to open fd to restore KVM hash table: %s", 1558e68cb8b4SAlexey Kardashevskiy strerror(errno)); 1559e68cb8b4SAlexey Kardashevskiy } 1560e68cb8b4SAlexey Kardashevskiy } 1561e68cb8b4SAlexey Kardashevskiy 15624be21d56SDavid Gibson while (true) { 15634be21d56SDavid Gibson uint32_t index; 15644be21d56SDavid Gibson uint16_t n_valid, n_invalid; 15654be21d56SDavid Gibson 15664be21d56SDavid Gibson index = qemu_get_be32(f); 15674be21d56SDavid Gibson n_valid = qemu_get_be16(f); 15684be21d56SDavid Gibson n_invalid = qemu_get_be16(f); 15694be21d56SDavid Gibson 15704be21d56SDavid Gibson if ((index == 0) && (n_valid == 0) && (n_invalid == 0)) { 15714be21d56SDavid Gibson /* End of Stream */ 15724be21d56SDavid Gibson break; 15734be21d56SDavid Gibson } 15744be21d56SDavid Gibson 1575e68cb8b4SAlexey Kardashevskiy if ((index + n_valid + n_invalid) > 15764be21d56SDavid Gibson (HTAB_SIZE(spapr) / HASH_PTE_SIZE_64)) { 15774be21d56SDavid Gibson /* Bad index in stream */ 157898a5d100SDavid Gibson error_report( 157998a5d100SDavid Gibson "htab_load() bad index %d (%hd+%hd entries) in htab stream (htab_shift=%d)", 158098a5d100SDavid Gibson index, n_valid, n_invalid, spapr->htab_shift); 15814be21d56SDavid Gibson return -EINVAL; 15824be21d56SDavid Gibson } 15834be21d56SDavid Gibson 1584e68cb8b4SAlexey Kardashevskiy if (spapr->htab) { 15854be21d56SDavid Gibson if (n_valid) { 15864be21d56SDavid Gibson qemu_get_buffer(f, HPTE(spapr->htab, index), 15874be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_valid); 15884be21d56SDavid Gibson } 15894be21d56SDavid Gibson if (n_invalid) { 15904be21d56SDavid Gibson memset(HPTE(spapr->htab, index + n_valid), 0, 15914be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_invalid); 15924be21d56SDavid Gibson } 1593e68cb8b4SAlexey Kardashevskiy } else { 1594e68cb8b4SAlexey Kardashevskiy int rc; 1595e68cb8b4SAlexey Kardashevskiy 1596e68cb8b4SAlexey Kardashevskiy assert(fd >= 0); 1597e68cb8b4SAlexey Kardashevskiy 1598e68cb8b4SAlexey Kardashevskiy rc = kvmppc_load_htab_chunk(f, fd, index, n_valid, n_invalid); 1599e68cb8b4SAlexey Kardashevskiy if (rc < 0) { 1600e68cb8b4SAlexey Kardashevskiy return rc; 1601e68cb8b4SAlexey Kardashevskiy } 1602e68cb8b4SAlexey Kardashevskiy } 1603e68cb8b4SAlexey Kardashevskiy } 1604e68cb8b4SAlexey Kardashevskiy 1605e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1606e68cb8b4SAlexey Kardashevskiy assert(fd >= 0); 1607e68cb8b4SAlexey Kardashevskiy close(fd); 16084be21d56SDavid Gibson } 16094be21d56SDavid Gibson 16104be21d56SDavid Gibson return 0; 16114be21d56SDavid Gibson } 16124be21d56SDavid Gibson 16134be21d56SDavid Gibson static SaveVMHandlers savevm_htab_handlers = { 16144be21d56SDavid Gibson .save_live_setup = htab_save_setup, 16154be21d56SDavid Gibson .save_live_iterate = htab_save_iterate, 1616a3e06c3dSDr. David Alan Gilbert .save_live_complete_precopy = htab_save_complete, 16174be21d56SDavid Gibson .load_state = htab_load, 16184be21d56SDavid Gibson }; 16194be21d56SDavid Gibson 16205b2128d2SAlexander Graf static void spapr_boot_set(void *opaque, const char *boot_device, 16215b2128d2SAlexander Graf Error **errp) 16225b2128d2SAlexander Graf { 16235b2128d2SAlexander Graf MachineState *machine = MACHINE(qdev_get_machine()); 16245b2128d2SAlexander Graf machine->boot_order = g_strdup(boot_device); 16255b2128d2SAlexander Graf } 16265b2128d2SAlexander Graf 1627224245bfSDavid Gibson /* 1628224245bfSDavid Gibson * Reset routine for LMB DR devices. 1629224245bfSDavid Gibson * 1630224245bfSDavid Gibson * Unlike PCI DR devices, LMB DR devices explicitly register this reset 1631224245bfSDavid Gibson * routine. Reset for PCI DR devices will be handled by PHB reset routine 1632224245bfSDavid Gibson * when it walks all its children devices. LMB devices reset occurs 1633224245bfSDavid Gibson * as part of spapr_ppc_reset(). 1634224245bfSDavid Gibson */ 1635224245bfSDavid Gibson static void spapr_drc_reset(void *opaque) 1636224245bfSDavid Gibson { 1637224245bfSDavid Gibson sPAPRDRConnector *drc = opaque; 1638224245bfSDavid Gibson DeviceState *d = DEVICE(drc); 1639224245bfSDavid Gibson 1640224245bfSDavid Gibson if (d) { 1641224245bfSDavid Gibson device_reset(d); 1642224245bfSDavid Gibson } 1643224245bfSDavid Gibson } 1644224245bfSDavid Gibson 1645224245bfSDavid Gibson static void spapr_create_lmb_dr_connectors(sPAPRMachineState *spapr) 1646224245bfSDavid Gibson { 1647224245bfSDavid Gibson MachineState *machine = MACHINE(spapr); 1648224245bfSDavid Gibson uint64_t lmb_size = SPAPR_MEMORY_BLOCK_SIZE; 1649e8f986fcSBharata B Rao uint32_t nr_lmbs = (machine->maxram_size - machine->ram_size)/lmb_size; 1650224245bfSDavid Gibson int i; 1651224245bfSDavid Gibson 1652224245bfSDavid Gibson for (i = 0; i < nr_lmbs; i++) { 1653224245bfSDavid Gibson sPAPRDRConnector *drc; 1654224245bfSDavid Gibson uint64_t addr; 1655224245bfSDavid Gibson 1656e8f986fcSBharata B Rao addr = i * lmb_size + spapr->hotplug_memory.base; 1657224245bfSDavid Gibson drc = spapr_dr_connector_new(OBJECT(spapr), SPAPR_DR_CONNECTOR_TYPE_LMB, 1658224245bfSDavid Gibson addr/lmb_size); 1659224245bfSDavid Gibson qemu_register_reset(spapr_drc_reset, drc); 1660224245bfSDavid Gibson } 1661224245bfSDavid Gibson } 1662224245bfSDavid Gibson 1663224245bfSDavid Gibson /* 1664224245bfSDavid Gibson * If RAM size, maxmem size and individual node mem sizes aren't aligned 1665224245bfSDavid Gibson * to SPAPR_MEMORY_BLOCK_SIZE(256MB), then refuse to start the guest 1666224245bfSDavid Gibson * since we can't support such unaligned sizes with DRCONF_MEMORY. 1667224245bfSDavid Gibson */ 16687c150d6fSDavid Gibson static void spapr_validate_node_memory(MachineState *machine, Error **errp) 1669224245bfSDavid Gibson { 1670224245bfSDavid Gibson int i; 1671224245bfSDavid Gibson 16727c150d6fSDavid Gibson if (machine->ram_size % SPAPR_MEMORY_BLOCK_SIZE) { 16737c150d6fSDavid Gibson error_setg(errp, "Memory size 0x" RAM_ADDR_FMT 16747c150d6fSDavid Gibson " is not aligned to %llu MiB", 16757c150d6fSDavid Gibson machine->ram_size, 1676224245bfSDavid Gibson SPAPR_MEMORY_BLOCK_SIZE / M_BYTE); 16777c150d6fSDavid Gibson return; 16787c150d6fSDavid Gibson } 16797c150d6fSDavid Gibson 16807c150d6fSDavid Gibson if (machine->maxram_size % SPAPR_MEMORY_BLOCK_SIZE) { 16817c150d6fSDavid Gibson error_setg(errp, "Maximum memory size 0x" RAM_ADDR_FMT 16827c150d6fSDavid Gibson " is not aligned to %llu MiB", 16837c150d6fSDavid Gibson machine->ram_size, 16847c150d6fSDavid Gibson SPAPR_MEMORY_BLOCK_SIZE / M_BYTE); 16857c150d6fSDavid Gibson return; 1686224245bfSDavid Gibson } 1687224245bfSDavid Gibson 1688224245bfSDavid Gibson for (i = 0; i < nb_numa_nodes; i++) { 1689224245bfSDavid Gibson if (numa_info[i].node_mem % SPAPR_MEMORY_BLOCK_SIZE) { 16907c150d6fSDavid Gibson error_setg(errp, 16917c150d6fSDavid Gibson "Node %d memory size 0x%" PRIx64 16927c150d6fSDavid Gibson " is not aligned to %llu MiB", 16937c150d6fSDavid Gibson i, numa_info[i].node_mem, 1694224245bfSDavid Gibson SPAPR_MEMORY_BLOCK_SIZE / M_BYTE); 16957c150d6fSDavid Gibson return; 1696224245bfSDavid Gibson } 1697224245bfSDavid Gibson } 1698224245bfSDavid Gibson } 1699224245bfSDavid Gibson 170053018216SPaolo Bonzini /* pSeries LPAR / sPAPR hardware init */ 17013ef96221SMarcel Apfelbaum static void ppc_spapr_init(MachineState *machine) 170253018216SPaolo Bonzini { 170328e02042SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(machine); 1704224245bfSDavid Gibson sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(machine); 17053ef96221SMarcel Apfelbaum const char *kernel_filename = machine->kernel_filename; 17063ef96221SMarcel Apfelbaum const char *kernel_cmdline = machine->kernel_cmdline; 17073ef96221SMarcel Apfelbaum const char *initrd_filename = machine->initrd_filename; 170853018216SPaolo Bonzini PCIHostState *phb; 170953018216SPaolo Bonzini int i; 171053018216SPaolo Bonzini MemoryRegion *sysmem = get_system_memory(); 171153018216SPaolo Bonzini MemoryRegion *ram = g_new(MemoryRegion, 1); 1712658fa66bSAlexey Kardashevskiy MemoryRegion *rma_region; 1713658fa66bSAlexey Kardashevskiy void *rma = NULL; 171453018216SPaolo Bonzini hwaddr rma_alloc_size; 1715b082d65aSAlexey Kardashevskiy hwaddr node0_size = spapr_node0_size(); 171653018216SPaolo Bonzini uint32_t initrd_base = 0; 171753018216SPaolo Bonzini long kernel_size = 0, initrd_size = 0; 1718b7d1f77aSBenjamin Herrenschmidt long load_limit, fw_size; 171916457e7fSBenjamin Herrenschmidt bool kernel_le = false; 172053018216SPaolo Bonzini char *filename; 172194a94e4cSBharata B Rao int smt = kvmppc_smt_threads(); 172294a94e4cSBharata B Rao int spapr_cores = smp_cpus / smp_threads; 172394a94e4cSBharata B Rao int spapr_max_cores = max_cpus / smp_threads; 172494a94e4cSBharata B Rao 172594a94e4cSBharata B Rao if (smc->dr_cpu_enabled) { 172694a94e4cSBharata B Rao if (smp_cpus % smp_threads) { 172794a94e4cSBharata B Rao error_report("smp_cpus (%u) must be multiple of threads (%u)", 172894a94e4cSBharata B Rao smp_cpus, smp_threads); 172994a94e4cSBharata B Rao exit(1); 173094a94e4cSBharata B Rao } 173194a94e4cSBharata B Rao if (max_cpus % smp_threads) { 173294a94e4cSBharata B Rao error_report("max_cpus (%u) must be multiple of threads (%u)", 173394a94e4cSBharata B Rao max_cpus, smp_threads); 173494a94e4cSBharata B Rao exit(1); 173594a94e4cSBharata B Rao } 173694a94e4cSBharata B Rao } 173753018216SPaolo Bonzini 1738226419d6SMichael S. Tsirkin msi_nonbroken = true; 173953018216SPaolo Bonzini 174053018216SPaolo Bonzini QLIST_INIT(&spapr->phbs); 174153018216SPaolo Bonzini 174253018216SPaolo Bonzini cpu_ppc_hypercall = emulate_spapr_hypercall; 174353018216SPaolo Bonzini 174453018216SPaolo Bonzini /* Allocate RMA if necessary */ 1745658fa66bSAlexey Kardashevskiy rma_alloc_size = kvmppc_alloc_rma(&rma); 174653018216SPaolo Bonzini 174753018216SPaolo Bonzini if (rma_alloc_size == -1) { 1748730fce59SThomas Huth error_report("Unable to create RMA"); 174953018216SPaolo Bonzini exit(1); 175053018216SPaolo Bonzini } 175153018216SPaolo Bonzini 1752c4177479SAlexey Kardashevskiy if (rma_alloc_size && (rma_alloc_size < node0_size)) { 175353018216SPaolo Bonzini spapr->rma_size = rma_alloc_size; 175453018216SPaolo Bonzini } else { 1755c4177479SAlexey Kardashevskiy spapr->rma_size = node0_size; 175653018216SPaolo Bonzini 175753018216SPaolo Bonzini /* With KVM, we don't actually know whether KVM supports an 175853018216SPaolo Bonzini * unbounded RMA (PR KVM) or is limited by the hash table size 175953018216SPaolo Bonzini * (HV KVM using VRMA), so we always assume the latter 176053018216SPaolo Bonzini * 176153018216SPaolo Bonzini * In that case, we also limit the initial allocations for RTAS 176253018216SPaolo Bonzini * etc... to 256M since we have no way to know what the VRMA size 176353018216SPaolo Bonzini * is going to be as it depends on the size of the hash table 176453018216SPaolo Bonzini * isn't determined yet. 176553018216SPaolo Bonzini */ 176653018216SPaolo Bonzini if (kvm_enabled()) { 176753018216SPaolo Bonzini spapr->vrma_adjust = 1; 176853018216SPaolo Bonzini spapr->rma_size = MIN(spapr->rma_size, 0x10000000); 176953018216SPaolo Bonzini } 177053018216SPaolo Bonzini } 177153018216SPaolo Bonzini 1772c4177479SAlexey Kardashevskiy if (spapr->rma_size > node0_size) { 1773d54e4d76SDavid Gibson error_report("Numa node 0 has to span the RMA (%#08"HWADDR_PRIx")", 1774c4177479SAlexey Kardashevskiy spapr->rma_size); 1775c4177479SAlexey Kardashevskiy exit(1); 1776c4177479SAlexey Kardashevskiy } 1777c4177479SAlexey Kardashevskiy 1778b7d1f77aSBenjamin Herrenschmidt /* Setup a load limit for the ramdisk leaving room for SLOF and FDT */ 1779b7d1f77aSBenjamin Herrenschmidt load_limit = MIN(spapr->rma_size, RTAS_MAX_ADDR) - FW_OVERHEAD; 178053018216SPaolo Bonzini 17817b565160SDavid Gibson /* Set up Interrupt Controller before we create the VCPUs */ 1782446f16a6SMarcel Apfelbaum spapr->icp = xics_system_init(machine, 178394a94e4cSBharata B Rao DIV_ROUND_UP(max_cpus * smt, smp_threads), 17841e49182dSDavid Gibson XICS_IRQS, &error_fatal); 17857b565160SDavid Gibson 1786224245bfSDavid Gibson if (smc->dr_lmb_enabled) { 17877c150d6fSDavid Gibson spapr_validate_node_memory(machine, &error_fatal); 1788224245bfSDavid Gibson } 1789224245bfSDavid Gibson 179053018216SPaolo Bonzini /* init CPUs */ 179119fb2c36SBharata B Rao if (machine->cpu_model == NULL) { 179219fb2c36SBharata B Rao machine->cpu_model = kvm_enabled() ? "host" : "POWER7"; 179353018216SPaolo Bonzini } 179494a94e4cSBharata B Rao 179594a94e4cSBharata B Rao if (smc->dr_cpu_enabled) { 179694a94e4cSBharata B Rao char *type = spapr_get_cpu_core_type(machine->cpu_model); 179794a94e4cSBharata B Rao 179894a94e4cSBharata B Rao spapr->cores = g_new0(Object *, spapr_max_cores); 1799af81cf32SBharata B Rao for (i = 0; i < spapr_max_cores; i++) { 180094a94e4cSBharata B Rao int core_dt_id = i * smt; 1801af81cf32SBharata B Rao sPAPRDRConnector *drc = 1802af81cf32SBharata B Rao spapr_dr_connector_new(OBJECT(spapr), 1803af81cf32SBharata B Rao SPAPR_DR_CONNECTOR_TYPE_CPU, core_dt_id); 1804af81cf32SBharata B Rao 1805af81cf32SBharata B Rao qemu_register_reset(spapr_drc_reset, drc); 1806af81cf32SBharata B Rao 1807af81cf32SBharata B Rao if (i < spapr_cores) { 1808af81cf32SBharata B Rao char *type = spapr_get_cpu_core_type(machine->cpu_model); 180994a94e4cSBharata B Rao Object *core; 181094a94e4cSBharata B Rao 181194a94e4cSBharata B Rao if (!object_class_by_name(type)) { 181294a94e4cSBharata B Rao error_report("Unable to find sPAPR CPU Core definition"); 181394a94e4cSBharata B Rao exit(1); 181494a94e4cSBharata B Rao } 181594a94e4cSBharata B Rao 181694a94e4cSBharata B Rao core = object_new(type); 181794a94e4cSBharata B Rao object_property_set_int(core, smp_threads, "nr-threads", 181894a94e4cSBharata B Rao &error_fatal); 181994a94e4cSBharata B Rao object_property_set_int(core, core_dt_id, CPU_CORE_PROP_CORE_ID, 182094a94e4cSBharata B Rao &error_fatal); 182194a94e4cSBharata B Rao object_property_set_bool(core, true, "realized", &error_fatal); 182294a94e4cSBharata B Rao } 1823af81cf32SBharata B Rao } 182494a94e4cSBharata B Rao g_free(type); 182594a94e4cSBharata B Rao } else { 182653018216SPaolo Bonzini for (i = 0; i < smp_cpus; i++) { 182794a94e4cSBharata B Rao PowerPCCPU *cpu = cpu_ppc_init(machine->cpu_model); 182853018216SPaolo Bonzini if (cpu == NULL) { 1829569f4967SDavid Gibson error_report("Unable to find PowerPC CPU definition"); 183053018216SPaolo Bonzini exit(1); 183153018216SPaolo Bonzini } 1832569f4967SDavid Gibson spapr_cpu_init(spapr, cpu, &error_fatal); 183353018216SPaolo Bonzini } 183494a94e4cSBharata B Rao } 183553018216SPaolo Bonzini 1836026bfd89SDavid Gibson if (kvm_enabled()) { 1837026bfd89SDavid Gibson /* Enable H_LOGICAL_CI_* so SLOF can talk to in-kernel devices */ 1838026bfd89SDavid Gibson kvmppc_enable_logical_ci_hcalls(); 1839ef9971ddSAlexey Kardashevskiy kvmppc_enable_set_mode_hcall(); 1840026bfd89SDavid Gibson } 1841026bfd89SDavid Gibson 184253018216SPaolo Bonzini /* allocate RAM */ 1843f92f5da1SAlexey Kardashevskiy memory_region_allocate_system_memory(ram, NULL, "ppc_spapr.ram", 1844fb164994SDavid Gibson machine->ram_size); 1845f92f5da1SAlexey Kardashevskiy memory_region_add_subregion(sysmem, 0, ram); 184653018216SPaolo Bonzini 1847658fa66bSAlexey Kardashevskiy if (rma_alloc_size && rma) { 1848658fa66bSAlexey Kardashevskiy rma_region = g_new(MemoryRegion, 1); 1849658fa66bSAlexey Kardashevskiy memory_region_init_ram_ptr(rma_region, NULL, "ppc_spapr.rma", 1850658fa66bSAlexey Kardashevskiy rma_alloc_size, rma); 1851658fa66bSAlexey Kardashevskiy vmstate_register_ram_global(rma_region); 1852658fa66bSAlexey Kardashevskiy memory_region_add_subregion(sysmem, 0, rma_region); 1853658fa66bSAlexey Kardashevskiy } 1854658fa66bSAlexey Kardashevskiy 18554a1c9cf0SBharata B Rao /* initialize hotplug memory address space */ 18564a1c9cf0SBharata B Rao if (machine->ram_size < machine->maxram_size) { 18574a1c9cf0SBharata B Rao ram_addr_t hotplug_mem_size = machine->maxram_size - machine->ram_size; 185871c9a3ddSBharata B Rao /* 185971c9a3ddSBharata B Rao * Limit the number of hotpluggable memory slots to half the number 186071c9a3ddSBharata B Rao * slots that KVM supports, leaving the other half for PCI and other 186171c9a3ddSBharata B Rao * devices. However ensure that number of slots doesn't drop below 32. 186271c9a3ddSBharata B Rao */ 186371c9a3ddSBharata B Rao int max_memslots = kvm_enabled() ? kvm_get_max_memslots() / 2 : 186471c9a3ddSBharata B Rao SPAPR_MAX_RAM_SLOTS; 18654a1c9cf0SBharata B Rao 186671c9a3ddSBharata B Rao if (max_memslots < SPAPR_MAX_RAM_SLOTS) { 186771c9a3ddSBharata B Rao max_memslots = SPAPR_MAX_RAM_SLOTS; 186871c9a3ddSBharata B Rao } 186971c9a3ddSBharata B Rao if (machine->ram_slots > max_memslots) { 1870d54e4d76SDavid Gibson error_report("Specified number of memory slots %" 1871d54e4d76SDavid Gibson PRIu64" exceeds max supported %d", 187271c9a3ddSBharata B Rao machine->ram_slots, max_memslots); 1873d54e4d76SDavid Gibson exit(1); 18744a1c9cf0SBharata B Rao } 18754a1c9cf0SBharata B Rao 18764a1c9cf0SBharata B Rao spapr->hotplug_memory.base = ROUND_UP(machine->ram_size, 18774a1c9cf0SBharata B Rao SPAPR_HOTPLUG_MEM_ALIGN); 18784a1c9cf0SBharata B Rao memory_region_init(&spapr->hotplug_memory.mr, OBJECT(spapr), 18794a1c9cf0SBharata B Rao "hotplug-memory", hotplug_mem_size); 18804a1c9cf0SBharata B Rao memory_region_add_subregion(sysmem, spapr->hotplug_memory.base, 18814a1c9cf0SBharata B Rao &spapr->hotplug_memory.mr); 18824a1c9cf0SBharata B Rao } 18834a1c9cf0SBharata B Rao 1884224245bfSDavid Gibson if (smc->dr_lmb_enabled) { 1885224245bfSDavid Gibson spapr_create_lmb_dr_connectors(spapr); 1886224245bfSDavid Gibson } 1887224245bfSDavid Gibson 188853018216SPaolo Bonzini filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, "spapr-rtas.bin"); 18894c56440dSStefan Weil if (!filename) { 1890730fce59SThomas Huth error_report("Could not find LPAR rtas '%s'", "spapr-rtas.bin"); 18914c56440dSStefan Weil exit(1); 18924c56440dSStefan Weil } 1893b7d1f77aSBenjamin Herrenschmidt spapr->rtas_size = get_image_size(filename); 18948afc22a2SZhou Jie if (spapr->rtas_size < 0) { 18958afc22a2SZhou Jie error_report("Could not get size of LPAR rtas '%s'", filename); 18968afc22a2SZhou Jie exit(1); 18978afc22a2SZhou Jie } 1898b7d1f77aSBenjamin Herrenschmidt spapr->rtas_blob = g_malloc(spapr->rtas_size); 1899b7d1f77aSBenjamin Herrenschmidt if (load_image_size(filename, spapr->rtas_blob, spapr->rtas_size) < 0) { 1900730fce59SThomas Huth error_report("Could not load LPAR rtas '%s'", filename); 190153018216SPaolo Bonzini exit(1); 190253018216SPaolo Bonzini } 190353018216SPaolo Bonzini if (spapr->rtas_size > RTAS_MAX_SIZE) { 1904730fce59SThomas Huth error_report("RTAS too big ! 0x%zx bytes (max is 0x%x)", 19052f285bddSPeter Maydell (size_t)spapr->rtas_size, RTAS_MAX_SIZE); 190653018216SPaolo Bonzini exit(1); 190753018216SPaolo Bonzini } 190853018216SPaolo Bonzini g_free(filename); 190953018216SPaolo Bonzini 191053018216SPaolo Bonzini /* Set up EPOW events infrastructure */ 191153018216SPaolo Bonzini spapr_events_init(spapr); 191253018216SPaolo Bonzini 191312f42174SDavid Gibson /* Set up the RTC RTAS interfaces */ 191428df36a1SDavid Gibson spapr_rtc_create(spapr); 191512f42174SDavid Gibson 191653018216SPaolo Bonzini /* Set up VIO bus */ 191753018216SPaolo Bonzini spapr->vio_bus = spapr_vio_bus_init(); 191853018216SPaolo Bonzini 191953018216SPaolo Bonzini for (i = 0; i < MAX_SERIAL_PORTS; i++) { 192053018216SPaolo Bonzini if (serial_hds[i]) { 192153018216SPaolo Bonzini spapr_vty_create(spapr->vio_bus, serial_hds[i]); 192253018216SPaolo Bonzini } 192353018216SPaolo Bonzini } 192453018216SPaolo Bonzini 192553018216SPaolo Bonzini /* We always have at least the nvram device on VIO */ 192653018216SPaolo Bonzini spapr_create_nvram(spapr); 192753018216SPaolo Bonzini 192853018216SPaolo Bonzini /* Set up PCI */ 192953018216SPaolo Bonzini spapr_pci_rtas_init(); 193053018216SPaolo Bonzini 193189dfd6e1SDavid Gibson phb = spapr_create_phb(spapr, 0); 193253018216SPaolo Bonzini 193353018216SPaolo Bonzini for (i = 0; i < nb_nics; i++) { 193453018216SPaolo Bonzini NICInfo *nd = &nd_table[i]; 193553018216SPaolo Bonzini 193653018216SPaolo Bonzini if (!nd->model) { 193753018216SPaolo Bonzini nd->model = g_strdup("ibmveth"); 193853018216SPaolo Bonzini } 193953018216SPaolo Bonzini 194053018216SPaolo Bonzini if (strcmp(nd->model, "ibmveth") == 0) { 194153018216SPaolo Bonzini spapr_vlan_create(spapr->vio_bus, nd); 194253018216SPaolo Bonzini } else { 194329b358f9SDavid Gibson pci_nic_init_nofail(&nd_table[i], phb->bus, nd->model, NULL); 194453018216SPaolo Bonzini } 194553018216SPaolo Bonzini } 194653018216SPaolo Bonzini 194753018216SPaolo Bonzini for (i = 0; i <= drive_get_max_bus(IF_SCSI); i++) { 194853018216SPaolo Bonzini spapr_vscsi_create(spapr->vio_bus); 194953018216SPaolo Bonzini } 195053018216SPaolo Bonzini 195153018216SPaolo Bonzini /* Graphics */ 195214c6a894SDavid Gibson if (spapr_vga_init(phb->bus, &error_fatal)) { 195353018216SPaolo Bonzini spapr->has_graphics = true; 1954c6e76503SPaolo Bonzini machine->usb |= defaults_enabled() && !machine->usb_disabled; 195553018216SPaolo Bonzini } 195653018216SPaolo Bonzini 19574ee9ced9SMarcel Apfelbaum if (machine->usb) { 195857040d45SThomas Huth if (smc->use_ohci_by_default) { 195953018216SPaolo Bonzini pci_create_simple(phb->bus, -1, "pci-ohci"); 196057040d45SThomas Huth } else { 196157040d45SThomas Huth pci_create_simple(phb->bus, -1, "nec-usb-xhci"); 196257040d45SThomas Huth } 1963c86580b8SMarkus Armbruster 196453018216SPaolo Bonzini if (spapr->has_graphics) { 1965c86580b8SMarkus Armbruster USBBus *usb_bus = usb_bus_find(-1); 1966c86580b8SMarkus Armbruster 1967c86580b8SMarkus Armbruster usb_create_simple(usb_bus, "usb-kbd"); 1968c86580b8SMarkus Armbruster usb_create_simple(usb_bus, "usb-mouse"); 196953018216SPaolo Bonzini } 197053018216SPaolo Bonzini } 197153018216SPaolo Bonzini 197253018216SPaolo Bonzini if (spapr->rma_size < (MIN_RMA_SLOF << 20)) { 1973d54e4d76SDavid Gibson error_report( 1974d54e4d76SDavid Gibson "pSeries SLOF firmware requires >= %ldM guest RMA (Real Mode Area memory)", 1975d54e4d76SDavid Gibson MIN_RMA_SLOF); 197653018216SPaolo Bonzini exit(1); 197753018216SPaolo Bonzini } 197853018216SPaolo Bonzini 197953018216SPaolo Bonzini if (kernel_filename) { 198053018216SPaolo Bonzini uint64_t lowaddr = 0; 198153018216SPaolo Bonzini 198253018216SPaolo Bonzini kernel_size = load_elf(kernel_filename, translate_kernel_address, NULL, 19837ef295eaSPeter Crosthwaite NULL, &lowaddr, NULL, 1, PPC_ELF_MACHINE, 19847ef295eaSPeter Crosthwaite 0, 0); 19853b66da82SAlexey Kardashevskiy if (kernel_size == ELF_LOAD_WRONG_ENDIAN) { 198616457e7fSBenjamin Herrenschmidt kernel_size = load_elf(kernel_filename, 198716457e7fSBenjamin Herrenschmidt translate_kernel_address, NULL, 19887ef295eaSPeter Crosthwaite NULL, &lowaddr, NULL, 0, PPC_ELF_MACHINE, 19897ef295eaSPeter Crosthwaite 0, 0); 199016457e7fSBenjamin Herrenschmidt kernel_le = kernel_size > 0; 199116457e7fSBenjamin Herrenschmidt } 199216457e7fSBenjamin Herrenschmidt if (kernel_size < 0) { 1993d54e4d76SDavid Gibson error_report("error loading %s: %s", 19943b66da82SAlexey Kardashevskiy kernel_filename, load_elf_strerror(kernel_size)); 199553018216SPaolo Bonzini exit(1); 199653018216SPaolo Bonzini } 199753018216SPaolo Bonzini 199853018216SPaolo Bonzini /* load initrd */ 199953018216SPaolo Bonzini if (initrd_filename) { 200053018216SPaolo Bonzini /* Try to locate the initrd in the gap between the kernel 200153018216SPaolo Bonzini * and the firmware. Add a bit of space just in case 200253018216SPaolo Bonzini */ 200353018216SPaolo Bonzini initrd_base = (KERNEL_LOAD_ADDR + kernel_size + 0x1ffff) & ~0xffff; 200453018216SPaolo Bonzini initrd_size = load_image_targphys(initrd_filename, initrd_base, 200553018216SPaolo Bonzini load_limit - initrd_base); 200653018216SPaolo Bonzini if (initrd_size < 0) { 2007d54e4d76SDavid Gibson error_report("could not load initial ram disk '%s'", 200853018216SPaolo Bonzini initrd_filename); 200953018216SPaolo Bonzini exit(1); 201053018216SPaolo Bonzini } 201153018216SPaolo Bonzini } else { 201253018216SPaolo Bonzini initrd_base = 0; 201353018216SPaolo Bonzini initrd_size = 0; 201453018216SPaolo Bonzini } 201553018216SPaolo Bonzini } 201653018216SPaolo Bonzini 20178e7ea787SAndreas Färber if (bios_name == NULL) { 20188e7ea787SAndreas Färber bios_name = FW_FILE_NAME; 20198e7ea787SAndreas Färber } 20208e7ea787SAndreas Färber filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name); 20214c56440dSStefan Weil if (!filename) { 202268fea5a0SThomas Huth error_report("Could not find LPAR firmware '%s'", bios_name); 20234c56440dSStefan Weil exit(1); 20244c56440dSStefan Weil } 202553018216SPaolo Bonzini fw_size = load_image_targphys(filename, 0, FW_MAX_SIZE); 202668fea5a0SThomas Huth if (fw_size <= 0) { 202768fea5a0SThomas Huth error_report("Could not load LPAR firmware '%s'", filename); 202853018216SPaolo Bonzini exit(1); 202953018216SPaolo Bonzini } 203053018216SPaolo Bonzini g_free(filename); 203153018216SPaolo Bonzini 203228e02042SDavid Gibson /* FIXME: Should register things through the MachineState's qdev 203328e02042SDavid Gibson * interface, this is a legacy from the sPAPREnvironment structure 203428e02042SDavid Gibson * which predated MachineState but had a similar function */ 20354be21d56SDavid Gibson vmstate_register(NULL, 0, &vmstate_spapr, spapr); 20364be21d56SDavid Gibson register_savevm_live(NULL, "spapr/htab", -1, 1, 20374be21d56SDavid Gibson &savevm_htab_handlers, spapr); 20384be21d56SDavid Gibson 203953018216SPaolo Bonzini /* Prepare the device tree */ 20403bbf37f2SAndreas Färber spapr->fdt_skel = spapr_create_fdt_skel(initrd_base, initrd_size, 204116457e7fSBenjamin Herrenschmidt kernel_size, kernel_le, 204231fe14d1SNathan Fontenot kernel_cmdline, 204331fe14d1SNathan Fontenot spapr->check_exception_irq); 204453018216SPaolo Bonzini assert(spapr->fdt_skel != NULL); 20455b2128d2SAlexander Graf 204646503c2bSMichael Roth /* used by RTAS */ 204746503c2bSMichael Roth QTAILQ_INIT(&spapr->ccs_list); 204846503c2bSMichael Roth qemu_register_reset(spapr_ccs_reset_hook, spapr); 204946503c2bSMichael Roth 20505b2128d2SAlexander Graf qemu_register_boot_set(spapr_boot_set, spapr); 205153018216SPaolo Bonzini } 205253018216SPaolo Bonzini 2053135a129aSAneesh Kumar K.V static int spapr_kvm_type(const char *vm_type) 2054135a129aSAneesh Kumar K.V { 2055135a129aSAneesh Kumar K.V if (!vm_type) { 2056135a129aSAneesh Kumar K.V return 0; 2057135a129aSAneesh Kumar K.V } 2058135a129aSAneesh Kumar K.V 2059135a129aSAneesh Kumar K.V if (!strcmp(vm_type, "HV")) { 2060135a129aSAneesh Kumar K.V return 1; 2061135a129aSAneesh Kumar K.V } 2062135a129aSAneesh Kumar K.V 2063135a129aSAneesh Kumar K.V if (!strcmp(vm_type, "PR")) { 2064135a129aSAneesh Kumar K.V return 2; 2065135a129aSAneesh Kumar K.V } 2066135a129aSAneesh Kumar K.V 2067135a129aSAneesh Kumar K.V error_report("Unknown kvm-type specified '%s'", vm_type); 2068135a129aSAneesh Kumar K.V exit(1); 2069135a129aSAneesh Kumar K.V } 2070135a129aSAneesh Kumar K.V 207171461b0fSAlexey Kardashevskiy /* 2072627b84f4SGonglei * Implementation of an interface to adjust firmware path 207371461b0fSAlexey Kardashevskiy * for the bootindex property handling. 207471461b0fSAlexey Kardashevskiy */ 207571461b0fSAlexey Kardashevskiy static char *spapr_get_fw_dev_path(FWPathProvider *p, BusState *bus, 207671461b0fSAlexey Kardashevskiy DeviceState *dev) 207771461b0fSAlexey Kardashevskiy { 207871461b0fSAlexey Kardashevskiy #define CAST(type, obj, name) \ 207971461b0fSAlexey Kardashevskiy ((type *)object_dynamic_cast(OBJECT(obj), (name))) 208071461b0fSAlexey Kardashevskiy SCSIDevice *d = CAST(SCSIDevice, dev, TYPE_SCSI_DEVICE); 208171461b0fSAlexey Kardashevskiy sPAPRPHBState *phb = CAST(sPAPRPHBState, dev, TYPE_SPAPR_PCI_HOST_BRIDGE); 208271461b0fSAlexey Kardashevskiy 208371461b0fSAlexey Kardashevskiy if (d) { 208471461b0fSAlexey Kardashevskiy void *spapr = CAST(void, bus->parent, "spapr-vscsi"); 208571461b0fSAlexey Kardashevskiy VirtIOSCSI *virtio = CAST(VirtIOSCSI, bus->parent, TYPE_VIRTIO_SCSI); 208671461b0fSAlexey Kardashevskiy USBDevice *usb = CAST(USBDevice, bus->parent, TYPE_USB_DEVICE); 208771461b0fSAlexey Kardashevskiy 208871461b0fSAlexey Kardashevskiy if (spapr) { 208971461b0fSAlexey Kardashevskiy /* 209071461b0fSAlexey Kardashevskiy * Replace "channel@0/disk@0,0" with "disk@8000000000000000": 209171461b0fSAlexey Kardashevskiy * We use SRP luns of the form 8000 | (bus << 8) | (id << 5) | lun 209271461b0fSAlexey Kardashevskiy * in the top 16 bits of the 64-bit LUN 209371461b0fSAlexey Kardashevskiy */ 209471461b0fSAlexey Kardashevskiy unsigned id = 0x8000 | (d->id << 8) | d->lun; 209571461b0fSAlexey Kardashevskiy return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev), 209671461b0fSAlexey Kardashevskiy (uint64_t)id << 48); 209771461b0fSAlexey Kardashevskiy } else if (virtio) { 209871461b0fSAlexey Kardashevskiy /* 209971461b0fSAlexey Kardashevskiy * We use SRP luns of the form 01000000 | (target << 8) | lun 210071461b0fSAlexey Kardashevskiy * in the top 32 bits of the 64-bit LUN 210171461b0fSAlexey Kardashevskiy * Note: the quote above is from SLOF and it is wrong, 210271461b0fSAlexey Kardashevskiy * the actual binding is: 210371461b0fSAlexey Kardashevskiy * swap 0100 or 10 << or 20 << ( target lun-id -- srplun ) 210471461b0fSAlexey Kardashevskiy */ 210571461b0fSAlexey Kardashevskiy unsigned id = 0x1000000 | (d->id << 16) | d->lun; 210671461b0fSAlexey Kardashevskiy return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev), 210771461b0fSAlexey Kardashevskiy (uint64_t)id << 32); 210871461b0fSAlexey Kardashevskiy } else if (usb) { 210971461b0fSAlexey Kardashevskiy /* 211071461b0fSAlexey Kardashevskiy * We use SRP luns of the form 01000000 | (usb-port << 16) | lun 211171461b0fSAlexey Kardashevskiy * in the top 32 bits of the 64-bit LUN 211271461b0fSAlexey Kardashevskiy */ 211371461b0fSAlexey Kardashevskiy unsigned usb_port = atoi(usb->port->path); 211471461b0fSAlexey Kardashevskiy unsigned id = 0x1000000 | (usb_port << 16) | d->lun; 211571461b0fSAlexey Kardashevskiy return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev), 211671461b0fSAlexey Kardashevskiy (uint64_t)id << 32); 211771461b0fSAlexey Kardashevskiy } 211871461b0fSAlexey Kardashevskiy } 211971461b0fSAlexey Kardashevskiy 212071461b0fSAlexey Kardashevskiy if (phb) { 212171461b0fSAlexey Kardashevskiy /* Replace "pci" with "pci@800000020000000" */ 212271461b0fSAlexey Kardashevskiy return g_strdup_printf("pci@%"PRIX64, phb->buid); 212371461b0fSAlexey Kardashevskiy } 212471461b0fSAlexey Kardashevskiy 212571461b0fSAlexey Kardashevskiy return NULL; 212671461b0fSAlexey Kardashevskiy } 212771461b0fSAlexey Kardashevskiy 212823825581SEduardo Habkost static char *spapr_get_kvm_type(Object *obj, Error **errp) 212923825581SEduardo Habkost { 213028e02042SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 213123825581SEduardo Habkost 213228e02042SDavid Gibson return g_strdup(spapr->kvm_type); 213323825581SEduardo Habkost } 213423825581SEduardo Habkost 213523825581SEduardo Habkost static void spapr_set_kvm_type(Object *obj, const char *value, Error **errp) 213623825581SEduardo Habkost { 213728e02042SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 213823825581SEduardo Habkost 213928e02042SDavid Gibson g_free(spapr->kvm_type); 214028e02042SDavid Gibson spapr->kvm_type = g_strdup(value); 214123825581SEduardo Habkost } 214223825581SEduardo Habkost 214323825581SEduardo Habkost static void spapr_machine_initfn(Object *obj) 214423825581SEduardo Habkost { 2145715c5407SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 2146715c5407SDavid Gibson 2147715c5407SDavid Gibson spapr->htab_fd = -1; 214823825581SEduardo Habkost object_property_add_str(obj, "kvm-type", 214923825581SEduardo Habkost spapr_get_kvm_type, spapr_set_kvm_type, NULL); 215049d2e648SMarcel Apfelbaum object_property_set_description(obj, "kvm-type", 215149d2e648SMarcel Apfelbaum "Specifies the KVM virtualization mode (HV, PR)", 215249d2e648SMarcel Apfelbaum NULL); 215323825581SEduardo Habkost } 215423825581SEduardo Habkost 215587bbdd9cSDavid Gibson static void spapr_machine_finalizefn(Object *obj) 215687bbdd9cSDavid Gibson { 215787bbdd9cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 215887bbdd9cSDavid Gibson 215987bbdd9cSDavid Gibson g_free(spapr->kvm_type); 216087bbdd9cSDavid Gibson } 216187bbdd9cSDavid Gibson 216234316482SAlexey Kardashevskiy static void ppc_cpu_do_nmi_on_cpu(void *arg) 216334316482SAlexey Kardashevskiy { 216434316482SAlexey Kardashevskiy CPUState *cs = arg; 216534316482SAlexey Kardashevskiy 216634316482SAlexey Kardashevskiy cpu_synchronize_state(cs); 216734316482SAlexey Kardashevskiy ppc_cpu_do_system_reset(cs); 216834316482SAlexey Kardashevskiy } 216934316482SAlexey Kardashevskiy 217034316482SAlexey Kardashevskiy static void spapr_nmi(NMIState *n, int cpu_index, Error **errp) 217134316482SAlexey Kardashevskiy { 217234316482SAlexey Kardashevskiy CPUState *cs; 217334316482SAlexey Kardashevskiy 217434316482SAlexey Kardashevskiy CPU_FOREACH(cs) { 217534316482SAlexey Kardashevskiy async_run_on_cpu(cs, ppc_cpu_do_nmi_on_cpu, cs); 217634316482SAlexey Kardashevskiy } 217734316482SAlexey Kardashevskiy } 217834316482SAlexey Kardashevskiy 2179c20d332aSBharata B Rao static void spapr_add_lmbs(DeviceState *dev, uint64_t addr, uint64_t size, 2180c20d332aSBharata B Rao uint32_t node, Error **errp) 2181c20d332aSBharata B Rao { 2182c20d332aSBharata B Rao sPAPRDRConnector *drc; 2183c20d332aSBharata B Rao sPAPRDRConnectorClass *drck; 2184c20d332aSBharata B Rao uint32_t nr_lmbs = size/SPAPR_MEMORY_BLOCK_SIZE; 2185c20d332aSBharata B Rao int i, fdt_offset, fdt_size; 2186c20d332aSBharata B Rao void *fdt; 2187c20d332aSBharata B Rao 2188c20d332aSBharata B Rao for (i = 0; i < nr_lmbs; i++) { 2189c20d332aSBharata B Rao drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_LMB, 2190c20d332aSBharata B Rao addr/SPAPR_MEMORY_BLOCK_SIZE); 2191c20d332aSBharata B Rao g_assert(drc); 2192c20d332aSBharata B Rao 2193c20d332aSBharata B Rao fdt = create_device_tree(&fdt_size); 2194c20d332aSBharata B Rao fdt_offset = spapr_populate_memory_node(fdt, node, addr, 2195c20d332aSBharata B Rao SPAPR_MEMORY_BLOCK_SIZE); 2196c20d332aSBharata B Rao 2197c20d332aSBharata B Rao drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 2198c20d332aSBharata B Rao drck->attach(drc, dev, fdt, fdt_offset, !dev->hotplugged, errp); 2199c20d332aSBharata B Rao addr += SPAPR_MEMORY_BLOCK_SIZE; 2200c20d332aSBharata B Rao } 22015dd5238cSJianjun Duan /* send hotplug notification to the 22025dd5238cSJianjun Duan * guest only in case of hotplugged memory 22035dd5238cSJianjun Duan */ 22045dd5238cSJianjun Duan if (dev->hotplugged) { 22050a417869SBharata B Rao spapr_hotplug_req_add_by_count(SPAPR_DR_CONNECTOR_TYPE_LMB, nr_lmbs); 2206c20d332aSBharata B Rao } 22075dd5238cSJianjun Duan } 2208c20d332aSBharata B Rao 2209c20d332aSBharata B Rao static void spapr_memory_plug(HotplugHandler *hotplug_dev, DeviceState *dev, 2210c20d332aSBharata B Rao uint32_t node, Error **errp) 2211c20d332aSBharata B Rao { 2212c20d332aSBharata B Rao Error *local_err = NULL; 2213c20d332aSBharata B Rao sPAPRMachineState *ms = SPAPR_MACHINE(hotplug_dev); 2214c20d332aSBharata B Rao PCDIMMDevice *dimm = PC_DIMM(dev); 2215c20d332aSBharata B Rao PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); 2216c20d332aSBharata B Rao MemoryRegion *mr = ddc->get_memory_region(dimm); 2217c20d332aSBharata B Rao uint64_t align = memory_region_get_alignment(mr); 2218c20d332aSBharata B Rao uint64_t size = memory_region_size(mr); 2219c20d332aSBharata B Rao uint64_t addr; 2220c20d332aSBharata B Rao 2221c20d332aSBharata B Rao if (size % SPAPR_MEMORY_BLOCK_SIZE) { 2222c20d332aSBharata B Rao error_setg(&local_err, "Hotplugged memory size must be a multiple of " 2223c20d332aSBharata B Rao "%lld MB", SPAPR_MEMORY_BLOCK_SIZE/M_BYTE); 2224c20d332aSBharata B Rao goto out; 2225c20d332aSBharata B Rao } 2226c20d332aSBharata B Rao 2227d6a9b0b8SMichael S. Tsirkin pc_dimm_memory_plug(dev, &ms->hotplug_memory, mr, align, &local_err); 2228c20d332aSBharata B Rao if (local_err) { 2229c20d332aSBharata B Rao goto out; 2230c20d332aSBharata B Rao } 2231c20d332aSBharata B Rao 2232c20d332aSBharata B Rao addr = object_property_get_int(OBJECT(dimm), PC_DIMM_ADDR_PROP, &local_err); 2233c20d332aSBharata B Rao if (local_err) { 2234c20d332aSBharata B Rao pc_dimm_memory_unplug(dev, &ms->hotplug_memory, mr); 2235c20d332aSBharata B Rao goto out; 2236c20d332aSBharata B Rao } 2237c20d332aSBharata B Rao 2238c20d332aSBharata B Rao spapr_add_lmbs(dev, addr, size, node, &error_abort); 2239c20d332aSBharata B Rao 2240c20d332aSBharata B Rao out: 2241c20d332aSBharata B Rao error_propagate(errp, local_err); 2242c20d332aSBharata B Rao } 2243c20d332aSBharata B Rao 2244af81cf32SBharata B Rao void *spapr_populate_hotplug_cpu_dt(CPUState *cs, int *fdt_offset, 2245af81cf32SBharata B Rao sPAPRMachineState *spapr) 2246af81cf32SBharata B Rao { 2247af81cf32SBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(cs); 2248af81cf32SBharata B Rao DeviceClass *dc = DEVICE_GET_CLASS(cs); 2249af81cf32SBharata B Rao int id = ppc_get_vcpu_dt_id(cpu); 2250af81cf32SBharata B Rao void *fdt; 2251af81cf32SBharata B Rao int offset, fdt_size; 2252af81cf32SBharata B Rao char *nodename; 2253af81cf32SBharata B Rao 2254af81cf32SBharata B Rao fdt = create_device_tree(&fdt_size); 2255af81cf32SBharata B Rao nodename = g_strdup_printf("%s@%x", dc->fw_name, id); 2256af81cf32SBharata B Rao offset = fdt_add_subnode(fdt, 0, nodename); 2257af81cf32SBharata B Rao 2258af81cf32SBharata B Rao spapr_populate_cpu_dt(cs, fdt, offset, spapr); 2259af81cf32SBharata B Rao g_free(nodename); 2260af81cf32SBharata B Rao 2261af81cf32SBharata B Rao *fdt_offset = offset; 2262af81cf32SBharata B Rao return fdt; 2263af81cf32SBharata B Rao } 2264af81cf32SBharata B Rao 2265c20d332aSBharata B Rao static void spapr_machine_device_plug(HotplugHandler *hotplug_dev, 2266c20d332aSBharata B Rao DeviceState *dev, Error **errp) 2267c20d332aSBharata B Rao { 2268c20d332aSBharata B Rao sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(qdev_get_machine()); 2269c20d332aSBharata B Rao 2270c20d332aSBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { 2271b556854bSBharata B Rao int node; 2272c20d332aSBharata B Rao 2273c20d332aSBharata B Rao if (!smc->dr_lmb_enabled) { 2274c20d332aSBharata B Rao error_setg(errp, "Memory hotplug not supported for this machine"); 2275c20d332aSBharata B Rao return; 2276c20d332aSBharata B Rao } 2277c20d332aSBharata B Rao node = object_property_get_int(OBJECT(dev), PC_DIMM_NODE_PROP, errp); 2278c20d332aSBharata B Rao if (*errp) { 2279c20d332aSBharata B Rao return; 2280c20d332aSBharata B Rao } 22811a5512bbSGonglei if (node < 0 || node >= MAX_NODES) { 22821a5512bbSGonglei error_setg(errp, "Invaild node %d", node); 22831a5512bbSGonglei return; 22841a5512bbSGonglei } 2285c20d332aSBharata B Rao 2286b556854bSBharata B Rao /* 2287b556854bSBharata B Rao * Currently PowerPC kernel doesn't allow hot-adding memory to 2288b556854bSBharata B Rao * memory-less node, but instead will silently add the memory 2289b556854bSBharata B Rao * to the first node that has some memory. This causes two 2290b556854bSBharata B Rao * unexpected behaviours for the user. 2291b556854bSBharata B Rao * 2292b556854bSBharata B Rao * - Memory gets hotplugged to a different node than what the user 2293b556854bSBharata B Rao * specified. 2294b556854bSBharata B Rao * - Since pc-dimm subsystem in QEMU still thinks that memory belongs 2295b556854bSBharata B Rao * to memory-less node, a reboot will set things accordingly 2296b556854bSBharata B Rao * and the previously hotplugged memory now ends in the right node. 2297b556854bSBharata B Rao * This appears as if some memory moved from one node to another. 2298b556854bSBharata B Rao * 2299b556854bSBharata B Rao * So until kernel starts supporting memory hotplug to memory-less 2300b556854bSBharata B Rao * nodes, just prevent such attempts upfront in QEMU. 2301b556854bSBharata B Rao */ 2302b556854bSBharata B Rao if (nb_numa_nodes && !numa_info[node].node_mem) { 2303b556854bSBharata B Rao error_setg(errp, "Can't hotplug memory to memory-less node %d", 2304b556854bSBharata B Rao node); 2305b556854bSBharata B Rao return; 2306b556854bSBharata B Rao } 2307b556854bSBharata B Rao 2308c20d332aSBharata B Rao spapr_memory_plug(hotplug_dev, dev, node, errp); 2309af81cf32SBharata B Rao } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 2310af81cf32SBharata B Rao spapr_core_plug(hotplug_dev, dev, errp); 2311c20d332aSBharata B Rao } 2312c20d332aSBharata B Rao } 2313c20d332aSBharata B Rao 2314c20d332aSBharata B Rao static void spapr_machine_device_unplug(HotplugHandler *hotplug_dev, 2315c20d332aSBharata B Rao DeviceState *dev, Error **errp) 2316c20d332aSBharata B Rao { 23176f4b5c3eSBharata B Rao sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(qdev_get_machine()); 23186f4b5c3eSBharata B Rao 2319c20d332aSBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { 2320c20d332aSBharata B Rao error_setg(errp, "Memory hot unplug not supported by sPAPR"); 23216f4b5c3eSBharata B Rao } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 23226f4b5c3eSBharata B Rao if (!smc->dr_cpu_enabled) { 23236f4b5c3eSBharata B Rao error_setg(errp, "CPU hot unplug not supported on this machine"); 23246f4b5c3eSBharata B Rao return; 23256f4b5c3eSBharata B Rao } 23266f4b5c3eSBharata B Rao spapr_core_unplug(hotplug_dev, dev, errp); 2327c20d332aSBharata B Rao } 2328c20d332aSBharata B Rao } 2329c20d332aSBharata B Rao 233094a94e4cSBharata B Rao static void spapr_machine_device_pre_plug(HotplugHandler *hotplug_dev, 233194a94e4cSBharata B Rao DeviceState *dev, Error **errp) 233294a94e4cSBharata B Rao { 233394a94e4cSBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 233494a94e4cSBharata B Rao spapr_core_pre_plug(hotplug_dev, dev, errp); 233594a94e4cSBharata B Rao } 233694a94e4cSBharata B Rao } 233794a94e4cSBharata B Rao 2338c20d332aSBharata B Rao static HotplugHandler *spapr_get_hotpug_handler(MachineState *machine, 2339c20d332aSBharata B Rao DeviceState *dev) 2340c20d332aSBharata B Rao { 234194a94e4cSBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM) || 234294a94e4cSBharata B Rao object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) { 2343c20d332aSBharata B Rao return HOTPLUG_HANDLER(machine); 2344c20d332aSBharata B Rao } 2345c20d332aSBharata B Rao return NULL; 2346c20d332aSBharata B Rao } 2347c20d332aSBharata B Rao 234820bb648dSDavid Gibson static unsigned spapr_cpu_index_to_socket_id(unsigned cpu_index) 234920bb648dSDavid Gibson { 235020bb648dSDavid Gibson /* Allocate to NUMA nodes on a "socket" basis (not that concept of 235120bb648dSDavid Gibson * socket means much for the paravirtualized PAPR platform) */ 235220bb648dSDavid Gibson return cpu_index / smp_threads / smp_cores; 235320bb648dSDavid Gibson } 235420bb648dSDavid Gibson 23552474bfd4SIgor Mammedov static HotpluggableCPUList *spapr_query_hotpluggable_cpus(MachineState *machine) 23562474bfd4SIgor Mammedov { 23572474bfd4SIgor Mammedov int i; 23582474bfd4SIgor Mammedov HotpluggableCPUList *head = NULL; 23592474bfd4SIgor Mammedov sPAPRMachineState *spapr = SPAPR_MACHINE(machine); 23602474bfd4SIgor Mammedov int spapr_max_cores = max_cpus / smp_threads; 23612474bfd4SIgor Mammedov int smt = kvmppc_smt_threads(); 23622474bfd4SIgor Mammedov 23632474bfd4SIgor Mammedov for (i = 0; i < spapr_max_cores; i++) { 23642474bfd4SIgor Mammedov HotpluggableCPUList *list_item = g_new0(typeof(*list_item), 1); 23652474bfd4SIgor Mammedov HotpluggableCPU *cpu_item = g_new0(typeof(*cpu_item), 1); 23662474bfd4SIgor Mammedov CpuInstanceProperties *cpu_props = g_new0(typeof(*cpu_props), 1); 23672474bfd4SIgor Mammedov 23682474bfd4SIgor Mammedov cpu_item->type = spapr_get_cpu_core_type(machine->cpu_model); 23692474bfd4SIgor Mammedov cpu_item->vcpus_count = smp_threads; 2370*27393c33SPeter Krempa cpu_props->has_core_id = true; 2371*27393c33SPeter Krempa cpu_props->core_id = i * smt; 23722474bfd4SIgor Mammedov /* TODO: add 'has_node/node' here to describe 23732474bfd4SIgor Mammedov to which node core belongs */ 23742474bfd4SIgor Mammedov 23752474bfd4SIgor Mammedov cpu_item->props = cpu_props; 23762474bfd4SIgor Mammedov if (spapr->cores[i]) { 23772474bfd4SIgor Mammedov cpu_item->has_qom_path = true; 23782474bfd4SIgor Mammedov cpu_item->qom_path = object_get_canonical_path(spapr->cores[i]); 23792474bfd4SIgor Mammedov } 23802474bfd4SIgor Mammedov list_item->value = cpu_item; 23812474bfd4SIgor Mammedov list_item->next = head; 23822474bfd4SIgor Mammedov head = list_item; 23832474bfd4SIgor Mammedov } 23842474bfd4SIgor Mammedov return head; 23852474bfd4SIgor Mammedov } 23862474bfd4SIgor Mammedov 238729ee3247SAlexey Kardashevskiy static void spapr_machine_class_init(ObjectClass *oc, void *data) 238853018216SPaolo Bonzini { 238929ee3247SAlexey Kardashevskiy MachineClass *mc = MACHINE_CLASS(oc); 2390224245bfSDavid Gibson sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(oc); 239171461b0fSAlexey Kardashevskiy FWPathProviderClass *fwc = FW_PATH_PROVIDER_CLASS(oc); 239234316482SAlexey Kardashevskiy NMIClass *nc = NMI_CLASS(oc); 2393c20d332aSBharata B Rao HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(oc); 239429ee3247SAlexey Kardashevskiy 23950eb9054cSDavid Gibson mc->desc = "pSeries Logical Partition (PAPR compliant)"; 2396fc9f38c3SDavid Gibson 2397fc9f38c3SDavid Gibson /* 2398fc9f38c3SDavid Gibson * We set up the default / latest behaviour here. The class_init 2399fc9f38c3SDavid Gibson * functions for the specific versioned machine types can override 2400fc9f38c3SDavid Gibson * these details for backwards compatibility 2401fc9f38c3SDavid Gibson */ 2402958db90cSMarcel Apfelbaum mc->init = ppc_spapr_init; 2403958db90cSMarcel Apfelbaum mc->reset = ppc_spapr_reset; 2404958db90cSMarcel Apfelbaum mc->block_default_type = IF_SCSI; 240538b02bd8SAlexey Kardashevskiy mc->max_cpus = MAX_CPUMASK_BITS; 2406958db90cSMarcel Apfelbaum mc->no_parallel = 1; 24075b2128d2SAlexander Graf mc->default_boot_order = ""; 2408a34944feSNikunj A Dadhania mc->default_ram_size = 512 * M_BYTE; 2409958db90cSMarcel Apfelbaum mc->kvm_type = spapr_kvm_type; 24109e3f9733SAlexander Graf mc->has_dynamic_sysbus = true; 2411e4024630SLaurent Vivier mc->pci_allow_0_address = true; 2412c20d332aSBharata B Rao mc->get_hotplug_handler = spapr_get_hotpug_handler; 241394a94e4cSBharata B Rao hc->pre_plug = spapr_machine_device_pre_plug; 2414c20d332aSBharata B Rao hc->plug = spapr_machine_device_plug; 2415c20d332aSBharata B Rao hc->unplug = spapr_machine_device_unplug; 241620bb648dSDavid Gibson mc->cpu_index_to_socket_id = spapr_cpu_index_to_socket_id; 24172474bfd4SIgor Mammedov mc->query_hotpluggable_cpus = spapr_query_hotpluggable_cpus; 241800b4fbe2SMarcel Apfelbaum 2419fc9f38c3SDavid Gibson smc->dr_lmb_enabled = true; 242094a94e4cSBharata B Rao smc->dr_cpu_enabled = true; 242171461b0fSAlexey Kardashevskiy fwc->get_dev_path = spapr_get_fw_dev_path; 242234316482SAlexey Kardashevskiy nc->nmi_monitor_handler = spapr_nmi; 242353018216SPaolo Bonzini } 242453018216SPaolo Bonzini 242529ee3247SAlexey Kardashevskiy static const TypeInfo spapr_machine_info = { 242629ee3247SAlexey Kardashevskiy .name = TYPE_SPAPR_MACHINE, 242729ee3247SAlexey Kardashevskiy .parent = TYPE_MACHINE, 24284aee7362SDavid Gibson .abstract = true, 24296ca1502eSAlexey Kardashevskiy .instance_size = sizeof(sPAPRMachineState), 243023825581SEduardo Habkost .instance_init = spapr_machine_initfn, 243187bbdd9cSDavid Gibson .instance_finalize = spapr_machine_finalizefn, 2432183930c0SDavid Gibson .class_size = sizeof(sPAPRMachineClass), 243329ee3247SAlexey Kardashevskiy .class_init = spapr_machine_class_init, 243471461b0fSAlexey Kardashevskiy .interfaces = (InterfaceInfo[]) { 243571461b0fSAlexey Kardashevskiy { TYPE_FW_PATH_PROVIDER }, 243634316482SAlexey Kardashevskiy { TYPE_NMI }, 2437c20d332aSBharata B Rao { TYPE_HOTPLUG_HANDLER }, 243871461b0fSAlexey Kardashevskiy { } 243971461b0fSAlexey Kardashevskiy }, 244029ee3247SAlexey Kardashevskiy }; 244129ee3247SAlexey Kardashevskiy 2442fccbc785SDavid Gibson #define DEFINE_SPAPR_MACHINE(suffix, verstr, latest) \ 24435013c547SDavid Gibson static void spapr_machine_##suffix##_class_init(ObjectClass *oc, \ 24445013c547SDavid Gibson void *data) \ 24455013c547SDavid Gibson { \ 24465013c547SDavid Gibson MachineClass *mc = MACHINE_CLASS(oc); \ 24475013c547SDavid Gibson spapr_machine_##suffix##_class_options(mc); \ 2448fccbc785SDavid Gibson if (latest) { \ 2449fccbc785SDavid Gibson mc->alias = "pseries"; \ 2450fccbc785SDavid Gibson mc->is_default = 1; \ 2451fccbc785SDavid Gibson } \ 24525013c547SDavid Gibson } \ 24535013c547SDavid Gibson static void spapr_machine_##suffix##_instance_init(Object *obj) \ 24545013c547SDavid Gibson { \ 24555013c547SDavid Gibson MachineState *machine = MACHINE(obj); \ 24565013c547SDavid Gibson spapr_machine_##suffix##_instance_options(machine); \ 24575013c547SDavid Gibson } \ 24585013c547SDavid Gibson static const TypeInfo spapr_machine_##suffix##_info = { \ 24595013c547SDavid Gibson .name = MACHINE_TYPE_NAME("pseries-" verstr), \ 24605013c547SDavid Gibson .parent = TYPE_SPAPR_MACHINE, \ 24615013c547SDavid Gibson .class_init = spapr_machine_##suffix##_class_init, \ 24625013c547SDavid Gibson .instance_init = spapr_machine_##suffix##_instance_init, \ 24635013c547SDavid Gibson }; \ 24645013c547SDavid Gibson static void spapr_machine_register_##suffix(void) \ 24655013c547SDavid Gibson { \ 24665013c547SDavid Gibson type_register(&spapr_machine_##suffix##_info); \ 24675013c547SDavid Gibson } \ 24680e6aac87SEduardo Habkost type_init(spapr_machine_register_##suffix) 24695013c547SDavid Gibson 24701c5f29bbSDavid Gibson /* 24711ea1eefcSBharata B Rao * pseries-2.7 24721ea1eefcSBharata B Rao */ 24731ea1eefcSBharata B Rao static void spapr_machine_2_7_instance_options(MachineState *machine) 24741ea1eefcSBharata B Rao { 24751ea1eefcSBharata B Rao } 24761ea1eefcSBharata B Rao 24771ea1eefcSBharata B Rao static void spapr_machine_2_7_class_options(MachineClass *mc) 24781ea1eefcSBharata B Rao { 24791ea1eefcSBharata B Rao /* Defaults for the latest behaviour inherited from the base class */ 24801ea1eefcSBharata B Rao } 24811ea1eefcSBharata B Rao 24821ea1eefcSBharata B Rao DEFINE_SPAPR_MACHINE(2_7, "2.7", true); 24831ea1eefcSBharata B Rao 24841ea1eefcSBharata B Rao /* 24854b23699cSDavid Gibson * pseries-2.6 24864b23699cSDavid Gibson */ 24871ea1eefcSBharata B Rao #define SPAPR_COMPAT_2_6 \ 24881ea1eefcSBharata B Rao HW_COMPAT_2_6 24891ea1eefcSBharata B Rao 24904b23699cSDavid Gibson static void spapr_machine_2_6_instance_options(MachineState *machine) 24914b23699cSDavid Gibson { 24924b23699cSDavid Gibson } 24934b23699cSDavid Gibson 24944b23699cSDavid Gibson static void spapr_machine_2_6_class_options(MachineClass *mc) 24954b23699cSDavid Gibson { 249694a94e4cSBharata B Rao sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); 249794a94e4cSBharata B Rao 24981ea1eefcSBharata B Rao spapr_machine_2_7_class_options(mc); 249994a94e4cSBharata B Rao smc->dr_cpu_enabled = false; 25001ea1eefcSBharata B Rao SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_6); 25014b23699cSDavid Gibson } 25024b23699cSDavid Gibson 25031ea1eefcSBharata B Rao DEFINE_SPAPR_MACHINE(2_6, "2.6", false); 25044b23699cSDavid Gibson 25054b23699cSDavid Gibson /* 25061c5f29bbSDavid Gibson * pseries-2.5 25071c5f29bbSDavid Gibson */ 25084b23699cSDavid Gibson #define SPAPR_COMPAT_2_5 \ 250957c522f4SThomas Huth HW_COMPAT_2_5 \ 251057c522f4SThomas Huth { \ 251157c522f4SThomas Huth .driver = "spapr-vlan", \ 251257c522f4SThomas Huth .property = "use-rx-buffer-pools", \ 251357c522f4SThomas Huth .value = "off", \ 251457c522f4SThomas Huth }, 25154b23699cSDavid Gibson 25165013c547SDavid Gibson static void spapr_machine_2_5_instance_options(MachineState *machine) 25171c5f29bbSDavid Gibson { 25185013c547SDavid Gibson } 25195013c547SDavid Gibson 25205013c547SDavid Gibson static void spapr_machine_2_5_class_options(MachineClass *mc) 25215013c547SDavid Gibson { 252257040d45SThomas Huth sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); 252357040d45SThomas Huth 25244b23699cSDavid Gibson spapr_machine_2_6_class_options(mc); 252557040d45SThomas Huth smc->use_ohci_by_default = true; 25264b23699cSDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_5); 25271c5f29bbSDavid Gibson } 25281c5f29bbSDavid Gibson 25294b23699cSDavid Gibson DEFINE_SPAPR_MACHINE(2_5, "2.5", false); 25301c5f29bbSDavid Gibson 25311c5f29bbSDavid Gibson /* 25321c5f29bbSDavid Gibson * pseries-2.4 25331c5f29bbSDavid Gibson */ 253480fd50f9SCornelia Huck #define SPAPR_COMPAT_2_4 \ 253580fd50f9SCornelia Huck HW_COMPAT_2_4 253680fd50f9SCornelia Huck 25375013c547SDavid Gibson static void spapr_machine_2_4_instance_options(MachineState *machine) 25381c5f29bbSDavid Gibson { 25395013c547SDavid Gibson spapr_machine_2_5_instance_options(machine); 25405013c547SDavid Gibson } 25411c5f29bbSDavid Gibson 25425013c547SDavid Gibson static void spapr_machine_2_4_class_options(MachineClass *mc) 25435013c547SDavid Gibson { 2544fc9f38c3SDavid Gibson sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); 2545fc9f38c3SDavid Gibson 2546fc9f38c3SDavid Gibson spapr_machine_2_5_class_options(mc); 2547fc9f38c3SDavid Gibson smc->dr_lmb_enabled = false; 2548f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_4); 25491c5f29bbSDavid Gibson } 25501c5f29bbSDavid Gibson 2551fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_4, "2.4", false); 25521c5f29bbSDavid Gibson 25531c5f29bbSDavid Gibson /* 25541c5f29bbSDavid Gibson * pseries-2.3 25551c5f29bbSDavid Gibson */ 255638ff32c6SEduardo Habkost #define SPAPR_COMPAT_2_3 \ 25577619c7b0SMichael Roth HW_COMPAT_2_3 \ 25587619c7b0SMichael Roth {\ 25597619c7b0SMichael Roth .driver = "spapr-pci-host-bridge",\ 25607619c7b0SMichael Roth .property = "dynamic-reconfiguration",\ 25617619c7b0SMichael Roth .value = "off",\ 25627619c7b0SMichael Roth }, 256338ff32c6SEduardo Habkost 25645013c547SDavid Gibson static void spapr_machine_2_3_instance_options(MachineState *machine) 25651c5f29bbSDavid Gibson { 25665013c547SDavid Gibson spapr_machine_2_4_instance_options(machine); 25671c5f29bbSDavid Gibson savevm_skip_section_footers(); 25681c5f29bbSDavid Gibson global_state_set_optional(); 256909b5e30dSGreg Kurz savevm_skip_configuration(); 25701c5f29bbSDavid Gibson } 25711c5f29bbSDavid Gibson 25725013c547SDavid Gibson static void spapr_machine_2_3_class_options(MachineClass *mc) 25731c5f29bbSDavid Gibson { 2574fc9f38c3SDavid Gibson spapr_machine_2_4_class_options(mc); 2575f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_3); 25761c5f29bbSDavid Gibson } 2577fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_3, "2.3", false); 25781c5f29bbSDavid Gibson 25791c5f29bbSDavid Gibson /* 25801c5f29bbSDavid Gibson * pseries-2.2 25811c5f29bbSDavid Gibson */ 25821c5f29bbSDavid Gibson 2583b194df47SAlexey Kardashevskiy #define SPAPR_COMPAT_2_2 \ 25844dfd8eaaSEduardo Habkost HW_COMPAT_2_2 \ 2585b194df47SAlexey Kardashevskiy {\ 2586b194df47SAlexey Kardashevskiy .driver = TYPE_SPAPR_PCI_HOST_BRIDGE,\ 2587b194df47SAlexey Kardashevskiy .property = "mem_win_size",\ 2588b194df47SAlexey Kardashevskiy .value = "0x20000000",\ 2589dd754bafSEduardo Habkost }, 2590b194df47SAlexey Kardashevskiy 25915013c547SDavid Gibson static void spapr_machine_2_2_instance_options(MachineState *machine) 2592b0e966d0SJason Wang { 25935013c547SDavid Gibson spapr_machine_2_3_instance_options(machine); 2594cba0e779SGreg Kurz machine->suppress_vmdesc = true; 2595b0e966d0SJason Wang } 2596b0e966d0SJason Wang 25975013c547SDavid Gibson static void spapr_machine_2_2_class_options(MachineClass *mc) 2598b0e966d0SJason Wang { 2599fc9f38c3SDavid Gibson spapr_machine_2_3_class_options(mc); 2600f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_2); 26011c5f29bbSDavid Gibson } 2602fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_2, "2.2", false); 26031c5f29bbSDavid Gibson 26041c5f29bbSDavid Gibson /* 26051c5f29bbSDavid Gibson * pseries-2.1 26061c5f29bbSDavid Gibson */ 26071c5f29bbSDavid Gibson #define SPAPR_COMPAT_2_1 \ 26081c5f29bbSDavid Gibson HW_COMPAT_2_1 26091c5f29bbSDavid Gibson 26105013c547SDavid Gibson static void spapr_machine_2_1_instance_options(MachineState *machine) 26111c5f29bbSDavid Gibson { 26125013c547SDavid Gibson spapr_machine_2_2_instance_options(machine); 26131c5f29bbSDavid Gibson } 26141c5f29bbSDavid Gibson 26155013c547SDavid Gibson static void spapr_machine_2_1_class_options(MachineClass *mc) 2616b0e966d0SJason Wang { 2617fc9f38c3SDavid Gibson spapr_machine_2_2_class_options(mc); 2618f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_1); 26196026db45SAlexey Kardashevskiy } 2620fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_1, "2.1", false); 26216026db45SAlexey Kardashevskiy 262229ee3247SAlexey Kardashevskiy static void spapr_machine_register_types(void) 262329ee3247SAlexey Kardashevskiy { 262429ee3247SAlexey Kardashevskiy type_register_static(&spapr_machine_info); 262529ee3247SAlexey Kardashevskiy } 262629ee3247SAlexey Kardashevskiy 262729ee3247SAlexey Kardashevskiy type_init(spapr_machine_register_types) 2628