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 */ 2753018216SPaolo Bonzini #include "sysemu/sysemu.h" 28e35704baSEduardo Habkost #include "sysemu/numa.h" 2953018216SPaolo Bonzini #include "hw/hw.h" 3071461b0fSAlexey Kardashevskiy #include "hw/fw-path-provider.h" 3153018216SPaolo Bonzini #include "elf.h" 3253018216SPaolo Bonzini #include "net/net.h" 33ad440b4aSAndrew Jones #include "sysemu/device_tree.h" 34fa1d36dfSMarkus Armbruster #include "sysemu/block-backend.h" 3553018216SPaolo Bonzini #include "sysemu/cpus.h" 3653018216SPaolo Bonzini #include "sysemu/kvm.h" 37c20d332aSBharata B Rao #include "sysemu/device_tree.h" 3853018216SPaolo Bonzini #include "kvm_ppc.h" 39ff14e817SDr. David Alan Gilbert #include "migration/migration.h" 404be21d56SDavid Gibson #include "mmu-hash64.h" 413794d548SAlexey Kardashevskiy #include "qom/cpu.h" 4253018216SPaolo Bonzini 4353018216SPaolo Bonzini #include "hw/boards.h" 440d09e41aSPaolo Bonzini #include "hw/ppc/ppc.h" 4553018216SPaolo Bonzini #include "hw/loader.h" 4653018216SPaolo Bonzini 470d09e41aSPaolo Bonzini #include "hw/ppc/spapr.h" 480d09e41aSPaolo Bonzini #include "hw/ppc/spapr_vio.h" 490d09e41aSPaolo Bonzini #include "hw/pci-host/spapr.h" 500d09e41aSPaolo Bonzini #include "hw/ppc/xics.h" 5153018216SPaolo Bonzini #include "hw/pci/msi.h" 5253018216SPaolo Bonzini 5353018216SPaolo Bonzini #include "hw/pci/pci.h" 5471461b0fSAlexey Kardashevskiy #include "hw/scsi/scsi.h" 5571461b0fSAlexey Kardashevskiy #include "hw/virtio/virtio-scsi.h" 5653018216SPaolo Bonzini 5753018216SPaolo Bonzini #include "exec/address-spaces.h" 5853018216SPaolo Bonzini #include "hw/usb.h" 5953018216SPaolo Bonzini #include "qemu/config-file.h" 60135a129aSAneesh Kumar K.V #include "qemu/error-report.h" 612a6593cbSAlexey Kardashevskiy #include "trace.h" 6234316482SAlexey Kardashevskiy #include "hw/nmi.h" 6353018216SPaolo Bonzini 6468a27b20SMichael S. Tsirkin #include "hw/compat.h" 65224245bfSDavid Gibson #include "qemu-common.h" 6668a27b20SMichael S. Tsirkin 6753018216SPaolo Bonzini #include <libfdt.h> 6853018216SPaolo Bonzini 6953018216SPaolo Bonzini /* SLOF memory layout: 7053018216SPaolo Bonzini * 7153018216SPaolo Bonzini * SLOF raw image loaded at 0, copies its romfs right below the flat 7253018216SPaolo Bonzini * device-tree, then position SLOF itself 31M below that 7353018216SPaolo Bonzini * 7453018216SPaolo Bonzini * So we set FW_OVERHEAD to 40MB which should account for all of that 7553018216SPaolo Bonzini * and more 7653018216SPaolo Bonzini * 7753018216SPaolo Bonzini * We load our kernel at 4M, leaving space for SLOF initial image 7853018216SPaolo Bonzini */ 7938b02bd8SAlexey Kardashevskiy #define FDT_MAX_SIZE 0x100000 8053018216SPaolo Bonzini #define RTAS_MAX_SIZE 0x10000 81b7d1f77aSBenjamin Herrenschmidt #define RTAS_MAX_ADDR 0x80000000 /* RTAS must stay below that */ 8253018216SPaolo Bonzini #define FW_MAX_SIZE 0x400000 8353018216SPaolo Bonzini #define FW_FILE_NAME "slof.bin" 8453018216SPaolo Bonzini #define FW_OVERHEAD 0x2800000 8553018216SPaolo Bonzini #define KERNEL_LOAD_ADDR FW_MAX_SIZE 8653018216SPaolo Bonzini 8753018216SPaolo Bonzini #define MIN_RMA_SLOF 128UL 8853018216SPaolo Bonzini 8953018216SPaolo Bonzini #define TIMEBASE_FREQ 512000000ULL 9053018216SPaolo Bonzini 9153018216SPaolo Bonzini #define PHANDLE_XICP 0x00001111 9253018216SPaolo Bonzini 9353018216SPaolo Bonzini #define HTAB_SIZE(spapr) (1ULL << ((spapr)->htab_shift)) 9453018216SPaolo Bonzini 95c04d6cfaSAnthony Liguori static XICSState *try_create_xics(const char *type, int nr_servers, 9634f2af3dSMarkus Armbruster int nr_irqs, Error **errp) 97c04d6cfaSAnthony Liguori { 9834f2af3dSMarkus Armbruster Error *err = NULL; 99c04d6cfaSAnthony Liguori DeviceState *dev; 100c04d6cfaSAnthony Liguori 101c04d6cfaSAnthony Liguori dev = qdev_create(NULL, type); 102c04d6cfaSAnthony Liguori qdev_prop_set_uint32(dev, "nr_servers", nr_servers); 103c04d6cfaSAnthony Liguori qdev_prop_set_uint32(dev, "nr_irqs", nr_irqs); 10434f2af3dSMarkus Armbruster object_property_set_bool(OBJECT(dev), true, "realized", &err); 10534f2af3dSMarkus Armbruster if (err) { 10634f2af3dSMarkus Armbruster error_propagate(errp, err); 10734f2af3dSMarkus Armbruster object_unparent(OBJECT(dev)); 108c04d6cfaSAnthony Liguori return NULL; 109c04d6cfaSAnthony Liguori } 1105a3d7b23SAlexey Kardashevskiy return XICS_COMMON(dev); 111c04d6cfaSAnthony Liguori } 112c04d6cfaSAnthony Liguori 113446f16a6SMarcel Apfelbaum static XICSState *xics_system_init(MachineState *machine, 114446f16a6SMarcel Apfelbaum int nr_servers, int nr_irqs) 115c04d6cfaSAnthony Liguori { 116c04d6cfaSAnthony Liguori XICSState *icp = NULL; 117c04d6cfaSAnthony Liguori 11811ad93f6SDavid Gibson if (kvm_enabled()) { 11934f2af3dSMarkus Armbruster Error *err = NULL; 12034f2af3dSMarkus Armbruster 121446f16a6SMarcel Apfelbaum if (machine_kernel_irqchip_allowed(machine)) { 12234f2af3dSMarkus Armbruster icp = try_create_xics(TYPE_KVM_XICS, nr_servers, nr_irqs, &err); 12311ad93f6SDavid Gibson } 124446f16a6SMarcel Apfelbaum if (machine_kernel_irqchip_required(machine) && !icp) { 12534f2af3dSMarkus Armbruster error_report("kernel_irqchip requested but unavailable: %s", 12634f2af3dSMarkus Armbruster error_get_pretty(err)); 12711ad93f6SDavid Gibson } 128903a41d3SStefano Dong (董兴水) error_free(err); 12911ad93f6SDavid Gibson } 13011ad93f6SDavid Gibson 13111ad93f6SDavid Gibson if (!icp) { 13234f2af3dSMarkus Armbruster icp = try_create_xics(TYPE_XICS, nr_servers, nr_irqs, &error_abort); 133c04d6cfaSAnthony Liguori } 134c04d6cfaSAnthony Liguori 135c04d6cfaSAnthony Liguori return icp; 136c04d6cfaSAnthony Liguori } 137c04d6cfaSAnthony Liguori 138833d4668SAlexey Kardashevskiy static int spapr_fixup_cpu_smt_dt(void *fdt, int offset, PowerPCCPU *cpu, 139833d4668SAlexey Kardashevskiy int smt_threads) 140833d4668SAlexey Kardashevskiy { 141833d4668SAlexey Kardashevskiy int i, ret = 0; 142833d4668SAlexey Kardashevskiy uint32_t servers_prop[smt_threads]; 143833d4668SAlexey Kardashevskiy uint32_t gservers_prop[smt_threads * 2]; 144833d4668SAlexey Kardashevskiy int index = ppc_get_vcpu_dt_id(cpu); 145833d4668SAlexey Kardashevskiy 1466d9412eaSAlexey Kardashevskiy if (cpu->cpu_version) { 1474bce526eSLaurent Dufour ret = fdt_setprop_cell(fdt, offset, "cpu-version", cpu->cpu_version); 1486d9412eaSAlexey Kardashevskiy if (ret < 0) { 1496d9412eaSAlexey Kardashevskiy return ret; 1506d9412eaSAlexey Kardashevskiy } 1516d9412eaSAlexey Kardashevskiy } 1526d9412eaSAlexey Kardashevskiy 153833d4668SAlexey Kardashevskiy /* Build interrupt servers and gservers properties */ 154833d4668SAlexey Kardashevskiy for (i = 0; i < smt_threads; i++) { 155833d4668SAlexey Kardashevskiy servers_prop[i] = cpu_to_be32(index + i); 156833d4668SAlexey Kardashevskiy /* Hack, direct the group queues back to cpu 0 */ 157833d4668SAlexey Kardashevskiy gservers_prop[i*2] = cpu_to_be32(index + i); 158833d4668SAlexey Kardashevskiy gservers_prop[i*2 + 1] = 0; 159833d4668SAlexey Kardashevskiy } 160833d4668SAlexey Kardashevskiy ret = fdt_setprop(fdt, offset, "ibm,ppc-interrupt-server#s", 161833d4668SAlexey Kardashevskiy servers_prop, sizeof(servers_prop)); 162833d4668SAlexey Kardashevskiy if (ret < 0) { 163833d4668SAlexey Kardashevskiy return ret; 164833d4668SAlexey Kardashevskiy } 165833d4668SAlexey Kardashevskiy ret = fdt_setprop(fdt, offset, "ibm,ppc-interrupt-gserver#s", 166833d4668SAlexey Kardashevskiy gservers_prop, sizeof(gservers_prop)); 167833d4668SAlexey Kardashevskiy 168833d4668SAlexey Kardashevskiy return ret; 169833d4668SAlexey Kardashevskiy } 170833d4668SAlexey Kardashevskiy 1710da6f3feSBharata B Rao static int spapr_fixup_cpu_numa_dt(void *fdt, int offset, CPUState *cs) 1720da6f3feSBharata B Rao { 1730da6f3feSBharata B Rao int ret = 0; 1740da6f3feSBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(cs); 1750da6f3feSBharata B Rao int index = ppc_get_vcpu_dt_id(cpu); 1760da6f3feSBharata B Rao uint32_t associativity[] = {cpu_to_be32(0x5), 1770da6f3feSBharata B Rao cpu_to_be32(0x0), 1780da6f3feSBharata B Rao cpu_to_be32(0x0), 1790da6f3feSBharata B Rao cpu_to_be32(0x0), 1800da6f3feSBharata B Rao cpu_to_be32(cs->numa_node), 1810da6f3feSBharata B Rao cpu_to_be32(index)}; 1820da6f3feSBharata B Rao 1830da6f3feSBharata B Rao /* Advertise NUMA via ibm,associativity */ 1840da6f3feSBharata B Rao if (nb_numa_nodes > 1) { 1850da6f3feSBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,associativity", associativity, 1860da6f3feSBharata B Rao sizeof(associativity)); 1870da6f3feSBharata B Rao } 1880da6f3feSBharata B Rao 1890da6f3feSBharata B Rao return ret; 1900da6f3feSBharata B Rao } 1910da6f3feSBharata B Rao 19228e02042SDavid Gibson static int spapr_fixup_cpu_dt(void *fdt, sPAPRMachineState *spapr) 19353018216SPaolo Bonzini { 19482677ed2SAlexey Kardashevskiy int ret = 0, offset, cpus_offset; 19582677ed2SAlexey Kardashevskiy CPUState *cs; 19653018216SPaolo Bonzini char cpu_model[32]; 19753018216SPaolo Bonzini int smt = kvmppc_smt_threads(); 19853018216SPaolo Bonzini uint32_t pft_size_prop[] = {0, cpu_to_be32(spapr->htab_shift)}; 19953018216SPaolo Bonzini 20082677ed2SAlexey Kardashevskiy CPU_FOREACH(cs) { 20182677ed2SAlexey Kardashevskiy PowerPCCPU *cpu = POWERPC_CPU(cs); 20282677ed2SAlexey Kardashevskiy DeviceClass *dc = DEVICE_GET_CLASS(cs); 20382677ed2SAlexey Kardashevskiy int index = ppc_get_vcpu_dt_id(cpu); 20453018216SPaolo Bonzini 2050f20ba62SAlexey Kardashevskiy if ((index % smt) != 0) { 20653018216SPaolo Bonzini continue; 20753018216SPaolo Bonzini } 20853018216SPaolo Bonzini 20982677ed2SAlexey Kardashevskiy snprintf(cpu_model, 32, "%s@%x", dc->fw_name, index); 21053018216SPaolo Bonzini 21182677ed2SAlexey Kardashevskiy cpus_offset = fdt_path_offset(fdt, "/cpus"); 21282677ed2SAlexey Kardashevskiy if (cpus_offset < 0) { 21382677ed2SAlexey Kardashevskiy cpus_offset = fdt_add_subnode(fdt, fdt_path_offset(fdt, "/"), 21482677ed2SAlexey Kardashevskiy "cpus"); 21582677ed2SAlexey Kardashevskiy if (cpus_offset < 0) { 21682677ed2SAlexey Kardashevskiy return cpus_offset; 21782677ed2SAlexey Kardashevskiy } 21882677ed2SAlexey Kardashevskiy } 21982677ed2SAlexey Kardashevskiy offset = fdt_subnode_offset(fdt, cpus_offset, cpu_model); 22082677ed2SAlexey Kardashevskiy if (offset < 0) { 22182677ed2SAlexey Kardashevskiy offset = fdt_add_subnode(fdt, cpus_offset, cpu_model); 22253018216SPaolo Bonzini if (offset < 0) { 22353018216SPaolo Bonzini return offset; 22453018216SPaolo Bonzini } 22582677ed2SAlexey Kardashevskiy } 22653018216SPaolo Bonzini 2270da6f3feSBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,pft-size", 2280da6f3feSBharata B Rao pft_size_prop, sizeof(pft_size_prop)); 22953018216SPaolo Bonzini if (ret < 0) { 23053018216SPaolo Bonzini return ret; 23153018216SPaolo Bonzini } 23253018216SPaolo Bonzini 2330da6f3feSBharata B Rao ret = spapr_fixup_cpu_numa_dt(fdt, offset, cs); 23453018216SPaolo Bonzini if (ret < 0) { 23553018216SPaolo Bonzini return ret; 23653018216SPaolo Bonzini } 237833d4668SAlexey Kardashevskiy 23882677ed2SAlexey Kardashevskiy ret = spapr_fixup_cpu_smt_dt(fdt, offset, cpu, 2392a48d993SAlexey Kardashevskiy ppc_get_compat_smt_threads(cpu)); 240833d4668SAlexey Kardashevskiy if (ret < 0) { 241833d4668SAlexey Kardashevskiy return ret; 242833d4668SAlexey Kardashevskiy } 24353018216SPaolo Bonzini } 24453018216SPaolo Bonzini return ret; 24553018216SPaolo Bonzini } 24653018216SPaolo Bonzini 24753018216SPaolo Bonzini 24853018216SPaolo Bonzini static size_t create_page_sizes_prop(CPUPPCState *env, uint32_t *prop, 24953018216SPaolo Bonzini size_t maxsize) 25053018216SPaolo Bonzini { 25153018216SPaolo Bonzini size_t maxcells = maxsize / sizeof(uint32_t); 25253018216SPaolo Bonzini int i, j, count; 25353018216SPaolo Bonzini uint32_t *p = prop; 25453018216SPaolo Bonzini 25553018216SPaolo Bonzini for (i = 0; i < PPC_PAGE_SIZES_MAX_SZ; i++) { 25653018216SPaolo Bonzini struct ppc_one_seg_page_size *sps = &env->sps.sps[i]; 25753018216SPaolo Bonzini 25853018216SPaolo Bonzini if (!sps->page_shift) { 25953018216SPaolo Bonzini break; 26053018216SPaolo Bonzini } 26153018216SPaolo Bonzini for (count = 0; count < PPC_PAGE_SIZES_MAX_SZ; count++) { 26253018216SPaolo Bonzini if (sps->enc[count].page_shift == 0) { 26353018216SPaolo Bonzini break; 26453018216SPaolo Bonzini } 26553018216SPaolo Bonzini } 26653018216SPaolo Bonzini if ((p - prop) >= (maxcells - 3 - count * 2)) { 26753018216SPaolo Bonzini break; 26853018216SPaolo Bonzini } 26953018216SPaolo Bonzini *(p++) = cpu_to_be32(sps->page_shift); 27053018216SPaolo Bonzini *(p++) = cpu_to_be32(sps->slb_enc); 27153018216SPaolo Bonzini *(p++) = cpu_to_be32(count); 27253018216SPaolo Bonzini for (j = 0; j < count; j++) { 27353018216SPaolo Bonzini *(p++) = cpu_to_be32(sps->enc[j].page_shift); 27453018216SPaolo Bonzini *(p++) = cpu_to_be32(sps->enc[j].pte_enc); 27553018216SPaolo Bonzini } 27653018216SPaolo Bonzini } 27753018216SPaolo Bonzini 27853018216SPaolo Bonzini return (p - prop) * sizeof(uint32_t); 27953018216SPaolo Bonzini } 28053018216SPaolo Bonzini 281b082d65aSAlexey Kardashevskiy static hwaddr spapr_node0_size(void) 282b082d65aSAlexey Kardashevskiy { 283fb164994SDavid Gibson MachineState *machine = MACHINE(qdev_get_machine()); 284fb164994SDavid Gibson 285b082d65aSAlexey Kardashevskiy if (nb_numa_nodes) { 286b082d65aSAlexey Kardashevskiy int i; 287b082d65aSAlexey Kardashevskiy for (i = 0; i < nb_numa_nodes; ++i) { 288b082d65aSAlexey Kardashevskiy if (numa_info[i].node_mem) { 289fb164994SDavid Gibson return MIN(pow2floor(numa_info[i].node_mem), 290fb164994SDavid Gibson machine->ram_size); 291b082d65aSAlexey Kardashevskiy } 292b082d65aSAlexey Kardashevskiy } 293b082d65aSAlexey Kardashevskiy } 294fb164994SDavid Gibson return machine->ram_size; 295b082d65aSAlexey Kardashevskiy } 296b082d65aSAlexey Kardashevskiy 29753018216SPaolo Bonzini #define _FDT(exp) \ 29853018216SPaolo Bonzini do { \ 29953018216SPaolo Bonzini int ret = (exp); \ 30053018216SPaolo Bonzini if (ret < 0) { \ 30153018216SPaolo Bonzini fprintf(stderr, "qemu: error creating device tree: %s: %s\n", \ 30253018216SPaolo Bonzini #exp, fdt_strerror(ret)); \ 30353018216SPaolo Bonzini exit(1); \ 30453018216SPaolo Bonzini } \ 30553018216SPaolo Bonzini } while (0) 30653018216SPaolo Bonzini 307a1d59c0fSAlexey Kardashevskiy static void add_str(GString *s, const gchar *s1) 308a1d59c0fSAlexey Kardashevskiy { 309a1d59c0fSAlexey Kardashevskiy g_string_append_len(s, s1, strlen(s1) + 1); 310a1d59c0fSAlexey Kardashevskiy } 31153018216SPaolo Bonzini 3123bbf37f2SAndreas Färber static void *spapr_create_fdt_skel(hwaddr initrd_base, 31353018216SPaolo Bonzini hwaddr initrd_size, 31453018216SPaolo Bonzini hwaddr kernel_size, 31516457e7fSBenjamin Herrenschmidt bool little_endian, 31653018216SPaolo Bonzini const char *kernel_cmdline, 31753018216SPaolo Bonzini uint32_t epow_irq) 31853018216SPaolo Bonzini { 31953018216SPaolo Bonzini void *fdt; 32053018216SPaolo Bonzini uint32_t start_prop = cpu_to_be32(initrd_base); 32153018216SPaolo Bonzini uint32_t end_prop = cpu_to_be32(initrd_base + initrd_size); 322a1d59c0fSAlexey Kardashevskiy GString *hypertas = g_string_sized_new(256); 323a1d59c0fSAlexey Kardashevskiy GString *qemu_hypertas = g_string_sized_new(256); 32453018216SPaolo Bonzini uint32_t refpoints[] = {cpu_to_be32(0x4), cpu_to_be32(0x4)}; 3259e734e3dSBharata B Rao uint32_t interrupt_server_ranges_prop[] = {0, cpu_to_be32(max_cpus)}; 32653018216SPaolo Bonzini unsigned char vec5[] = {0x0, 0x0, 0x0, 0x0, 0x0, 0x80}; 327ef951443SNikunj A Dadhania char *buf; 32853018216SPaolo Bonzini 329a1d59c0fSAlexey Kardashevskiy add_str(hypertas, "hcall-pft"); 330a1d59c0fSAlexey Kardashevskiy add_str(hypertas, "hcall-term"); 331a1d59c0fSAlexey Kardashevskiy add_str(hypertas, "hcall-dabr"); 332a1d59c0fSAlexey Kardashevskiy add_str(hypertas, "hcall-interrupt"); 333a1d59c0fSAlexey Kardashevskiy add_str(hypertas, "hcall-tce"); 334a1d59c0fSAlexey Kardashevskiy add_str(hypertas, "hcall-vio"); 335a1d59c0fSAlexey Kardashevskiy add_str(hypertas, "hcall-splpar"); 336a1d59c0fSAlexey Kardashevskiy add_str(hypertas, "hcall-bulk"); 337a1d59c0fSAlexey Kardashevskiy add_str(hypertas, "hcall-set-mode"); 338a1d59c0fSAlexey Kardashevskiy add_str(qemu_hypertas, "hcall-memop1"); 339a1d59c0fSAlexey Kardashevskiy 34053018216SPaolo Bonzini fdt = g_malloc0(FDT_MAX_SIZE); 34153018216SPaolo Bonzini _FDT((fdt_create(fdt, FDT_MAX_SIZE))); 34253018216SPaolo Bonzini 34353018216SPaolo Bonzini if (kernel_size) { 34453018216SPaolo Bonzini _FDT((fdt_add_reservemap_entry(fdt, KERNEL_LOAD_ADDR, kernel_size))); 34553018216SPaolo Bonzini } 34653018216SPaolo Bonzini if (initrd_size) { 34753018216SPaolo Bonzini _FDT((fdt_add_reservemap_entry(fdt, initrd_base, initrd_size))); 34853018216SPaolo Bonzini } 34953018216SPaolo Bonzini _FDT((fdt_finish_reservemap(fdt))); 35053018216SPaolo Bonzini 35153018216SPaolo Bonzini /* Root node */ 35253018216SPaolo Bonzini _FDT((fdt_begin_node(fdt, ""))); 35353018216SPaolo Bonzini _FDT((fdt_property_string(fdt, "device_type", "chrp"))); 35453018216SPaolo Bonzini _FDT((fdt_property_string(fdt, "model", "IBM pSeries (emulated by qemu)"))); 355fa388916SAnthony Liguori _FDT((fdt_property_string(fdt, "compatible", "qemu,pseries"))); 35653018216SPaolo Bonzini 357ef951443SNikunj A Dadhania /* 358ef951443SNikunj A Dadhania * Add info to guest to indentify which host is it being run on 359ef951443SNikunj A Dadhania * and what is the uuid of the guest 360ef951443SNikunj A Dadhania */ 361ef951443SNikunj A Dadhania if (kvmppc_get_host_model(&buf)) { 362ef951443SNikunj A Dadhania _FDT((fdt_property_string(fdt, "host-model", buf))); 363ef951443SNikunj A Dadhania g_free(buf); 364ef951443SNikunj A Dadhania } 365ef951443SNikunj A Dadhania if (kvmppc_get_host_serial(&buf)) { 366ef951443SNikunj A Dadhania _FDT((fdt_property_string(fdt, "host-serial", buf))); 367ef951443SNikunj A Dadhania g_free(buf); 368ef951443SNikunj A Dadhania } 369ef951443SNikunj A Dadhania 370ef951443SNikunj A Dadhania buf = g_strdup_printf(UUID_FMT, qemu_uuid[0], qemu_uuid[1], 371ef951443SNikunj A Dadhania qemu_uuid[2], qemu_uuid[3], qemu_uuid[4], 372ef951443SNikunj A Dadhania qemu_uuid[5], qemu_uuid[6], qemu_uuid[7], 373ef951443SNikunj A Dadhania qemu_uuid[8], qemu_uuid[9], qemu_uuid[10], 374ef951443SNikunj A Dadhania qemu_uuid[11], qemu_uuid[12], qemu_uuid[13], 375ef951443SNikunj A Dadhania qemu_uuid[14], qemu_uuid[15]); 376ef951443SNikunj A Dadhania 377ef951443SNikunj A Dadhania _FDT((fdt_property_string(fdt, "vm,uuid", buf))); 378*3dc0a66dSAlexey Kardashevskiy if (qemu_uuid_set) { 379*3dc0a66dSAlexey Kardashevskiy _FDT((fdt_property_string(fdt, "system-id", buf))); 380*3dc0a66dSAlexey Kardashevskiy } 381ef951443SNikunj A Dadhania g_free(buf); 382ef951443SNikunj A Dadhania 3832c1aaa81SSam Bobroff if (qemu_get_vm_name()) { 3842c1aaa81SSam Bobroff _FDT((fdt_property_string(fdt, "ibm,partition-name", 3852c1aaa81SSam Bobroff qemu_get_vm_name()))); 3862c1aaa81SSam Bobroff } 3872c1aaa81SSam Bobroff 38853018216SPaolo Bonzini _FDT((fdt_property_cell(fdt, "#address-cells", 0x2))); 38953018216SPaolo Bonzini _FDT((fdt_property_cell(fdt, "#size-cells", 0x2))); 39053018216SPaolo Bonzini 39153018216SPaolo Bonzini /* /chosen */ 39253018216SPaolo Bonzini _FDT((fdt_begin_node(fdt, "chosen"))); 39353018216SPaolo Bonzini 39453018216SPaolo Bonzini /* Set Form1_affinity */ 39553018216SPaolo Bonzini _FDT((fdt_property(fdt, "ibm,architecture-vec-5", vec5, sizeof(vec5)))); 39653018216SPaolo Bonzini 39753018216SPaolo Bonzini _FDT((fdt_property_string(fdt, "bootargs", kernel_cmdline))); 39853018216SPaolo Bonzini _FDT((fdt_property(fdt, "linux,initrd-start", 39953018216SPaolo Bonzini &start_prop, sizeof(start_prop)))); 40053018216SPaolo Bonzini _FDT((fdt_property(fdt, "linux,initrd-end", 40153018216SPaolo Bonzini &end_prop, sizeof(end_prop)))); 40253018216SPaolo Bonzini if (kernel_size) { 40353018216SPaolo Bonzini uint64_t kprop[2] = { cpu_to_be64(KERNEL_LOAD_ADDR), 40453018216SPaolo Bonzini cpu_to_be64(kernel_size) }; 40553018216SPaolo Bonzini 40653018216SPaolo Bonzini _FDT((fdt_property(fdt, "qemu,boot-kernel", &kprop, sizeof(kprop)))); 40716457e7fSBenjamin Herrenschmidt if (little_endian) { 40816457e7fSBenjamin Herrenschmidt _FDT((fdt_property(fdt, "qemu,boot-kernel-le", NULL, 0))); 40916457e7fSBenjamin Herrenschmidt } 41053018216SPaolo Bonzini } 411cc84c0f3SAvik Sil if (boot_menu) { 412cc84c0f3SAvik Sil _FDT((fdt_property_cell(fdt, "qemu,boot-menu", boot_menu))); 413cc84c0f3SAvik Sil } 41453018216SPaolo Bonzini _FDT((fdt_property_cell(fdt, "qemu,graphic-width", graphic_width))); 41553018216SPaolo Bonzini _FDT((fdt_property_cell(fdt, "qemu,graphic-height", graphic_height))); 41653018216SPaolo Bonzini _FDT((fdt_property_cell(fdt, "qemu,graphic-depth", graphic_depth))); 41753018216SPaolo Bonzini 41853018216SPaolo Bonzini _FDT((fdt_end_node(fdt))); 41953018216SPaolo Bonzini 42053018216SPaolo Bonzini /* RTAS */ 42153018216SPaolo Bonzini _FDT((fdt_begin_node(fdt, "rtas"))); 42253018216SPaolo Bonzini 423da95324eSAlexey Kardashevskiy if (!kvm_enabled() || kvmppc_spapr_use_multitce()) { 424da95324eSAlexey Kardashevskiy add_str(hypertas, "hcall-multi-tce"); 425da95324eSAlexey Kardashevskiy } 426a1d59c0fSAlexey Kardashevskiy _FDT((fdt_property(fdt, "ibm,hypertas-functions", hypertas->str, 427a1d59c0fSAlexey Kardashevskiy hypertas->len))); 428a1d59c0fSAlexey Kardashevskiy g_string_free(hypertas, TRUE); 429a1d59c0fSAlexey Kardashevskiy _FDT((fdt_property(fdt, "qemu,hypertas-functions", qemu_hypertas->str, 430a1d59c0fSAlexey Kardashevskiy qemu_hypertas->len))); 431a1d59c0fSAlexey Kardashevskiy g_string_free(qemu_hypertas, TRUE); 43253018216SPaolo Bonzini 43353018216SPaolo Bonzini _FDT((fdt_property(fdt, "ibm,associativity-reference-points", 43453018216SPaolo Bonzini refpoints, sizeof(refpoints)))); 43553018216SPaolo Bonzini 43653018216SPaolo Bonzini _FDT((fdt_property_cell(fdt, "rtas-error-log-max", RTAS_ERROR_LOG_MAX))); 43779853e18STyrel Datwyler _FDT((fdt_property_cell(fdt, "rtas-event-scan-rate", 43879853e18STyrel Datwyler RTAS_EVENT_SCAN_RATE))); 43953018216SPaolo Bonzini 440a95f9922SSam Bobroff if (msi_supported) { 441a95f9922SSam Bobroff _FDT((fdt_property(fdt, "ibm,change-msix-capable", NULL, 0))); 442a95f9922SSam Bobroff } 443a95f9922SSam Bobroff 4442e14072fSNikunj A Dadhania /* 4459d632f5fSzhanghailiang * According to PAPR, rtas ibm,os-term does not guarantee a return 4462e14072fSNikunj A Dadhania * back to the guest cpu. 4472e14072fSNikunj A Dadhania * 4482e14072fSNikunj A Dadhania * While an additional ibm,extended-os-term property indicates that 4492e14072fSNikunj A Dadhania * rtas call return will always occur. Set this property. 4502e14072fSNikunj A Dadhania */ 4512e14072fSNikunj A Dadhania _FDT((fdt_property(fdt, "ibm,extended-os-term", NULL, 0))); 4522e14072fSNikunj A Dadhania 45353018216SPaolo Bonzini _FDT((fdt_end_node(fdt))); 45453018216SPaolo Bonzini 45553018216SPaolo Bonzini /* interrupt controller */ 45653018216SPaolo Bonzini _FDT((fdt_begin_node(fdt, "interrupt-controller"))); 45753018216SPaolo Bonzini 45853018216SPaolo Bonzini _FDT((fdt_property_string(fdt, "device_type", 45953018216SPaolo Bonzini "PowerPC-External-Interrupt-Presentation"))); 46053018216SPaolo Bonzini _FDT((fdt_property_string(fdt, "compatible", "IBM,ppc-xicp"))); 46153018216SPaolo Bonzini _FDT((fdt_property(fdt, "interrupt-controller", NULL, 0))); 46253018216SPaolo Bonzini _FDT((fdt_property(fdt, "ibm,interrupt-server-ranges", 46353018216SPaolo Bonzini interrupt_server_ranges_prop, 46453018216SPaolo Bonzini sizeof(interrupt_server_ranges_prop)))); 46553018216SPaolo Bonzini _FDT((fdt_property_cell(fdt, "#interrupt-cells", 2))); 46653018216SPaolo Bonzini _FDT((fdt_property_cell(fdt, "linux,phandle", PHANDLE_XICP))); 46753018216SPaolo Bonzini _FDT((fdt_property_cell(fdt, "phandle", PHANDLE_XICP))); 46853018216SPaolo Bonzini 46953018216SPaolo Bonzini _FDT((fdt_end_node(fdt))); 47053018216SPaolo Bonzini 47153018216SPaolo Bonzini /* vdevice */ 47253018216SPaolo Bonzini _FDT((fdt_begin_node(fdt, "vdevice"))); 47353018216SPaolo Bonzini 47453018216SPaolo Bonzini _FDT((fdt_property_string(fdt, "device_type", "vdevice"))); 47553018216SPaolo Bonzini _FDT((fdt_property_string(fdt, "compatible", "IBM,vdevice"))); 47653018216SPaolo Bonzini _FDT((fdt_property_cell(fdt, "#address-cells", 0x1))); 47753018216SPaolo Bonzini _FDT((fdt_property_cell(fdt, "#size-cells", 0x0))); 47853018216SPaolo Bonzini _FDT((fdt_property_cell(fdt, "#interrupt-cells", 0x2))); 47953018216SPaolo Bonzini _FDT((fdt_property(fdt, "interrupt-controller", NULL, 0))); 48053018216SPaolo Bonzini 48153018216SPaolo Bonzini _FDT((fdt_end_node(fdt))); 48253018216SPaolo Bonzini 48353018216SPaolo Bonzini /* event-sources */ 48453018216SPaolo Bonzini spapr_events_fdt_skel(fdt, epow_irq); 48553018216SPaolo Bonzini 486f7d69146SAlexander Graf /* /hypervisor node */ 487f7d69146SAlexander Graf if (kvm_enabled()) { 488f7d69146SAlexander Graf uint8_t hypercall[16]; 489f7d69146SAlexander Graf 490f7d69146SAlexander Graf /* indicate KVM hypercall interface */ 491f7d69146SAlexander Graf _FDT((fdt_begin_node(fdt, "hypervisor"))); 492f7d69146SAlexander Graf _FDT((fdt_property_string(fdt, "compatible", "linux,kvm"))); 493f7d69146SAlexander Graf if (kvmppc_has_cap_fixup_hcalls()) { 494f7d69146SAlexander Graf /* 495f7d69146SAlexander Graf * Older KVM versions with older guest kernels were broken with the 496f7d69146SAlexander Graf * magic page, don't allow the guest to map it. 497f7d69146SAlexander Graf */ 498f7d69146SAlexander Graf kvmppc_get_hypercall(first_cpu->env_ptr, hypercall, 499f7d69146SAlexander Graf sizeof(hypercall)); 500f7d69146SAlexander Graf _FDT((fdt_property(fdt, "hcall-instructions", hypercall, 501f7d69146SAlexander Graf sizeof(hypercall)))); 502f7d69146SAlexander Graf } 503f7d69146SAlexander Graf _FDT((fdt_end_node(fdt))); 504f7d69146SAlexander Graf } 505f7d69146SAlexander Graf 50653018216SPaolo Bonzini _FDT((fdt_end_node(fdt))); /* close root node */ 50753018216SPaolo Bonzini _FDT((fdt_finish(fdt))); 50853018216SPaolo Bonzini 50953018216SPaolo Bonzini return fdt; 51053018216SPaolo Bonzini } 51153018216SPaolo Bonzini 51203d196b7SBharata B Rao static int spapr_populate_memory_node(void *fdt, int nodeid, hwaddr start, 51326a8c353SAlexey Kardashevskiy hwaddr size) 51426a8c353SAlexey Kardashevskiy { 51526a8c353SAlexey Kardashevskiy uint32_t associativity[] = { 51626a8c353SAlexey Kardashevskiy cpu_to_be32(0x4), /* length */ 51726a8c353SAlexey Kardashevskiy cpu_to_be32(0x0), cpu_to_be32(0x0), 518c3b4f589SAlexey Kardashevskiy cpu_to_be32(0x0), cpu_to_be32(nodeid) 51926a8c353SAlexey Kardashevskiy }; 52026a8c353SAlexey Kardashevskiy char mem_name[32]; 52126a8c353SAlexey Kardashevskiy uint64_t mem_reg_property[2]; 52226a8c353SAlexey Kardashevskiy int off; 52326a8c353SAlexey Kardashevskiy 52426a8c353SAlexey Kardashevskiy mem_reg_property[0] = cpu_to_be64(start); 52526a8c353SAlexey Kardashevskiy mem_reg_property[1] = cpu_to_be64(size); 52626a8c353SAlexey Kardashevskiy 52726a8c353SAlexey Kardashevskiy sprintf(mem_name, "memory@" TARGET_FMT_lx, start); 52826a8c353SAlexey Kardashevskiy off = fdt_add_subnode(fdt, 0, mem_name); 52926a8c353SAlexey Kardashevskiy _FDT(off); 53026a8c353SAlexey Kardashevskiy _FDT((fdt_setprop_string(fdt, off, "device_type", "memory"))); 53126a8c353SAlexey Kardashevskiy _FDT((fdt_setprop(fdt, off, "reg", mem_reg_property, 53226a8c353SAlexey Kardashevskiy sizeof(mem_reg_property)))); 53326a8c353SAlexey Kardashevskiy _FDT((fdt_setprop(fdt, off, "ibm,associativity", associativity, 53426a8c353SAlexey Kardashevskiy sizeof(associativity)))); 53503d196b7SBharata B Rao return off; 53626a8c353SAlexey Kardashevskiy } 53726a8c353SAlexey Kardashevskiy 53828e02042SDavid Gibson static int spapr_populate_memory(sPAPRMachineState *spapr, void *fdt) 53953018216SPaolo Bonzini { 540fb164994SDavid Gibson MachineState *machine = MACHINE(spapr); 5417db8a127SAlexey Kardashevskiy hwaddr mem_start, node_size; 5427db8a127SAlexey Kardashevskiy int i, nb_nodes = nb_numa_nodes; 5437db8a127SAlexey Kardashevskiy NodeInfo *nodes = numa_info; 5447db8a127SAlexey Kardashevskiy NodeInfo ramnode; 54553018216SPaolo Bonzini 5467db8a127SAlexey Kardashevskiy /* No NUMA nodes, assume there is just one node with whole RAM */ 5477db8a127SAlexey Kardashevskiy if (!nb_numa_nodes) { 5487db8a127SAlexey Kardashevskiy nb_nodes = 1; 549fb164994SDavid Gibson ramnode.node_mem = machine->ram_size; 5507db8a127SAlexey Kardashevskiy nodes = &ramnode; 5515fe269b1SPaul Mackerras } 55253018216SPaolo Bonzini 5537db8a127SAlexey Kardashevskiy for (i = 0, mem_start = 0; i < nb_nodes; ++i) { 5547db8a127SAlexey Kardashevskiy if (!nodes[i].node_mem) { 5557db8a127SAlexey Kardashevskiy continue; 55653018216SPaolo Bonzini } 557fb164994SDavid Gibson if (mem_start >= machine->ram_size) { 5585fe269b1SPaul Mackerras node_size = 0; 5595fe269b1SPaul Mackerras } else { 5607db8a127SAlexey Kardashevskiy node_size = nodes[i].node_mem; 561fb164994SDavid Gibson if (node_size > machine->ram_size - mem_start) { 562fb164994SDavid Gibson node_size = machine->ram_size - mem_start; 5635fe269b1SPaul Mackerras } 5645fe269b1SPaul Mackerras } 5657db8a127SAlexey Kardashevskiy if (!mem_start) { 5667db8a127SAlexey Kardashevskiy /* ppc_spapr_init() checks for rma_size <= node0_size already */ 567e8f986fcSBharata B Rao spapr_populate_memory_node(fdt, i, 0, spapr->rma_size); 5687db8a127SAlexey Kardashevskiy mem_start += spapr->rma_size; 5697db8a127SAlexey Kardashevskiy node_size -= spapr->rma_size; 5707db8a127SAlexey Kardashevskiy } 5716010818cSAlexey Kardashevskiy for ( ; node_size; ) { 5726010818cSAlexey Kardashevskiy hwaddr sizetmp = pow2floor(node_size); 5736010818cSAlexey Kardashevskiy 5746010818cSAlexey Kardashevskiy /* mem_start != 0 here */ 5756010818cSAlexey Kardashevskiy if (ctzl(mem_start) < ctzl(sizetmp)) { 5766010818cSAlexey Kardashevskiy sizetmp = 1ULL << ctzl(mem_start); 5776010818cSAlexey Kardashevskiy } 5786010818cSAlexey Kardashevskiy 5796010818cSAlexey Kardashevskiy spapr_populate_memory_node(fdt, i, mem_start, sizetmp); 5806010818cSAlexey Kardashevskiy node_size -= sizetmp; 5816010818cSAlexey Kardashevskiy mem_start += sizetmp; 5826010818cSAlexey Kardashevskiy } 58353018216SPaolo Bonzini } 58453018216SPaolo Bonzini 58553018216SPaolo Bonzini return 0; 58653018216SPaolo Bonzini } 58753018216SPaolo Bonzini 5880da6f3feSBharata B Rao static void spapr_populate_cpu_dt(CPUState *cs, void *fdt, int offset, 5890da6f3feSBharata B Rao sPAPRMachineState *spapr) 5900da6f3feSBharata B Rao { 5910da6f3feSBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(cs); 5920da6f3feSBharata B Rao CPUPPCState *env = &cpu->env; 5930da6f3feSBharata B Rao PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(cs); 5940da6f3feSBharata B Rao int index = ppc_get_vcpu_dt_id(cpu); 5950da6f3feSBharata B Rao uint32_t segs[] = {cpu_to_be32(28), cpu_to_be32(40), 5960da6f3feSBharata B Rao 0xffffffff, 0xffffffff}; 5970da6f3feSBharata B Rao uint32_t tbfreq = kvm_enabled() ? kvmppc_get_tbfreq() : TIMEBASE_FREQ; 5980da6f3feSBharata B Rao uint32_t cpufreq = kvm_enabled() ? kvmppc_get_clockfreq() : 1000000000; 5990da6f3feSBharata B Rao uint32_t page_sizes_prop[64]; 6000da6f3feSBharata B Rao size_t page_sizes_prop_size; 60122419c2aSDavid Gibson uint32_t vcpus_per_socket = smp_threads * smp_cores; 6020da6f3feSBharata B Rao uint32_t pft_size_prop[] = {0, cpu_to_be32(spapr->htab_shift)}; 6030da6f3feSBharata B Rao 60490da0d5aSBenjamin Herrenschmidt /* Note: we keep CI large pages off for now because a 64K capable guest 60590da0d5aSBenjamin Herrenschmidt * provisioned with large pages might otherwise try to map a qemu 60690da0d5aSBenjamin Herrenschmidt * framebuffer (or other kind of memory mapped PCI BAR) using 64K pages 60790da0d5aSBenjamin Herrenschmidt * even if that qemu runs on a 4k host. 60890da0d5aSBenjamin Herrenschmidt * 60990da0d5aSBenjamin Herrenschmidt * We can later add this bit back when we are confident this is not 61090da0d5aSBenjamin Herrenschmidt * an issue (!HV KVM or 64K host) 61190da0d5aSBenjamin Herrenschmidt */ 61290da0d5aSBenjamin Herrenschmidt uint8_t pa_features_206[] = { 6, 0, 61390da0d5aSBenjamin Herrenschmidt 0xf6, 0x1f, 0xc7, 0x00, 0x80, 0xc0 }; 61490da0d5aSBenjamin Herrenschmidt uint8_t pa_features_207[] = { 24, 0, 61590da0d5aSBenjamin Herrenschmidt 0xf6, 0x1f, 0xc7, 0xc0, 0x80, 0xf0, 61690da0d5aSBenjamin Herrenschmidt 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 61790da0d5aSBenjamin Herrenschmidt 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 61890da0d5aSBenjamin Herrenschmidt 0x80, 0x00, 0x80, 0x00, 0x80, 0x00 }; 61990da0d5aSBenjamin Herrenschmidt uint8_t *pa_features; 62090da0d5aSBenjamin Herrenschmidt size_t pa_size; 62190da0d5aSBenjamin Herrenschmidt 6220da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "reg", index))); 6230da6f3feSBharata B Rao _FDT((fdt_setprop_string(fdt, offset, "device_type", "cpu"))); 6240da6f3feSBharata B Rao 6250da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "cpu-version", env->spr[SPR_PVR]))); 6260da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "d-cache-block-size", 6270da6f3feSBharata B Rao env->dcache_line_size))); 6280da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "d-cache-line-size", 6290da6f3feSBharata B Rao env->dcache_line_size))); 6300da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "i-cache-block-size", 6310da6f3feSBharata B Rao env->icache_line_size))); 6320da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "i-cache-line-size", 6330da6f3feSBharata B Rao env->icache_line_size))); 6340da6f3feSBharata B Rao 6350da6f3feSBharata B Rao if (pcc->l1_dcache_size) { 6360da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "d-cache-size", 6370da6f3feSBharata B Rao pcc->l1_dcache_size))); 6380da6f3feSBharata B Rao } else { 6390da6f3feSBharata B Rao fprintf(stderr, "Warning: Unknown L1 dcache size for cpu\n"); 6400da6f3feSBharata B Rao } 6410da6f3feSBharata B Rao if (pcc->l1_icache_size) { 6420da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "i-cache-size", 6430da6f3feSBharata B Rao pcc->l1_icache_size))); 6440da6f3feSBharata B Rao } else { 6450da6f3feSBharata B Rao fprintf(stderr, "Warning: Unknown L1 icache size for cpu\n"); 6460da6f3feSBharata B Rao } 6470da6f3feSBharata B Rao 6480da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "timebase-frequency", tbfreq))); 6490da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "clock-frequency", cpufreq))); 650fd5da5c4SThomas Huth _FDT((fdt_setprop_cell(fdt, offset, "slb-size", env->slb_nr))); 6510da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,slb-size", env->slb_nr))); 6520da6f3feSBharata B Rao _FDT((fdt_setprop_string(fdt, offset, "status", "okay"))); 6530da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "64-bit", NULL, 0))); 6540da6f3feSBharata B Rao 6550da6f3feSBharata B Rao if (env->spr_cb[SPR_PURR].oea_read) { 6560da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,purr", NULL, 0))); 6570da6f3feSBharata B Rao } 6580da6f3feSBharata B Rao 6590da6f3feSBharata B Rao if (env->mmu_model & POWERPC_MMU_1TSEG) { 6600da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,processor-segment-sizes", 6610da6f3feSBharata B Rao segs, sizeof(segs)))); 6620da6f3feSBharata B Rao } 6630da6f3feSBharata B Rao 6640da6f3feSBharata B Rao /* Advertise VMX/VSX (vector extensions) if available 6650da6f3feSBharata B Rao * 0 / no property == no vector extensions 6660da6f3feSBharata B Rao * 1 == VMX / Altivec available 6670da6f3feSBharata B Rao * 2 == VSX available */ 6680da6f3feSBharata B Rao if (env->insns_flags & PPC_ALTIVEC) { 6690da6f3feSBharata B Rao uint32_t vmx = (env->insns_flags2 & PPC2_VSX) ? 2 : 1; 6700da6f3feSBharata B Rao 6710da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,vmx", vmx))); 6720da6f3feSBharata B Rao } 6730da6f3feSBharata B Rao 6740da6f3feSBharata B Rao /* Advertise DFP (Decimal Floating Point) if available 6750da6f3feSBharata B Rao * 0 / no property == no DFP 6760da6f3feSBharata B Rao * 1 == DFP available */ 6770da6f3feSBharata B Rao if (env->insns_flags2 & PPC2_DFP) { 6780da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,dfp", 1))); 6790da6f3feSBharata B Rao } 6800da6f3feSBharata B Rao 6810da6f3feSBharata B Rao page_sizes_prop_size = create_page_sizes_prop(env, page_sizes_prop, 6820da6f3feSBharata B Rao sizeof(page_sizes_prop)); 6830da6f3feSBharata B Rao if (page_sizes_prop_size) { 6840da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,segment-page-sizes", 6850da6f3feSBharata B Rao page_sizes_prop, page_sizes_prop_size))); 6860da6f3feSBharata B Rao } 6870da6f3feSBharata B Rao 68890da0d5aSBenjamin Herrenschmidt /* Do the ibm,pa-features property, adjust it for ci-large-pages */ 68990da0d5aSBenjamin Herrenschmidt if (env->mmu_model == POWERPC_MMU_2_06) { 69090da0d5aSBenjamin Herrenschmidt pa_features = pa_features_206; 69190da0d5aSBenjamin Herrenschmidt pa_size = sizeof(pa_features_206); 69290da0d5aSBenjamin Herrenschmidt } else /* env->mmu_model == POWERPC_MMU_2_07 */ { 69390da0d5aSBenjamin Herrenschmidt pa_features = pa_features_207; 69490da0d5aSBenjamin Herrenschmidt pa_size = sizeof(pa_features_207); 69590da0d5aSBenjamin Herrenschmidt } 69690da0d5aSBenjamin Herrenschmidt if (env->ci_large_pages) { 69790da0d5aSBenjamin Herrenschmidt pa_features[3] |= 0x20; 69890da0d5aSBenjamin Herrenschmidt } 69990da0d5aSBenjamin Herrenschmidt _FDT((fdt_setprop(fdt, offset, "ibm,pa-features", pa_features, pa_size))); 70090da0d5aSBenjamin Herrenschmidt 7010da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,chip-id", 70222419c2aSDavid Gibson cs->cpu_index / vcpus_per_socket))); 7030da6f3feSBharata B Rao 7040da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,pft-size", 7050da6f3feSBharata B Rao pft_size_prop, sizeof(pft_size_prop)))); 7060da6f3feSBharata B Rao 7070da6f3feSBharata B Rao _FDT(spapr_fixup_cpu_numa_dt(fdt, offset, cs)); 7080da6f3feSBharata B Rao 7090da6f3feSBharata B Rao _FDT(spapr_fixup_cpu_smt_dt(fdt, offset, cpu, 7100da6f3feSBharata B Rao ppc_get_compat_smt_threads(cpu))); 7110da6f3feSBharata B Rao } 7120da6f3feSBharata B Rao 7130da6f3feSBharata B Rao static void spapr_populate_cpus_dt_node(void *fdt, sPAPRMachineState *spapr) 7140da6f3feSBharata B Rao { 7150da6f3feSBharata B Rao CPUState *cs; 7160da6f3feSBharata B Rao int cpus_offset; 7170da6f3feSBharata B Rao char *nodename; 7180da6f3feSBharata B Rao int smt = kvmppc_smt_threads(); 7190da6f3feSBharata B Rao 7200da6f3feSBharata B Rao cpus_offset = fdt_add_subnode(fdt, 0, "cpus"); 7210da6f3feSBharata B Rao _FDT(cpus_offset); 7220da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, cpus_offset, "#address-cells", 0x1))); 7230da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, cpus_offset, "#size-cells", 0x0))); 7240da6f3feSBharata B Rao 7250da6f3feSBharata B Rao /* 7260da6f3feSBharata B Rao * We walk the CPUs in reverse order to ensure that CPU DT nodes 7270da6f3feSBharata B Rao * created by fdt_add_subnode() end up in the right order in FDT 7280da6f3feSBharata B Rao * for the guest kernel the enumerate the CPUs correctly. 7290da6f3feSBharata B Rao */ 7300da6f3feSBharata B Rao CPU_FOREACH_REVERSE(cs) { 7310da6f3feSBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(cs); 7320da6f3feSBharata B Rao int index = ppc_get_vcpu_dt_id(cpu); 7330da6f3feSBharata B Rao DeviceClass *dc = DEVICE_GET_CLASS(cs); 7340da6f3feSBharata B Rao int offset; 7350da6f3feSBharata B Rao 7360da6f3feSBharata B Rao if ((index % smt) != 0) { 7370da6f3feSBharata B Rao continue; 7380da6f3feSBharata B Rao } 7390da6f3feSBharata B Rao 7400da6f3feSBharata B Rao nodename = g_strdup_printf("%s@%x", dc->fw_name, index); 7410da6f3feSBharata B Rao offset = fdt_add_subnode(fdt, cpus_offset, nodename); 7420da6f3feSBharata B Rao g_free(nodename); 7430da6f3feSBharata B Rao _FDT(offset); 7440da6f3feSBharata B Rao spapr_populate_cpu_dt(cs, fdt, offset, spapr); 7450da6f3feSBharata B Rao } 7460da6f3feSBharata B Rao 7470da6f3feSBharata B Rao } 7480da6f3feSBharata B Rao 74903d196b7SBharata B Rao /* 75003d196b7SBharata B Rao * Adds ibm,dynamic-reconfiguration-memory node. 75103d196b7SBharata B Rao * Refer to docs/specs/ppc-spapr-hotplug.txt for the documentation 75203d196b7SBharata B Rao * of this device tree node. 75303d196b7SBharata B Rao */ 75403d196b7SBharata B Rao static int spapr_populate_drconf_memory(sPAPRMachineState *spapr, void *fdt) 75503d196b7SBharata B Rao { 75603d196b7SBharata B Rao MachineState *machine = MACHINE(spapr); 75703d196b7SBharata B Rao int ret, i, offset; 75803d196b7SBharata B Rao uint64_t lmb_size = SPAPR_MEMORY_BLOCK_SIZE; 75903d196b7SBharata B Rao uint32_t prop_lmb_size[] = {0, cpu_to_be32(lmb_size)}; 760e8f986fcSBharata B Rao uint32_t nr_lmbs = (machine->maxram_size - machine->ram_size)/lmb_size; 76103d196b7SBharata B Rao uint32_t *int_buf, *cur_index, buf_len; 7626663864eSBharata B Rao int nr_nodes = nb_numa_nodes ? nb_numa_nodes : 1; 76303d196b7SBharata B Rao 764ef001f06SThomas Huth /* 765ef001f06SThomas Huth * Allocate enough buffer size to fit in ibm,dynamic-memory 766ef001f06SThomas Huth * or ibm,associativity-lookup-arrays 767ef001f06SThomas Huth */ 768ef001f06SThomas Huth buf_len = MAX(nr_lmbs * SPAPR_DR_LMB_LIST_ENTRY_SIZE + 1, nr_nodes * 4 + 2) 769ef001f06SThomas Huth * sizeof(uint32_t); 77003d196b7SBharata B Rao cur_index = int_buf = g_malloc0(buf_len); 77103d196b7SBharata B Rao 77203d196b7SBharata B Rao offset = fdt_add_subnode(fdt, 0, "ibm,dynamic-reconfiguration-memory"); 77303d196b7SBharata B Rao 77403d196b7SBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,lmb-size", prop_lmb_size, 77503d196b7SBharata B Rao sizeof(prop_lmb_size)); 77603d196b7SBharata B Rao if (ret < 0) { 77703d196b7SBharata B Rao goto out; 77803d196b7SBharata B Rao } 77903d196b7SBharata B Rao 78003d196b7SBharata B Rao ret = fdt_setprop_cell(fdt, offset, "ibm,memory-flags-mask", 0xff); 78103d196b7SBharata B Rao if (ret < 0) { 78203d196b7SBharata B Rao goto out; 78303d196b7SBharata B Rao } 78403d196b7SBharata B Rao 78503d196b7SBharata B Rao ret = fdt_setprop_cell(fdt, offset, "ibm,memory-preservation-time", 0x0); 78603d196b7SBharata B Rao if (ret < 0) { 78703d196b7SBharata B Rao goto out; 78803d196b7SBharata B Rao } 78903d196b7SBharata B Rao 79003d196b7SBharata B Rao /* ibm,dynamic-memory */ 79103d196b7SBharata B Rao int_buf[0] = cpu_to_be32(nr_lmbs); 79203d196b7SBharata B Rao cur_index++; 79303d196b7SBharata B Rao for (i = 0; i < nr_lmbs; i++) { 79403d196b7SBharata B Rao sPAPRDRConnector *drc; 79503d196b7SBharata B Rao sPAPRDRConnectorClass *drck; 796e8f986fcSBharata B Rao uint64_t addr = i * lmb_size + spapr->hotplug_memory.base;; 79703d196b7SBharata B Rao uint32_t *dynamic_memory = cur_index; 79803d196b7SBharata B Rao 79903d196b7SBharata B Rao drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_LMB, 80003d196b7SBharata B Rao addr/lmb_size); 80103d196b7SBharata B Rao g_assert(drc); 80203d196b7SBharata B Rao drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 80303d196b7SBharata B Rao 80403d196b7SBharata B Rao dynamic_memory[0] = cpu_to_be32(addr >> 32); 80503d196b7SBharata B Rao dynamic_memory[1] = cpu_to_be32(addr & 0xffffffff); 80603d196b7SBharata B Rao dynamic_memory[2] = cpu_to_be32(drck->get_index(drc)); 80703d196b7SBharata B Rao dynamic_memory[3] = cpu_to_be32(0); /* reserved */ 80803d196b7SBharata B Rao dynamic_memory[4] = cpu_to_be32(numa_get_node(addr, NULL)); 80903d196b7SBharata B Rao if (addr < machine->ram_size || 81003d196b7SBharata B Rao memory_region_present(get_system_memory(), addr)) { 81103d196b7SBharata B Rao dynamic_memory[5] = cpu_to_be32(SPAPR_LMB_FLAGS_ASSIGNED); 81203d196b7SBharata B Rao } else { 81303d196b7SBharata B Rao dynamic_memory[5] = cpu_to_be32(0); 81403d196b7SBharata B Rao } 81503d196b7SBharata B Rao 81603d196b7SBharata B Rao cur_index += SPAPR_DR_LMB_LIST_ENTRY_SIZE; 81703d196b7SBharata B Rao } 81803d196b7SBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,dynamic-memory", int_buf, buf_len); 81903d196b7SBharata B Rao if (ret < 0) { 82003d196b7SBharata B Rao goto out; 82103d196b7SBharata B Rao } 82203d196b7SBharata B Rao 82303d196b7SBharata B Rao /* ibm,associativity-lookup-arrays */ 82403d196b7SBharata B Rao cur_index = int_buf; 8256663864eSBharata B Rao int_buf[0] = cpu_to_be32(nr_nodes); 82603d196b7SBharata B Rao int_buf[1] = cpu_to_be32(4); /* Number of entries per associativity list */ 82703d196b7SBharata B Rao cur_index += 2; 8286663864eSBharata B Rao for (i = 0; i < nr_nodes; i++) { 82903d196b7SBharata B Rao uint32_t associativity[] = { 83003d196b7SBharata B Rao cpu_to_be32(0x0), 83103d196b7SBharata B Rao cpu_to_be32(0x0), 83203d196b7SBharata B Rao cpu_to_be32(0x0), 83303d196b7SBharata B Rao cpu_to_be32(i) 83403d196b7SBharata B Rao }; 83503d196b7SBharata B Rao memcpy(cur_index, associativity, sizeof(associativity)); 83603d196b7SBharata B Rao cur_index += 4; 83703d196b7SBharata B Rao } 83803d196b7SBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,associativity-lookup-arrays", int_buf, 83903d196b7SBharata B Rao (cur_index - int_buf) * sizeof(uint32_t)); 84003d196b7SBharata B Rao out: 84103d196b7SBharata B Rao g_free(int_buf); 84203d196b7SBharata B Rao return ret; 84303d196b7SBharata B Rao } 84403d196b7SBharata B Rao 84503d196b7SBharata B Rao int spapr_h_cas_compose_response(sPAPRMachineState *spapr, 84603d196b7SBharata B Rao target_ulong addr, target_ulong size, 84703d196b7SBharata B Rao bool cpu_update, bool memory_update) 84803d196b7SBharata B Rao { 84903d196b7SBharata B Rao void *fdt, *fdt_skel; 85003d196b7SBharata B Rao sPAPRDeviceTreeUpdateHeader hdr = { .version_id = 1 }; 85103d196b7SBharata B Rao sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(qdev_get_machine()); 85203d196b7SBharata B Rao 85303d196b7SBharata B Rao size -= sizeof(hdr); 85403d196b7SBharata B Rao 85503d196b7SBharata B Rao /* Create sceleton */ 85603d196b7SBharata B Rao fdt_skel = g_malloc0(size); 85703d196b7SBharata B Rao _FDT((fdt_create(fdt_skel, size))); 85803d196b7SBharata B Rao _FDT((fdt_begin_node(fdt_skel, ""))); 85903d196b7SBharata B Rao _FDT((fdt_end_node(fdt_skel))); 86003d196b7SBharata B Rao _FDT((fdt_finish(fdt_skel))); 86103d196b7SBharata B Rao fdt = g_malloc0(size); 86203d196b7SBharata B Rao _FDT((fdt_open_into(fdt_skel, fdt, size))); 86303d196b7SBharata B Rao g_free(fdt_skel); 86403d196b7SBharata B Rao 86503d196b7SBharata B Rao /* Fixup cpu nodes */ 86603d196b7SBharata B Rao if (cpu_update) { 86703d196b7SBharata B Rao _FDT((spapr_fixup_cpu_dt(fdt, spapr))); 86803d196b7SBharata B Rao } 86903d196b7SBharata B Rao 87003d196b7SBharata B Rao /* Generate memory nodes or ibm,dynamic-reconfiguration-memory node */ 87103d196b7SBharata B Rao if (memory_update && smc->dr_lmb_enabled) { 87203d196b7SBharata B Rao _FDT((spapr_populate_drconf_memory(spapr, fdt))); 87303d196b7SBharata B Rao } 87403d196b7SBharata B Rao 87503d196b7SBharata B Rao /* Pack resulting tree */ 87603d196b7SBharata B Rao _FDT((fdt_pack(fdt))); 87703d196b7SBharata B Rao 87803d196b7SBharata B Rao if (fdt_totalsize(fdt) + sizeof(hdr) > size) { 87903d196b7SBharata B Rao trace_spapr_cas_failed(size); 88003d196b7SBharata B Rao return -1; 88103d196b7SBharata B Rao } 88203d196b7SBharata B Rao 88303d196b7SBharata B Rao cpu_physical_memory_write(addr, &hdr, sizeof(hdr)); 88403d196b7SBharata B Rao cpu_physical_memory_write(addr + sizeof(hdr), fdt, fdt_totalsize(fdt)); 88503d196b7SBharata B Rao trace_spapr_cas_continue(fdt_totalsize(fdt) + sizeof(hdr)); 88603d196b7SBharata B Rao g_free(fdt); 88703d196b7SBharata B Rao 88803d196b7SBharata B Rao return 0; 88903d196b7SBharata B Rao } 89003d196b7SBharata B Rao 89128e02042SDavid Gibson static void spapr_finalize_fdt(sPAPRMachineState *spapr, 89253018216SPaolo Bonzini hwaddr fdt_addr, 89353018216SPaolo Bonzini hwaddr rtas_addr, 89453018216SPaolo Bonzini hwaddr rtas_size) 89553018216SPaolo Bonzini { 8965b2128d2SAlexander Graf MachineState *machine = MACHINE(qdev_get_machine()); 897c20d332aSBharata B Rao sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(machine); 8985b2128d2SAlexander Graf const char *boot_device = machine->boot_order; 89971461b0fSAlexey Kardashevskiy int ret, i; 90071461b0fSAlexey Kardashevskiy size_t cb = 0; 90171461b0fSAlexey Kardashevskiy char *bootlist; 90253018216SPaolo Bonzini void *fdt; 90353018216SPaolo Bonzini sPAPRPHBState *phb; 90453018216SPaolo Bonzini 90553018216SPaolo Bonzini fdt = g_malloc(FDT_MAX_SIZE); 90653018216SPaolo Bonzini 90753018216SPaolo Bonzini /* open out the base tree into a temp buffer for the final tweaks */ 90853018216SPaolo Bonzini _FDT((fdt_open_into(spapr->fdt_skel, fdt, FDT_MAX_SIZE))); 90953018216SPaolo Bonzini 910e8f986fcSBharata B Rao ret = spapr_populate_memory(spapr, fdt); 911e8f986fcSBharata B Rao if (ret < 0) { 912e8f986fcSBharata B Rao fprintf(stderr, "couldn't setup memory nodes in fdt\n"); 913e8f986fcSBharata B Rao exit(1); 91453018216SPaolo Bonzini } 91553018216SPaolo Bonzini 91653018216SPaolo Bonzini ret = spapr_populate_vdevice(spapr->vio_bus, fdt); 91753018216SPaolo Bonzini if (ret < 0) { 91853018216SPaolo Bonzini fprintf(stderr, "couldn't setup vio devices in fdt\n"); 91953018216SPaolo Bonzini exit(1); 92053018216SPaolo Bonzini } 92153018216SPaolo Bonzini 9224d9392beSThomas Huth if (object_resolve_path_type("", TYPE_SPAPR_RNG, NULL)) { 9234d9392beSThomas Huth ret = spapr_rng_populate_dt(fdt); 9244d9392beSThomas Huth if (ret < 0) { 9254d9392beSThomas Huth fprintf(stderr, "could not set up rng device in the fdt\n"); 9264d9392beSThomas Huth exit(1); 9274d9392beSThomas Huth } 9284d9392beSThomas Huth } 9294d9392beSThomas Huth 93053018216SPaolo Bonzini QLIST_FOREACH(phb, &spapr->phbs, list) { 93153018216SPaolo Bonzini ret = spapr_populate_pci_dt(phb, PHANDLE_XICP, fdt); 93253018216SPaolo Bonzini } 93353018216SPaolo Bonzini 93453018216SPaolo Bonzini if (ret < 0) { 93553018216SPaolo Bonzini fprintf(stderr, "couldn't setup PCI devices in fdt\n"); 93653018216SPaolo Bonzini exit(1); 93753018216SPaolo Bonzini } 93853018216SPaolo Bonzini 93953018216SPaolo Bonzini /* RTAS */ 94053018216SPaolo Bonzini ret = spapr_rtas_device_tree_setup(fdt, rtas_addr, rtas_size); 94153018216SPaolo Bonzini if (ret < 0) { 94253018216SPaolo Bonzini fprintf(stderr, "Couldn't set up RTAS device tree properties\n"); 94353018216SPaolo Bonzini } 94453018216SPaolo Bonzini 9450da6f3feSBharata B Rao /* cpus */ 9460da6f3feSBharata B Rao spapr_populate_cpus_dt_node(fdt, spapr); 94753018216SPaolo Bonzini 94871461b0fSAlexey Kardashevskiy bootlist = get_boot_devices_list(&cb, true); 94971461b0fSAlexey Kardashevskiy if (cb && bootlist) { 95071461b0fSAlexey Kardashevskiy int offset = fdt_path_offset(fdt, "/chosen"); 95171461b0fSAlexey Kardashevskiy if (offset < 0) { 95271461b0fSAlexey Kardashevskiy exit(1); 95371461b0fSAlexey Kardashevskiy } 95471461b0fSAlexey Kardashevskiy for (i = 0; i < cb; i++) { 95571461b0fSAlexey Kardashevskiy if (bootlist[i] == '\n') { 95671461b0fSAlexey Kardashevskiy bootlist[i] = ' '; 95771461b0fSAlexey Kardashevskiy } 95871461b0fSAlexey Kardashevskiy 95971461b0fSAlexey Kardashevskiy } 96071461b0fSAlexey Kardashevskiy ret = fdt_setprop_string(fdt, offset, "qemu,boot-list", bootlist); 96171461b0fSAlexey Kardashevskiy } 96271461b0fSAlexey Kardashevskiy 9635b2128d2SAlexander Graf if (boot_device && strlen(boot_device)) { 9645b2128d2SAlexander Graf int offset = fdt_path_offset(fdt, "/chosen"); 9655b2128d2SAlexander Graf 9665b2128d2SAlexander Graf if (offset < 0) { 9675b2128d2SAlexander Graf exit(1); 9685b2128d2SAlexander Graf } 9695b2128d2SAlexander Graf fdt_setprop_string(fdt, offset, "qemu,boot-device", boot_device); 9705b2128d2SAlexander Graf } 9715b2128d2SAlexander Graf 97253018216SPaolo Bonzini if (!spapr->has_graphics) { 97353018216SPaolo Bonzini spapr_populate_chosen_stdout(fdt, spapr->vio_bus); 97453018216SPaolo Bonzini } 97553018216SPaolo Bonzini 976c20d332aSBharata B Rao if (smc->dr_lmb_enabled) { 977c20d332aSBharata B Rao _FDT(spapr_drc_populate_dt(fdt, 0, NULL, SPAPR_DR_CONNECTOR_TYPE_LMB)); 978c20d332aSBharata B Rao } 979c20d332aSBharata B Rao 98053018216SPaolo Bonzini _FDT((fdt_pack(fdt))); 98153018216SPaolo Bonzini 98253018216SPaolo Bonzini if (fdt_totalsize(fdt) > FDT_MAX_SIZE) { 983730fce59SThomas Huth error_report("FDT too big ! 0x%x bytes (max is 0x%x)", 98453018216SPaolo Bonzini fdt_totalsize(fdt), FDT_MAX_SIZE); 98553018216SPaolo Bonzini exit(1); 98653018216SPaolo Bonzini } 98753018216SPaolo Bonzini 988ad440b4aSAndrew Jones qemu_fdt_dumpdtb(fdt, fdt_totalsize(fdt)); 98953018216SPaolo Bonzini cpu_physical_memory_write(fdt_addr, fdt, fdt_totalsize(fdt)); 99053018216SPaolo Bonzini 991a21a7a70SGonglei g_free(bootlist); 99253018216SPaolo Bonzini g_free(fdt); 99353018216SPaolo Bonzini } 99453018216SPaolo Bonzini 99553018216SPaolo Bonzini static uint64_t translate_kernel_address(void *opaque, uint64_t addr) 99653018216SPaolo Bonzini { 99753018216SPaolo Bonzini return (addr & 0x0fffffff) + KERNEL_LOAD_ADDR; 99853018216SPaolo Bonzini } 99953018216SPaolo Bonzini 100053018216SPaolo Bonzini static void emulate_spapr_hypercall(PowerPCCPU *cpu) 100153018216SPaolo Bonzini { 100253018216SPaolo Bonzini CPUPPCState *env = &cpu->env; 100353018216SPaolo Bonzini 100453018216SPaolo Bonzini if (msr_pr) { 100553018216SPaolo Bonzini hcall_dprintf("Hypercall made with MSR[PR]=1\n"); 100653018216SPaolo Bonzini env->gpr[3] = H_PRIVILEGE; 100753018216SPaolo Bonzini } else { 100853018216SPaolo Bonzini env->gpr[3] = spapr_hypercall(cpu, env->gpr[3], &env->gpr[4]); 100953018216SPaolo Bonzini } 101053018216SPaolo Bonzini } 101153018216SPaolo Bonzini 1012e6b8fd24SSamuel Mendoza-Jonas #define HPTE(_table, _i) (void *)(((uint64_t *)(_table)) + ((_i) * 2)) 1013e6b8fd24SSamuel Mendoza-Jonas #define HPTE_VALID(_hpte) (tswap64(*((uint64_t *)(_hpte))) & HPTE64_V_VALID) 1014e6b8fd24SSamuel Mendoza-Jonas #define HPTE_DIRTY(_hpte) (tswap64(*((uint64_t *)(_hpte))) & HPTE64_V_HPTE_DIRTY) 1015e6b8fd24SSamuel Mendoza-Jonas #define CLEAN_HPTE(_hpte) ((*(uint64_t *)(_hpte)) &= tswap64(~HPTE64_V_HPTE_DIRTY)) 1016e6b8fd24SSamuel Mendoza-Jonas #define DIRTY_HPTE(_hpte) ((*(uint64_t *)(_hpte)) |= tswap64(HPTE64_V_HPTE_DIRTY)) 1017e6b8fd24SSamuel Mendoza-Jonas 1018b817772aSBharata B Rao static void spapr_alloc_htab(sPAPRMachineState *spapr) 101953018216SPaolo Bonzini { 102053018216SPaolo Bonzini long shift; 1021e6b8fd24SSamuel Mendoza-Jonas int index; 102253018216SPaolo Bonzini 102353018216SPaolo Bonzini /* allocate hash page table. For now we always make this 16mb, 102453018216SPaolo Bonzini * later we should probably make it scale to the size of guest 102553018216SPaolo Bonzini * RAM */ 102653018216SPaolo Bonzini 102753018216SPaolo Bonzini shift = kvmppc_reset_htab(spapr->htab_shift); 1028b41d320fSBharata B Rao if (shift < 0) { 1029b41d320fSBharata B Rao /* 1030b41d320fSBharata B Rao * For HV KVM, host kernel will return -ENOMEM when requested 1031b41d320fSBharata B Rao * HTAB size can't be allocated. 1032b41d320fSBharata B Rao */ 1033b41d320fSBharata B Rao error_setg(&error_abort, "Failed to allocate HTAB of requested size, try with smaller maxmem"); 1034b41d320fSBharata B Rao } else if (shift > 0) { 1035b41d320fSBharata B Rao /* 1036b41d320fSBharata B Rao * Kernel handles htab, we don't need to allocate one 1037b41d320fSBharata B Rao * 1038b41d320fSBharata B Rao * Older kernels can fall back to lower HTAB shift values, 1039b41d320fSBharata B Rao * but we don't allow booting of such guests. 1040b41d320fSBharata B Rao */ 10417735fedaSBharata B Rao if (shift != spapr->htab_shift) { 10427735fedaSBharata B Rao error_setg(&error_abort, "Failed to allocate HTAB of requested size, try with smaller maxmem"); 10437735fedaSBharata B Rao } 10447735fedaSBharata B Rao 104553018216SPaolo Bonzini spapr->htab_shift = shift; 10467c43bca0SAneesh Kumar K.V kvmppc_kern_htab = true; 1047b817772aSBharata B Rao } else { 1048b817772aSBharata B Rao /* Allocate htab */ 1049b817772aSBharata B Rao spapr->htab = qemu_memalign(HTAB_SIZE(spapr), HTAB_SIZE(spapr)); 105001a57972SSamuel Mendoza-Jonas 1051b817772aSBharata B Rao /* And clear it */ 1052b817772aSBharata B Rao memset(spapr->htab, 0, HTAB_SIZE(spapr)); 1053b817772aSBharata B Rao 1054b817772aSBharata B Rao for (index = 0; index < HTAB_SIZE(spapr) / HASH_PTE_SIZE_64; index++) { 1055b817772aSBharata B Rao DIRTY_HPTE(HPTE(spapr->htab, index)); 1056b817772aSBharata B Rao } 1057b817772aSBharata B Rao } 1058b817772aSBharata B Rao } 1059b817772aSBharata B Rao 1060b817772aSBharata B Rao /* 1061b817772aSBharata B Rao * Clear HTAB entries during reset. 1062b817772aSBharata B Rao * 1063b817772aSBharata B Rao * If host kernel has allocated HTAB, KVM_PPC_ALLOCATE_HTAB ioctl is 1064b817772aSBharata B Rao * used to clear HTAB. Otherwise QEMU-allocated HTAB is cleared manually. 1065b817772aSBharata B Rao */ 1066b817772aSBharata B Rao static void spapr_reset_htab(sPAPRMachineState *spapr) 1067b817772aSBharata B Rao { 1068b817772aSBharata B Rao long shift; 1069b817772aSBharata B Rao int index; 1070b817772aSBharata B Rao 1071b817772aSBharata B Rao shift = kvmppc_reset_htab(spapr->htab_shift); 1072b41d320fSBharata B Rao if (shift < 0) { 1073b41d320fSBharata B Rao error_setg(&error_abort, "Failed to reset HTAB"); 1074b41d320fSBharata B Rao } else if (shift > 0) { 10757735fedaSBharata B Rao if (shift != spapr->htab_shift) { 10767735fedaSBharata B Rao error_setg(&error_abort, "Requested HTAB allocation failed during reset"); 10777735fedaSBharata B Rao } 10787735fedaSBharata B Rao 107901a57972SSamuel Mendoza-Jonas /* Tell readers to update their file descriptor */ 108001a57972SSamuel Mendoza-Jonas if (spapr->htab_fd >= 0) { 108101a57972SSamuel Mendoza-Jonas spapr->htab_fd_stale = true; 108201a57972SSamuel Mendoza-Jonas } 108353018216SPaolo Bonzini } else { 108453018216SPaolo Bonzini memset(spapr->htab, 0, HTAB_SIZE(spapr)); 1085e6b8fd24SSamuel Mendoza-Jonas 1086e6b8fd24SSamuel Mendoza-Jonas for (index = 0; index < HTAB_SIZE(spapr) / HASH_PTE_SIZE_64; index++) { 1087e6b8fd24SSamuel Mendoza-Jonas DIRTY_HPTE(HPTE(spapr->htab, index)); 1088e6b8fd24SSamuel Mendoza-Jonas } 108953018216SPaolo Bonzini } 109053018216SPaolo Bonzini 109153018216SPaolo Bonzini /* Update the RMA size if necessary */ 109253018216SPaolo Bonzini if (spapr->vrma_adjust) { 1093b082d65aSAlexey Kardashevskiy spapr->rma_size = kvmppc_rma_size(spapr_node0_size(), 1094b082d65aSAlexey Kardashevskiy spapr->htab_shift); 109553018216SPaolo Bonzini } 109653018216SPaolo Bonzini } 109753018216SPaolo Bonzini 10989e3f9733SAlexander Graf static int find_unknown_sysbus_device(SysBusDevice *sbdev, void *opaque) 10999e3f9733SAlexander Graf { 11009e3f9733SAlexander Graf bool matched = false; 11019e3f9733SAlexander Graf 11029e3f9733SAlexander Graf if (object_dynamic_cast(OBJECT(sbdev), TYPE_SPAPR_PCI_HOST_BRIDGE)) { 11039e3f9733SAlexander Graf matched = true; 11049e3f9733SAlexander Graf } 11059e3f9733SAlexander Graf 11069e3f9733SAlexander Graf if (!matched) { 11079e3f9733SAlexander Graf error_report("Device %s is not supported by this machine yet.", 11089e3f9733SAlexander Graf qdev_fw_name(DEVICE(sbdev))); 11099e3f9733SAlexander Graf exit(1); 11109e3f9733SAlexander Graf } 11119e3f9733SAlexander Graf 11129e3f9733SAlexander Graf return 0; 11139e3f9733SAlexander Graf } 11149e3f9733SAlexander Graf 111501a57972SSamuel Mendoza-Jonas /* 111601a57972SSamuel Mendoza-Jonas * A guest reset will cause spapr->htab_fd to become stale if being used. 111701a57972SSamuel Mendoza-Jonas * Reopen the file descriptor to make sure the whole HTAB is properly read. 111801a57972SSamuel Mendoza-Jonas */ 111928e02042SDavid Gibson static int spapr_check_htab_fd(sPAPRMachineState *spapr) 112001a57972SSamuel Mendoza-Jonas { 112101a57972SSamuel Mendoza-Jonas int rc = 0; 112201a57972SSamuel Mendoza-Jonas 112301a57972SSamuel Mendoza-Jonas if (spapr->htab_fd_stale) { 112401a57972SSamuel Mendoza-Jonas close(spapr->htab_fd); 112501a57972SSamuel Mendoza-Jonas spapr->htab_fd = kvmppc_get_htab_fd(false); 112601a57972SSamuel Mendoza-Jonas if (spapr->htab_fd < 0) { 112701a57972SSamuel Mendoza-Jonas error_report("Unable to open fd for reading hash table from KVM: " 112801a57972SSamuel Mendoza-Jonas "%s", strerror(errno)); 112901a57972SSamuel Mendoza-Jonas rc = -1; 113001a57972SSamuel Mendoza-Jonas } 113101a57972SSamuel Mendoza-Jonas spapr->htab_fd_stale = false; 113201a57972SSamuel Mendoza-Jonas } 113301a57972SSamuel Mendoza-Jonas 113401a57972SSamuel Mendoza-Jonas return rc; 113501a57972SSamuel Mendoza-Jonas } 113601a57972SSamuel Mendoza-Jonas 113753018216SPaolo Bonzini static void ppc_spapr_reset(void) 113853018216SPaolo Bonzini { 113928e02042SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(qdev_get_machine()); 1140182735efSAndreas Färber PowerPCCPU *first_ppc_cpu; 1141b7d1f77aSBenjamin Herrenschmidt uint32_t rtas_limit; 1142259186a7SAndreas Färber 11439e3f9733SAlexander Graf /* Check for unknown sysbus devices */ 11449e3f9733SAlexander Graf foreach_dynamic_sysbus_device(find_unknown_sysbus_device, NULL); 11459e3f9733SAlexander Graf 114653018216SPaolo Bonzini /* Reset the hash table & recalc the RMA */ 114753018216SPaolo Bonzini spapr_reset_htab(spapr); 114853018216SPaolo Bonzini 114953018216SPaolo Bonzini qemu_devices_reset(); 115053018216SPaolo Bonzini 1151b7d1f77aSBenjamin Herrenschmidt /* 1152b7d1f77aSBenjamin Herrenschmidt * We place the device tree and RTAS just below either the top of the RMA, 1153b7d1f77aSBenjamin Herrenschmidt * or just below 2GB, whichever is lowere, so that it can be 1154b7d1f77aSBenjamin Herrenschmidt * processed with 32-bit real mode code if necessary 1155b7d1f77aSBenjamin Herrenschmidt */ 1156b7d1f77aSBenjamin Herrenschmidt rtas_limit = MIN(spapr->rma_size, RTAS_MAX_ADDR); 1157b7d1f77aSBenjamin Herrenschmidt spapr->rtas_addr = rtas_limit - RTAS_MAX_SIZE; 1158b7d1f77aSBenjamin Herrenschmidt spapr->fdt_addr = spapr->rtas_addr - FDT_MAX_SIZE; 1159b7d1f77aSBenjamin Herrenschmidt 116053018216SPaolo Bonzini /* Load the fdt */ 116153018216SPaolo Bonzini spapr_finalize_fdt(spapr, spapr->fdt_addr, spapr->rtas_addr, 116253018216SPaolo Bonzini spapr->rtas_size); 116353018216SPaolo Bonzini 1164b7d1f77aSBenjamin Herrenschmidt /* Copy RTAS over */ 1165b7d1f77aSBenjamin Herrenschmidt cpu_physical_memory_write(spapr->rtas_addr, spapr->rtas_blob, 1166b7d1f77aSBenjamin Herrenschmidt spapr->rtas_size); 1167b7d1f77aSBenjamin Herrenschmidt 116853018216SPaolo Bonzini /* Set up the entry state */ 1169182735efSAndreas Färber first_ppc_cpu = POWERPC_CPU(first_cpu); 1170182735efSAndreas Färber first_ppc_cpu->env.gpr[3] = spapr->fdt_addr; 1171182735efSAndreas Färber first_ppc_cpu->env.gpr[5] = 0; 1172182735efSAndreas Färber first_cpu->halted = 0; 11731b718907SDavid Gibson first_ppc_cpu->env.nip = SPAPR_ENTRY_POINT; 117453018216SPaolo Bonzini 117553018216SPaolo Bonzini } 117653018216SPaolo Bonzini 117753018216SPaolo Bonzini static void spapr_cpu_reset(void *opaque) 117853018216SPaolo Bonzini { 117928e02042SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(qdev_get_machine()); 118053018216SPaolo Bonzini PowerPCCPU *cpu = opaque; 1181259186a7SAndreas Färber CPUState *cs = CPU(cpu); 118253018216SPaolo Bonzini CPUPPCState *env = &cpu->env; 118353018216SPaolo Bonzini 1184259186a7SAndreas Färber cpu_reset(cs); 118553018216SPaolo Bonzini 118653018216SPaolo Bonzini /* All CPUs start halted. CPU0 is unhalted from the machine level 118753018216SPaolo Bonzini * reset code and the rest are explicitly started up by the guest 118853018216SPaolo Bonzini * using an RTAS call */ 1189259186a7SAndreas Färber cs->halted = 1; 119053018216SPaolo Bonzini 119153018216SPaolo Bonzini env->spr[SPR_HIOR] = 0; 119253018216SPaolo Bonzini 11934be21d56SDavid Gibson env->external_htab = (uint8_t *)spapr->htab; 11945736245cSAneesh Kumar K.V if (kvm_enabled() && !env->external_htab) { 11955736245cSAneesh Kumar K.V /* 11965736245cSAneesh Kumar K.V * HV KVM, set external_htab to 1 so our ppc_hash64_load_hpte* 11975736245cSAneesh Kumar K.V * functions do the right thing. 11985736245cSAneesh Kumar K.V */ 11995736245cSAneesh Kumar K.V env->external_htab = (void *)1; 12005736245cSAneesh Kumar K.V } 120153018216SPaolo Bonzini env->htab_base = -1; 1202f3c75d42SAneesh Kumar K.V /* 1203f3c75d42SAneesh Kumar K.V * htab_mask is the mask used to normalize hash value to PTEG index. 1204f3c75d42SAneesh Kumar K.V * htab_shift is log2 of hash table size. 1205f3c75d42SAneesh Kumar K.V * We have 8 hpte per group, and each hpte is 16 bytes. 1206f3c75d42SAneesh Kumar K.V * ie have 128 bytes per hpte entry. 1207f3c75d42SAneesh Kumar K.V */ 120828e02042SDavid Gibson env->htab_mask = (1ULL << (spapr->htab_shift - 7)) - 1; 1209ec4936e1SStefan Weil env->spr[SPR_SDR1] = (target_ulong)(uintptr_t)spapr->htab | 121053018216SPaolo Bonzini (spapr->htab_shift - 18); 121153018216SPaolo Bonzini } 121253018216SPaolo Bonzini 121328e02042SDavid Gibson static void spapr_create_nvram(sPAPRMachineState *spapr) 121453018216SPaolo Bonzini { 12152ff3de68SMarkus Armbruster DeviceState *dev = qdev_create(&spapr->vio_bus->bus, "spapr-nvram"); 12163978b863SPaolo Bonzini DriveInfo *dinfo = drive_get(IF_PFLASH, 0, 0); 121753018216SPaolo Bonzini 12183978b863SPaolo Bonzini if (dinfo) { 12194be74634SMarkus Armbruster qdev_prop_set_drive_nofail(dev, "drive", blk_by_legacy_dinfo(dinfo)); 122053018216SPaolo Bonzini } 122153018216SPaolo Bonzini 122253018216SPaolo Bonzini qdev_init_nofail(dev); 122353018216SPaolo Bonzini 122453018216SPaolo Bonzini spapr->nvram = (struct sPAPRNVRAM *)dev; 122553018216SPaolo Bonzini } 122653018216SPaolo Bonzini 122728e02042SDavid Gibson static void spapr_rtc_create(sPAPRMachineState *spapr) 122828df36a1SDavid Gibson { 122928df36a1SDavid Gibson DeviceState *dev = qdev_create(NULL, TYPE_SPAPR_RTC); 123028df36a1SDavid Gibson 123128df36a1SDavid Gibson qdev_init_nofail(dev); 123228df36a1SDavid Gibson spapr->rtc = dev; 123374e5ae28SDavid Gibson 123474e5ae28SDavid Gibson object_property_add_alias(qdev_get_machine(), "rtc-time", 123574e5ae28SDavid Gibson OBJECT(spapr->rtc), "date", NULL); 123628df36a1SDavid Gibson } 123728df36a1SDavid Gibson 123853018216SPaolo Bonzini /* Returns whether we want to use VGA or not */ 123953018216SPaolo Bonzini static int spapr_vga_init(PCIBus *pci_bus) 124053018216SPaolo Bonzini { 124153018216SPaolo Bonzini switch (vga_interface_type) { 124253018216SPaolo Bonzini case VGA_NONE: 12437effdaa3SMark Wu return false; 12447effdaa3SMark Wu case VGA_DEVICE: 12457effdaa3SMark Wu return true; 124653018216SPaolo Bonzini case VGA_STD: 1247b798c190SBenjamin Herrenschmidt case VGA_VIRTIO: 124853018216SPaolo Bonzini return pci_vga_init(pci_bus) != NULL; 124953018216SPaolo Bonzini default: 125053018216SPaolo Bonzini fprintf(stderr, "This vga model is not supported," 125153018216SPaolo Bonzini "currently it only supports -vga std\n"); 125253018216SPaolo Bonzini exit(0); 125353018216SPaolo Bonzini } 125453018216SPaolo Bonzini } 125553018216SPaolo Bonzini 1256880ae7deSDavid Gibson static int spapr_post_load(void *opaque, int version_id) 1257880ae7deSDavid Gibson { 125828e02042SDavid Gibson sPAPRMachineState *spapr = (sPAPRMachineState *)opaque; 1259880ae7deSDavid Gibson int err = 0; 1260880ae7deSDavid Gibson 1261631b22eaSStefan Weil /* In earlier versions, there was no separate qdev for the PAPR 1262880ae7deSDavid Gibson * RTC, so the RTC offset was stored directly in sPAPREnvironment. 1263880ae7deSDavid Gibson * So when migrating from those versions, poke the incoming offset 1264880ae7deSDavid Gibson * value into the RTC device */ 1265880ae7deSDavid Gibson if (version_id < 3) { 1266880ae7deSDavid Gibson err = spapr_rtc_import_offset(spapr->rtc, spapr->rtc_offset); 1267880ae7deSDavid Gibson } 1268880ae7deSDavid Gibson 1269880ae7deSDavid Gibson return err; 1270880ae7deSDavid Gibson } 1271880ae7deSDavid Gibson 1272880ae7deSDavid Gibson static bool version_before_3(void *opaque, int version_id) 1273880ae7deSDavid Gibson { 1274880ae7deSDavid Gibson return version_id < 3; 1275880ae7deSDavid Gibson } 1276880ae7deSDavid Gibson 12774be21d56SDavid Gibson static const VMStateDescription vmstate_spapr = { 12784be21d56SDavid Gibson .name = "spapr", 1279880ae7deSDavid Gibson .version_id = 3, 12804be21d56SDavid Gibson .minimum_version_id = 1, 1281880ae7deSDavid Gibson .post_load = spapr_post_load, 12824be21d56SDavid Gibson .fields = (VMStateField[]) { 1283880ae7deSDavid Gibson /* used to be @next_irq */ 1284880ae7deSDavid Gibson VMSTATE_UNUSED_BUFFER(version_before_3, 0, 4), 12854be21d56SDavid Gibson 12864be21d56SDavid Gibson /* RTC offset */ 128728e02042SDavid Gibson VMSTATE_UINT64_TEST(rtc_offset, sPAPRMachineState, version_before_3), 1288880ae7deSDavid Gibson 128928e02042SDavid Gibson VMSTATE_PPC_TIMEBASE_V(tb, sPAPRMachineState, 2), 12904be21d56SDavid Gibson VMSTATE_END_OF_LIST() 12914be21d56SDavid Gibson }, 12924be21d56SDavid Gibson }; 12934be21d56SDavid Gibson 12944be21d56SDavid Gibson static int htab_save_setup(QEMUFile *f, void *opaque) 12954be21d56SDavid Gibson { 129628e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 12974be21d56SDavid Gibson 12984be21d56SDavid Gibson /* "Iteration" header */ 12994be21d56SDavid Gibson qemu_put_be32(f, spapr->htab_shift); 13004be21d56SDavid Gibson 1301e68cb8b4SAlexey Kardashevskiy if (spapr->htab) { 1302e68cb8b4SAlexey Kardashevskiy spapr->htab_save_index = 0; 1303e68cb8b4SAlexey Kardashevskiy spapr->htab_first_pass = true; 1304e68cb8b4SAlexey Kardashevskiy } else { 1305e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 1306e68cb8b4SAlexey Kardashevskiy 1307e68cb8b4SAlexey Kardashevskiy spapr->htab_fd = kvmppc_get_htab_fd(false); 130801a57972SSamuel Mendoza-Jonas spapr->htab_fd_stale = false; 1309e68cb8b4SAlexey Kardashevskiy if (spapr->htab_fd < 0) { 1310e68cb8b4SAlexey Kardashevskiy fprintf(stderr, "Unable to open fd for reading hash table from KVM: %s\n", 1311e68cb8b4SAlexey Kardashevskiy strerror(errno)); 1312e68cb8b4SAlexey Kardashevskiy return -1; 1313e68cb8b4SAlexey Kardashevskiy } 13144be21d56SDavid Gibson } 13154be21d56SDavid Gibson 1316e68cb8b4SAlexey Kardashevskiy 1317e68cb8b4SAlexey Kardashevskiy return 0; 1318e68cb8b4SAlexey Kardashevskiy } 13194be21d56SDavid Gibson 132028e02042SDavid Gibson static void htab_save_first_pass(QEMUFile *f, sPAPRMachineState *spapr, 13214be21d56SDavid Gibson int64_t max_ns) 13224be21d56SDavid Gibson { 13234be21d56SDavid Gibson int htabslots = HTAB_SIZE(spapr) / HASH_PTE_SIZE_64; 13244be21d56SDavid Gibson int index = spapr->htab_save_index; 1325bc72ad67SAlex Bligh int64_t starttime = qemu_clock_get_ns(QEMU_CLOCK_REALTIME); 13264be21d56SDavid Gibson 13274be21d56SDavid Gibson assert(spapr->htab_first_pass); 13284be21d56SDavid Gibson 13294be21d56SDavid Gibson do { 13304be21d56SDavid Gibson int chunkstart; 13314be21d56SDavid Gibson 13324be21d56SDavid Gibson /* Consume invalid HPTEs */ 13334be21d56SDavid Gibson while ((index < htabslots) 13344be21d56SDavid Gibson && !HPTE_VALID(HPTE(spapr->htab, index))) { 13354be21d56SDavid Gibson index++; 13364be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 13374be21d56SDavid Gibson } 13384be21d56SDavid Gibson 13394be21d56SDavid Gibson /* Consume valid HPTEs */ 13404be21d56SDavid Gibson chunkstart = index; 1341338c25b6SSamuel Mendoza-Jonas while ((index < htabslots) && (index - chunkstart < USHRT_MAX) 13424be21d56SDavid Gibson && HPTE_VALID(HPTE(spapr->htab, index))) { 13434be21d56SDavid Gibson index++; 13444be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 13454be21d56SDavid Gibson } 13464be21d56SDavid Gibson 13474be21d56SDavid Gibson if (index > chunkstart) { 13484be21d56SDavid Gibson int n_valid = index - chunkstart; 13494be21d56SDavid Gibson 13504be21d56SDavid Gibson qemu_put_be32(f, chunkstart); 13514be21d56SDavid Gibson qemu_put_be16(f, n_valid); 13524be21d56SDavid Gibson qemu_put_be16(f, 0); 13534be21d56SDavid Gibson qemu_put_buffer(f, HPTE(spapr->htab, chunkstart), 13544be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_valid); 13554be21d56SDavid Gibson 1356bc72ad67SAlex Bligh if ((qemu_clock_get_ns(QEMU_CLOCK_REALTIME) - starttime) > max_ns) { 13574be21d56SDavid Gibson break; 13584be21d56SDavid Gibson } 13594be21d56SDavid Gibson } 13604be21d56SDavid Gibson } while ((index < htabslots) && !qemu_file_rate_limit(f)); 13614be21d56SDavid Gibson 13624be21d56SDavid Gibson if (index >= htabslots) { 13634be21d56SDavid Gibson assert(index == htabslots); 13644be21d56SDavid Gibson index = 0; 13654be21d56SDavid Gibson spapr->htab_first_pass = false; 13664be21d56SDavid Gibson } 13674be21d56SDavid Gibson spapr->htab_save_index = index; 13684be21d56SDavid Gibson } 13694be21d56SDavid Gibson 137028e02042SDavid Gibson static int htab_save_later_pass(QEMUFile *f, sPAPRMachineState *spapr, 13714be21d56SDavid Gibson int64_t max_ns) 13724be21d56SDavid Gibson { 13734be21d56SDavid Gibson bool final = max_ns < 0; 13744be21d56SDavid Gibson int htabslots = HTAB_SIZE(spapr) / HASH_PTE_SIZE_64; 13754be21d56SDavid Gibson int examined = 0, sent = 0; 13764be21d56SDavid Gibson int index = spapr->htab_save_index; 1377bc72ad67SAlex Bligh int64_t starttime = qemu_clock_get_ns(QEMU_CLOCK_REALTIME); 13784be21d56SDavid Gibson 13794be21d56SDavid Gibson assert(!spapr->htab_first_pass); 13804be21d56SDavid Gibson 13814be21d56SDavid Gibson do { 13824be21d56SDavid Gibson int chunkstart, invalidstart; 13834be21d56SDavid Gibson 13844be21d56SDavid Gibson /* Consume non-dirty HPTEs */ 13854be21d56SDavid Gibson while ((index < htabslots) 13864be21d56SDavid Gibson && !HPTE_DIRTY(HPTE(spapr->htab, index))) { 13874be21d56SDavid Gibson index++; 13884be21d56SDavid Gibson examined++; 13894be21d56SDavid Gibson } 13904be21d56SDavid Gibson 13914be21d56SDavid Gibson chunkstart = index; 13924be21d56SDavid Gibson /* Consume valid dirty HPTEs */ 1393338c25b6SSamuel Mendoza-Jonas while ((index < htabslots) && (index - chunkstart < USHRT_MAX) 13944be21d56SDavid Gibson && HPTE_DIRTY(HPTE(spapr->htab, index)) 13954be21d56SDavid Gibson && HPTE_VALID(HPTE(spapr->htab, index))) { 13964be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 13974be21d56SDavid Gibson index++; 13984be21d56SDavid Gibson examined++; 13994be21d56SDavid Gibson } 14004be21d56SDavid Gibson 14014be21d56SDavid Gibson invalidstart = index; 14024be21d56SDavid Gibson /* Consume invalid dirty HPTEs */ 1403338c25b6SSamuel Mendoza-Jonas while ((index < htabslots) && (index - invalidstart < USHRT_MAX) 14044be21d56SDavid Gibson && HPTE_DIRTY(HPTE(spapr->htab, index)) 14054be21d56SDavid Gibson && !HPTE_VALID(HPTE(spapr->htab, index))) { 14064be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 14074be21d56SDavid Gibson index++; 14084be21d56SDavid Gibson examined++; 14094be21d56SDavid Gibson } 14104be21d56SDavid Gibson 14114be21d56SDavid Gibson if (index > chunkstart) { 14124be21d56SDavid Gibson int n_valid = invalidstart - chunkstart; 14134be21d56SDavid Gibson int n_invalid = index - invalidstart; 14144be21d56SDavid Gibson 14154be21d56SDavid Gibson qemu_put_be32(f, chunkstart); 14164be21d56SDavid Gibson qemu_put_be16(f, n_valid); 14174be21d56SDavid Gibson qemu_put_be16(f, n_invalid); 14184be21d56SDavid Gibson qemu_put_buffer(f, HPTE(spapr->htab, chunkstart), 14194be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_valid); 14204be21d56SDavid Gibson sent += index - chunkstart; 14214be21d56SDavid Gibson 1422bc72ad67SAlex Bligh if (!final && (qemu_clock_get_ns(QEMU_CLOCK_REALTIME) - starttime) > max_ns) { 14234be21d56SDavid Gibson break; 14244be21d56SDavid Gibson } 14254be21d56SDavid Gibson } 14264be21d56SDavid Gibson 14274be21d56SDavid Gibson if (examined >= htabslots) { 14284be21d56SDavid Gibson break; 14294be21d56SDavid Gibson } 14304be21d56SDavid Gibson 14314be21d56SDavid Gibson if (index >= htabslots) { 14324be21d56SDavid Gibson assert(index == htabslots); 14334be21d56SDavid Gibson index = 0; 14344be21d56SDavid Gibson } 14354be21d56SDavid Gibson } while ((examined < htabslots) && (!qemu_file_rate_limit(f) || final)); 14364be21d56SDavid Gibson 14374be21d56SDavid Gibson if (index >= htabslots) { 14384be21d56SDavid Gibson assert(index == htabslots); 14394be21d56SDavid Gibson index = 0; 14404be21d56SDavid Gibson } 14414be21d56SDavid Gibson 14424be21d56SDavid Gibson spapr->htab_save_index = index; 14434be21d56SDavid Gibson 1444e68cb8b4SAlexey Kardashevskiy return (examined >= htabslots) && (sent == 0) ? 1 : 0; 14454be21d56SDavid Gibson } 14464be21d56SDavid Gibson 1447e68cb8b4SAlexey Kardashevskiy #define MAX_ITERATION_NS 5000000 /* 5 ms */ 1448e68cb8b4SAlexey Kardashevskiy #define MAX_KVM_BUF_SIZE 2048 1449e68cb8b4SAlexey Kardashevskiy 14504be21d56SDavid Gibson static int htab_save_iterate(QEMUFile *f, void *opaque) 14514be21d56SDavid Gibson { 145228e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 1453e68cb8b4SAlexey Kardashevskiy int rc = 0; 14544be21d56SDavid Gibson 14554be21d56SDavid Gibson /* Iteration header */ 14564be21d56SDavid Gibson qemu_put_be32(f, 0); 14574be21d56SDavid Gibson 1458e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1459e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 1460e68cb8b4SAlexey Kardashevskiy 146101a57972SSamuel Mendoza-Jonas rc = spapr_check_htab_fd(spapr); 146201a57972SSamuel Mendoza-Jonas if (rc < 0) { 146301a57972SSamuel Mendoza-Jonas return rc; 146401a57972SSamuel Mendoza-Jonas } 146501a57972SSamuel Mendoza-Jonas 1466e68cb8b4SAlexey Kardashevskiy rc = kvmppc_save_htab(f, spapr->htab_fd, 1467e68cb8b4SAlexey Kardashevskiy MAX_KVM_BUF_SIZE, MAX_ITERATION_NS); 1468e68cb8b4SAlexey Kardashevskiy if (rc < 0) { 1469e68cb8b4SAlexey Kardashevskiy return rc; 1470e68cb8b4SAlexey Kardashevskiy } 1471e68cb8b4SAlexey Kardashevskiy } else if (spapr->htab_first_pass) { 14724be21d56SDavid Gibson htab_save_first_pass(f, spapr, MAX_ITERATION_NS); 14734be21d56SDavid Gibson } else { 1474e68cb8b4SAlexey Kardashevskiy rc = htab_save_later_pass(f, spapr, MAX_ITERATION_NS); 14754be21d56SDavid Gibson } 14764be21d56SDavid Gibson 14774be21d56SDavid Gibson /* End marker */ 14784be21d56SDavid Gibson qemu_put_be32(f, 0); 14794be21d56SDavid Gibson qemu_put_be16(f, 0); 14804be21d56SDavid Gibson qemu_put_be16(f, 0); 14814be21d56SDavid Gibson 1482e68cb8b4SAlexey Kardashevskiy return rc; 14834be21d56SDavid Gibson } 14844be21d56SDavid Gibson 14854be21d56SDavid Gibson static int htab_save_complete(QEMUFile *f, void *opaque) 14864be21d56SDavid Gibson { 148728e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 14884be21d56SDavid Gibson 14894be21d56SDavid Gibson /* Iteration header */ 14904be21d56SDavid Gibson qemu_put_be32(f, 0); 14914be21d56SDavid Gibson 1492e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1493e68cb8b4SAlexey Kardashevskiy int rc; 1494e68cb8b4SAlexey Kardashevskiy 1495e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 1496e68cb8b4SAlexey Kardashevskiy 149701a57972SSamuel Mendoza-Jonas rc = spapr_check_htab_fd(spapr); 149801a57972SSamuel Mendoza-Jonas if (rc < 0) { 149901a57972SSamuel Mendoza-Jonas return rc; 150001a57972SSamuel Mendoza-Jonas } 150101a57972SSamuel Mendoza-Jonas 1502e68cb8b4SAlexey Kardashevskiy rc = kvmppc_save_htab(f, spapr->htab_fd, MAX_KVM_BUF_SIZE, -1); 1503e68cb8b4SAlexey Kardashevskiy if (rc < 0) { 1504e68cb8b4SAlexey Kardashevskiy return rc; 1505e68cb8b4SAlexey Kardashevskiy } 1506e68cb8b4SAlexey Kardashevskiy close(spapr->htab_fd); 1507e68cb8b4SAlexey Kardashevskiy spapr->htab_fd = -1; 1508e68cb8b4SAlexey Kardashevskiy } else { 15094be21d56SDavid Gibson htab_save_later_pass(f, spapr, -1); 1510e68cb8b4SAlexey Kardashevskiy } 15114be21d56SDavid Gibson 15124be21d56SDavid Gibson /* End marker */ 15134be21d56SDavid Gibson qemu_put_be32(f, 0); 15144be21d56SDavid Gibson qemu_put_be16(f, 0); 15154be21d56SDavid Gibson qemu_put_be16(f, 0); 15164be21d56SDavid Gibson 15174be21d56SDavid Gibson return 0; 15184be21d56SDavid Gibson } 15194be21d56SDavid Gibson 15204be21d56SDavid Gibson static int htab_load(QEMUFile *f, void *opaque, int version_id) 15214be21d56SDavid Gibson { 152228e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 15234be21d56SDavid Gibson uint32_t section_hdr; 1524e68cb8b4SAlexey Kardashevskiy int fd = -1; 15254be21d56SDavid Gibson 15264be21d56SDavid Gibson if (version_id < 1 || version_id > 1) { 15274be21d56SDavid Gibson fprintf(stderr, "htab_load() bad version\n"); 15284be21d56SDavid Gibson return -EINVAL; 15294be21d56SDavid Gibson } 15304be21d56SDavid Gibson 15314be21d56SDavid Gibson section_hdr = qemu_get_be32(f); 15324be21d56SDavid Gibson 15334be21d56SDavid Gibson if (section_hdr) { 15344be21d56SDavid Gibson /* First section, just the hash shift */ 15354be21d56SDavid Gibson if (spapr->htab_shift != section_hdr) { 1536613e7a76SBharata B Rao error_report("htab_shift mismatch: source %d target %d", 1537613e7a76SBharata B Rao section_hdr, spapr->htab_shift); 15384be21d56SDavid Gibson return -EINVAL; 15394be21d56SDavid Gibson } 15404be21d56SDavid Gibson return 0; 15414be21d56SDavid Gibson } 15424be21d56SDavid Gibson 1543e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1544e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 1545e68cb8b4SAlexey Kardashevskiy 1546e68cb8b4SAlexey Kardashevskiy fd = kvmppc_get_htab_fd(true); 1547e68cb8b4SAlexey Kardashevskiy if (fd < 0) { 1548e68cb8b4SAlexey Kardashevskiy fprintf(stderr, "Unable to open fd to restore KVM hash table: %s\n", 1549e68cb8b4SAlexey Kardashevskiy strerror(errno)); 1550e68cb8b4SAlexey Kardashevskiy } 1551e68cb8b4SAlexey Kardashevskiy } 1552e68cb8b4SAlexey Kardashevskiy 15534be21d56SDavid Gibson while (true) { 15544be21d56SDavid Gibson uint32_t index; 15554be21d56SDavid Gibson uint16_t n_valid, n_invalid; 15564be21d56SDavid Gibson 15574be21d56SDavid Gibson index = qemu_get_be32(f); 15584be21d56SDavid Gibson n_valid = qemu_get_be16(f); 15594be21d56SDavid Gibson n_invalid = qemu_get_be16(f); 15604be21d56SDavid Gibson 15614be21d56SDavid Gibson if ((index == 0) && (n_valid == 0) && (n_invalid == 0)) { 15624be21d56SDavid Gibson /* End of Stream */ 15634be21d56SDavid Gibson break; 15644be21d56SDavid Gibson } 15654be21d56SDavid Gibson 1566e68cb8b4SAlexey Kardashevskiy if ((index + n_valid + n_invalid) > 15674be21d56SDavid Gibson (HTAB_SIZE(spapr) / HASH_PTE_SIZE_64)) { 15684be21d56SDavid Gibson /* Bad index in stream */ 15694be21d56SDavid Gibson fprintf(stderr, "htab_load() bad index %d (%hd+%hd entries) " 1570e68cb8b4SAlexey Kardashevskiy "in htab stream (htab_shift=%d)\n", index, n_valid, n_invalid, 1571e68cb8b4SAlexey Kardashevskiy spapr->htab_shift); 15724be21d56SDavid Gibson return -EINVAL; 15734be21d56SDavid Gibson } 15744be21d56SDavid Gibson 1575e68cb8b4SAlexey Kardashevskiy if (spapr->htab) { 15764be21d56SDavid Gibson if (n_valid) { 15774be21d56SDavid Gibson qemu_get_buffer(f, HPTE(spapr->htab, index), 15784be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_valid); 15794be21d56SDavid Gibson } 15804be21d56SDavid Gibson if (n_invalid) { 15814be21d56SDavid Gibson memset(HPTE(spapr->htab, index + n_valid), 0, 15824be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_invalid); 15834be21d56SDavid Gibson } 1584e68cb8b4SAlexey Kardashevskiy } else { 1585e68cb8b4SAlexey Kardashevskiy int rc; 1586e68cb8b4SAlexey Kardashevskiy 1587e68cb8b4SAlexey Kardashevskiy assert(fd >= 0); 1588e68cb8b4SAlexey Kardashevskiy 1589e68cb8b4SAlexey Kardashevskiy rc = kvmppc_load_htab_chunk(f, fd, index, n_valid, n_invalid); 1590e68cb8b4SAlexey Kardashevskiy if (rc < 0) { 1591e68cb8b4SAlexey Kardashevskiy return rc; 1592e68cb8b4SAlexey Kardashevskiy } 1593e68cb8b4SAlexey Kardashevskiy } 1594e68cb8b4SAlexey Kardashevskiy } 1595e68cb8b4SAlexey Kardashevskiy 1596e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1597e68cb8b4SAlexey Kardashevskiy assert(fd >= 0); 1598e68cb8b4SAlexey Kardashevskiy close(fd); 15994be21d56SDavid Gibson } 16004be21d56SDavid Gibson 16014be21d56SDavid Gibson return 0; 16024be21d56SDavid Gibson } 16034be21d56SDavid Gibson 16044be21d56SDavid Gibson static SaveVMHandlers savevm_htab_handlers = { 16054be21d56SDavid Gibson .save_live_setup = htab_save_setup, 16064be21d56SDavid Gibson .save_live_iterate = htab_save_iterate, 1607a3e06c3dSDr. David Alan Gilbert .save_live_complete_precopy = htab_save_complete, 16084be21d56SDavid Gibson .load_state = htab_load, 16094be21d56SDavid Gibson }; 16104be21d56SDavid Gibson 16115b2128d2SAlexander Graf static void spapr_boot_set(void *opaque, const char *boot_device, 16125b2128d2SAlexander Graf Error **errp) 16135b2128d2SAlexander Graf { 16145b2128d2SAlexander Graf MachineState *machine = MACHINE(qdev_get_machine()); 16155b2128d2SAlexander Graf machine->boot_order = g_strdup(boot_device); 16165b2128d2SAlexander Graf } 16175b2128d2SAlexander Graf 1618bab99ea0SBharata B Rao static void spapr_cpu_init(sPAPRMachineState *spapr, PowerPCCPU *cpu) 1619bab99ea0SBharata B Rao { 1620bab99ea0SBharata B Rao CPUPPCState *env = &cpu->env; 1621bab99ea0SBharata B Rao 1622bab99ea0SBharata B Rao /* Set time-base frequency to 512 MHz */ 1623bab99ea0SBharata B Rao cpu_ppc_tb_init(env, TIMEBASE_FREQ); 1624bab99ea0SBharata B Rao 1625bab99ea0SBharata B Rao /* PAPR always has exception vectors in RAM not ROM. To ensure this, 1626bab99ea0SBharata B Rao * MSR[IP] should never be set. 1627bab99ea0SBharata B Rao */ 1628bab99ea0SBharata B Rao env->msr_mask &= ~(1 << 6); 1629bab99ea0SBharata B Rao 1630bab99ea0SBharata B Rao /* Tell KVM that we're in PAPR mode */ 1631bab99ea0SBharata B Rao if (kvm_enabled()) { 1632bab99ea0SBharata B Rao kvmppc_set_papr(cpu); 1633bab99ea0SBharata B Rao } 1634bab99ea0SBharata B Rao 1635bab99ea0SBharata B Rao if (cpu->max_compat) { 1636bab99ea0SBharata B Rao if (ppc_set_compat(cpu, cpu->max_compat) < 0) { 1637bab99ea0SBharata B Rao exit(1); 1638bab99ea0SBharata B Rao } 1639bab99ea0SBharata B Rao } 1640bab99ea0SBharata B Rao 1641bab99ea0SBharata B Rao xics_cpu_setup(spapr->icp, cpu); 1642bab99ea0SBharata B Rao 1643bab99ea0SBharata B Rao qemu_register_reset(spapr_cpu_reset, cpu); 1644bab99ea0SBharata B Rao } 1645bab99ea0SBharata B Rao 1646224245bfSDavid Gibson /* 1647224245bfSDavid Gibson * Reset routine for LMB DR devices. 1648224245bfSDavid Gibson * 1649224245bfSDavid Gibson * Unlike PCI DR devices, LMB DR devices explicitly register this reset 1650224245bfSDavid Gibson * routine. Reset for PCI DR devices will be handled by PHB reset routine 1651224245bfSDavid Gibson * when it walks all its children devices. LMB devices reset occurs 1652224245bfSDavid Gibson * as part of spapr_ppc_reset(). 1653224245bfSDavid Gibson */ 1654224245bfSDavid Gibson static void spapr_drc_reset(void *opaque) 1655224245bfSDavid Gibson { 1656224245bfSDavid Gibson sPAPRDRConnector *drc = opaque; 1657224245bfSDavid Gibson DeviceState *d = DEVICE(drc); 1658224245bfSDavid Gibson 1659224245bfSDavid Gibson if (d) { 1660224245bfSDavid Gibson device_reset(d); 1661224245bfSDavid Gibson } 1662224245bfSDavid Gibson } 1663224245bfSDavid Gibson 1664224245bfSDavid Gibson static void spapr_create_lmb_dr_connectors(sPAPRMachineState *spapr) 1665224245bfSDavid Gibson { 1666224245bfSDavid Gibson MachineState *machine = MACHINE(spapr); 1667224245bfSDavid Gibson uint64_t lmb_size = SPAPR_MEMORY_BLOCK_SIZE; 1668e8f986fcSBharata B Rao uint32_t nr_lmbs = (machine->maxram_size - machine->ram_size)/lmb_size; 1669224245bfSDavid Gibson int i; 1670224245bfSDavid Gibson 1671224245bfSDavid Gibson for (i = 0; i < nr_lmbs; i++) { 1672224245bfSDavid Gibson sPAPRDRConnector *drc; 1673224245bfSDavid Gibson uint64_t addr; 1674224245bfSDavid Gibson 1675e8f986fcSBharata B Rao addr = i * lmb_size + spapr->hotplug_memory.base; 1676224245bfSDavid Gibson drc = spapr_dr_connector_new(OBJECT(spapr), SPAPR_DR_CONNECTOR_TYPE_LMB, 1677224245bfSDavid Gibson addr/lmb_size); 1678224245bfSDavid Gibson qemu_register_reset(spapr_drc_reset, drc); 1679224245bfSDavid Gibson } 1680224245bfSDavid Gibson } 1681224245bfSDavid Gibson 1682224245bfSDavid Gibson /* 1683224245bfSDavid Gibson * If RAM size, maxmem size and individual node mem sizes aren't aligned 1684224245bfSDavid Gibson * to SPAPR_MEMORY_BLOCK_SIZE(256MB), then refuse to start the guest 1685224245bfSDavid Gibson * since we can't support such unaligned sizes with DRCONF_MEMORY. 1686224245bfSDavid Gibson */ 1687224245bfSDavid Gibson static void spapr_validate_node_memory(MachineState *machine) 1688224245bfSDavid Gibson { 1689224245bfSDavid Gibson int i; 1690224245bfSDavid Gibson 1691224245bfSDavid Gibson if (machine->maxram_size % SPAPR_MEMORY_BLOCK_SIZE || 1692224245bfSDavid Gibson machine->ram_size % SPAPR_MEMORY_BLOCK_SIZE) { 1693224245bfSDavid Gibson error_report("Can't support memory configuration where RAM size " 1694224245bfSDavid Gibson "0x" RAM_ADDR_FMT " or maxmem size " 1695224245bfSDavid Gibson "0x" RAM_ADDR_FMT " isn't aligned to %llu MB", 1696224245bfSDavid Gibson machine->ram_size, machine->maxram_size, 1697224245bfSDavid Gibson SPAPR_MEMORY_BLOCK_SIZE/M_BYTE); 1698224245bfSDavid Gibson exit(EXIT_FAILURE); 1699224245bfSDavid Gibson } 1700224245bfSDavid Gibson 1701224245bfSDavid Gibson for (i = 0; i < nb_numa_nodes; i++) { 1702224245bfSDavid Gibson if (numa_info[i].node_mem % SPAPR_MEMORY_BLOCK_SIZE) { 1703224245bfSDavid Gibson error_report("Can't support memory configuration where memory size" 1704224245bfSDavid Gibson " %" PRIx64 " of node %d isn't aligned to %llu MB", 1705224245bfSDavid Gibson numa_info[i].node_mem, i, 1706224245bfSDavid Gibson SPAPR_MEMORY_BLOCK_SIZE/M_BYTE); 1707224245bfSDavid Gibson exit(EXIT_FAILURE); 1708224245bfSDavid Gibson } 1709224245bfSDavid Gibson } 1710224245bfSDavid Gibson } 1711224245bfSDavid Gibson 171253018216SPaolo Bonzini /* pSeries LPAR / sPAPR hardware init */ 17133ef96221SMarcel Apfelbaum static void ppc_spapr_init(MachineState *machine) 171453018216SPaolo Bonzini { 171528e02042SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(machine); 1716224245bfSDavid Gibson sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(machine); 17173ef96221SMarcel Apfelbaum const char *kernel_filename = machine->kernel_filename; 17183ef96221SMarcel Apfelbaum const char *kernel_cmdline = machine->kernel_cmdline; 17193ef96221SMarcel Apfelbaum const char *initrd_filename = machine->initrd_filename; 172053018216SPaolo Bonzini PowerPCCPU *cpu; 172153018216SPaolo Bonzini PCIHostState *phb; 172253018216SPaolo Bonzini int i; 172353018216SPaolo Bonzini MemoryRegion *sysmem = get_system_memory(); 172453018216SPaolo Bonzini MemoryRegion *ram = g_new(MemoryRegion, 1); 1725658fa66bSAlexey Kardashevskiy MemoryRegion *rma_region; 1726658fa66bSAlexey Kardashevskiy void *rma = NULL; 172753018216SPaolo Bonzini hwaddr rma_alloc_size; 1728b082d65aSAlexey Kardashevskiy hwaddr node0_size = spapr_node0_size(); 172953018216SPaolo Bonzini uint32_t initrd_base = 0; 173053018216SPaolo Bonzini long kernel_size = 0, initrd_size = 0; 1731b7d1f77aSBenjamin Herrenschmidt long load_limit, fw_size; 173216457e7fSBenjamin Herrenschmidt bool kernel_le = false; 173353018216SPaolo Bonzini char *filename; 173453018216SPaolo Bonzini 173553018216SPaolo Bonzini msi_supported = true; 173653018216SPaolo Bonzini 173753018216SPaolo Bonzini QLIST_INIT(&spapr->phbs); 173853018216SPaolo Bonzini 173953018216SPaolo Bonzini cpu_ppc_hypercall = emulate_spapr_hypercall; 174053018216SPaolo Bonzini 174153018216SPaolo Bonzini /* Allocate RMA if necessary */ 1742658fa66bSAlexey Kardashevskiy rma_alloc_size = kvmppc_alloc_rma(&rma); 174353018216SPaolo Bonzini 174453018216SPaolo Bonzini if (rma_alloc_size == -1) { 1745730fce59SThomas Huth error_report("Unable to create RMA"); 174653018216SPaolo Bonzini exit(1); 174753018216SPaolo Bonzini } 174853018216SPaolo Bonzini 1749c4177479SAlexey Kardashevskiy if (rma_alloc_size && (rma_alloc_size < node0_size)) { 175053018216SPaolo Bonzini spapr->rma_size = rma_alloc_size; 175153018216SPaolo Bonzini } else { 1752c4177479SAlexey Kardashevskiy spapr->rma_size = node0_size; 175353018216SPaolo Bonzini 175453018216SPaolo Bonzini /* With KVM, we don't actually know whether KVM supports an 175553018216SPaolo Bonzini * unbounded RMA (PR KVM) or is limited by the hash table size 175653018216SPaolo Bonzini * (HV KVM using VRMA), so we always assume the latter 175753018216SPaolo Bonzini * 175853018216SPaolo Bonzini * In that case, we also limit the initial allocations for RTAS 175953018216SPaolo Bonzini * etc... to 256M since we have no way to know what the VRMA size 176053018216SPaolo Bonzini * is going to be as it depends on the size of the hash table 176153018216SPaolo Bonzini * isn't determined yet. 176253018216SPaolo Bonzini */ 176353018216SPaolo Bonzini if (kvm_enabled()) { 176453018216SPaolo Bonzini spapr->vrma_adjust = 1; 176553018216SPaolo Bonzini spapr->rma_size = MIN(spapr->rma_size, 0x10000000); 176653018216SPaolo Bonzini } 176753018216SPaolo Bonzini } 176853018216SPaolo Bonzini 1769c4177479SAlexey Kardashevskiy if (spapr->rma_size > node0_size) { 1770c4177479SAlexey Kardashevskiy fprintf(stderr, "Error: Numa node 0 has to span the RMA (%#08"HWADDR_PRIx")\n", 1771c4177479SAlexey Kardashevskiy spapr->rma_size); 1772c4177479SAlexey Kardashevskiy exit(1); 1773c4177479SAlexey Kardashevskiy } 1774c4177479SAlexey Kardashevskiy 1775b7d1f77aSBenjamin Herrenschmidt /* Setup a load limit for the ramdisk leaving room for SLOF and FDT */ 1776b7d1f77aSBenjamin Herrenschmidt load_limit = MIN(spapr->rma_size, RTAS_MAX_ADDR) - FW_OVERHEAD; 177753018216SPaolo Bonzini 177853018216SPaolo Bonzini /* We aim for a hash table of size 1/128 the size of RAM. The 177953018216SPaolo Bonzini * normal rule of thumb is 1/64 the size of RAM, but that's much 178053018216SPaolo Bonzini * more than needed for the Linux guests we support. */ 178153018216SPaolo Bonzini spapr->htab_shift = 18; /* Minimum architected size */ 178253018216SPaolo Bonzini while (spapr->htab_shift <= 46) { 1783ce881f77SBharata B Rao if ((1ULL << (spapr->htab_shift + 7)) >= machine->maxram_size) { 178453018216SPaolo Bonzini break; 178553018216SPaolo Bonzini } 178653018216SPaolo Bonzini spapr->htab_shift++; 178753018216SPaolo Bonzini } 1788b817772aSBharata B Rao spapr_alloc_htab(spapr); 178953018216SPaolo Bonzini 17907b565160SDavid Gibson /* Set up Interrupt Controller before we create the VCPUs */ 1791446f16a6SMarcel Apfelbaum spapr->icp = xics_system_init(machine, 17929e734e3dSBharata B Rao DIV_ROUND_UP(max_cpus * kvmppc_smt_threads(), 1793f303f117SGreg Kurz smp_threads), 17947b565160SDavid Gibson XICS_IRQS); 17957b565160SDavid Gibson 1796224245bfSDavid Gibson if (smc->dr_lmb_enabled) { 1797224245bfSDavid Gibson spapr_validate_node_memory(machine); 1798224245bfSDavid Gibson } 1799224245bfSDavid Gibson 180053018216SPaolo Bonzini /* init CPUs */ 180119fb2c36SBharata B Rao if (machine->cpu_model == NULL) { 180219fb2c36SBharata B Rao machine->cpu_model = kvm_enabled() ? "host" : "POWER7"; 180353018216SPaolo Bonzini } 180453018216SPaolo Bonzini for (i = 0; i < smp_cpus; i++) { 180519fb2c36SBharata B Rao cpu = cpu_ppc_init(machine->cpu_model); 180653018216SPaolo Bonzini if (cpu == NULL) { 180753018216SPaolo Bonzini fprintf(stderr, "Unable to find PowerPC CPU definition\n"); 180853018216SPaolo Bonzini exit(1); 180953018216SPaolo Bonzini } 1810bab99ea0SBharata B Rao spapr_cpu_init(spapr, cpu); 181153018216SPaolo Bonzini } 181253018216SPaolo Bonzini 1813026bfd89SDavid Gibson if (kvm_enabled()) { 1814026bfd89SDavid Gibson /* Enable H_LOGICAL_CI_* so SLOF can talk to in-kernel devices */ 1815026bfd89SDavid Gibson kvmppc_enable_logical_ci_hcalls(); 1816ef9971ddSAlexey Kardashevskiy kvmppc_enable_set_mode_hcall(); 1817026bfd89SDavid Gibson } 1818026bfd89SDavid Gibson 181953018216SPaolo Bonzini /* allocate RAM */ 1820f92f5da1SAlexey Kardashevskiy memory_region_allocate_system_memory(ram, NULL, "ppc_spapr.ram", 1821fb164994SDavid Gibson machine->ram_size); 1822f92f5da1SAlexey Kardashevskiy memory_region_add_subregion(sysmem, 0, ram); 182353018216SPaolo Bonzini 1824658fa66bSAlexey Kardashevskiy if (rma_alloc_size && rma) { 1825658fa66bSAlexey Kardashevskiy rma_region = g_new(MemoryRegion, 1); 1826658fa66bSAlexey Kardashevskiy memory_region_init_ram_ptr(rma_region, NULL, "ppc_spapr.rma", 1827658fa66bSAlexey Kardashevskiy rma_alloc_size, rma); 1828658fa66bSAlexey Kardashevskiy vmstate_register_ram_global(rma_region); 1829658fa66bSAlexey Kardashevskiy memory_region_add_subregion(sysmem, 0, rma_region); 1830658fa66bSAlexey Kardashevskiy } 1831658fa66bSAlexey Kardashevskiy 18324a1c9cf0SBharata B Rao /* initialize hotplug memory address space */ 18334a1c9cf0SBharata B Rao if (machine->ram_size < machine->maxram_size) { 18344a1c9cf0SBharata B Rao ram_addr_t hotplug_mem_size = machine->maxram_size - machine->ram_size; 18354a1c9cf0SBharata B Rao 18364a1c9cf0SBharata B Rao if (machine->ram_slots > SPAPR_MAX_RAM_SLOTS) { 183719a35c9eSBharata B Rao error_report("Specified number of memory slots %"PRIu64" exceeds max supported %d\n", 183819a35c9eSBharata B Rao machine->ram_slots, SPAPR_MAX_RAM_SLOTS); 18394a1c9cf0SBharata B Rao exit(EXIT_FAILURE); 18404a1c9cf0SBharata B Rao } 18414a1c9cf0SBharata B Rao 18424a1c9cf0SBharata B Rao spapr->hotplug_memory.base = ROUND_UP(machine->ram_size, 18434a1c9cf0SBharata B Rao SPAPR_HOTPLUG_MEM_ALIGN); 18444a1c9cf0SBharata B Rao memory_region_init(&spapr->hotplug_memory.mr, OBJECT(spapr), 18454a1c9cf0SBharata B Rao "hotplug-memory", hotplug_mem_size); 18464a1c9cf0SBharata B Rao memory_region_add_subregion(sysmem, spapr->hotplug_memory.base, 18474a1c9cf0SBharata B Rao &spapr->hotplug_memory.mr); 18484a1c9cf0SBharata B Rao } 18494a1c9cf0SBharata B Rao 1850224245bfSDavid Gibson if (smc->dr_lmb_enabled) { 1851224245bfSDavid Gibson spapr_create_lmb_dr_connectors(spapr); 1852224245bfSDavid Gibson } 1853224245bfSDavid Gibson 185453018216SPaolo Bonzini filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, "spapr-rtas.bin"); 18554c56440dSStefan Weil if (!filename) { 1856730fce59SThomas Huth error_report("Could not find LPAR rtas '%s'", "spapr-rtas.bin"); 18574c56440dSStefan Weil exit(1); 18584c56440dSStefan Weil } 1859b7d1f77aSBenjamin Herrenschmidt spapr->rtas_size = get_image_size(filename); 1860b7d1f77aSBenjamin Herrenschmidt spapr->rtas_blob = g_malloc(spapr->rtas_size); 1861b7d1f77aSBenjamin Herrenschmidt if (load_image_size(filename, spapr->rtas_blob, spapr->rtas_size) < 0) { 1862730fce59SThomas Huth error_report("Could not load LPAR rtas '%s'", filename); 186353018216SPaolo Bonzini exit(1); 186453018216SPaolo Bonzini } 186553018216SPaolo Bonzini if (spapr->rtas_size > RTAS_MAX_SIZE) { 1866730fce59SThomas Huth error_report("RTAS too big ! 0x%zx bytes (max is 0x%x)", 18672f285bddSPeter Maydell (size_t)spapr->rtas_size, RTAS_MAX_SIZE); 186853018216SPaolo Bonzini exit(1); 186953018216SPaolo Bonzini } 187053018216SPaolo Bonzini g_free(filename); 187153018216SPaolo Bonzini 187253018216SPaolo Bonzini /* Set up EPOW events infrastructure */ 187353018216SPaolo Bonzini spapr_events_init(spapr); 187453018216SPaolo Bonzini 187512f42174SDavid Gibson /* Set up the RTC RTAS interfaces */ 187628df36a1SDavid Gibson spapr_rtc_create(spapr); 187712f42174SDavid Gibson 187853018216SPaolo Bonzini /* Set up VIO bus */ 187953018216SPaolo Bonzini spapr->vio_bus = spapr_vio_bus_init(); 188053018216SPaolo Bonzini 188153018216SPaolo Bonzini for (i = 0; i < MAX_SERIAL_PORTS; i++) { 188253018216SPaolo Bonzini if (serial_hds[i]) { 188353018216SPaolo Bonzini spapr_vty_create(spapr->vio_bus, serial_hds[i]); 188453018216SPaolo Bonzini } 188553018216SPaolo Bonzini } 188653018216SPaolo Bonzini 188753018216SPaolo Bonzini /* We always have at least the nvram device on VIO */ 188853018216SPaolo Bonzini spapr_create_nvram(spapr); 188953018216SPaolo Bonzini 189053018216SPaolo Bonzini /* Set up PCI */ 189153018216SPaolo Bonzini spapr_pci_rtas_init(); 189253018216SPaolo Bonzini 189389dfd6e1SDavid Gibson phb = spapr_create_phb(spapr, 0); 189453018216SPaolo Bonzini 189553018216SPaolo Bonzini for (i = 0; i < nb_nics; i++) { 189653018216SPaolo Bonzini NICInfo *nd = &nd_table[i]; 189753018216SPaolo Bonzini 189853018216SPaolo Bonzini if (!nd->model) { 189953018216SPaolo Bonzini nd->model = g_strdup("ibmveth"); 190053018216SPaolo Bonzini } 190153018216SPaolo Bonzini 190253018216SPaolo Bonzini if (strcmp(nd->model, "ibmveth") == 0) { 190353018216SPaolo Bonzini spapr_vlan_create(spapr->vio_bus, nd); 190453018216SPaolo Bonzini } else { 190529b358f9SDavid Gibson pci_nic_init_nofail(&nd_table[i], phb->bus, nd->model, NULL); 190653018216SPaolo Bonzini } 190753018216SPaolo Bonzini } 190853018216SPaolo Bonzini 190953018216SPaolo Bonzini for (i = 0; i <= drive_get_max_bus(IF_SCSI); i++) { 191053018216SPaolo Bonzini spapr_vscsi_create(spapr->vio_bus); 191153018216SPaolo Bonzini } 191253018216SPaolo Bonzini 191353018216SPaolo Bonzini /* Graphics */ 191453018216SPaolo Bonzini if (spapr_vga_init(phb->bus)) { 191553018216SPaolo Bonzini spapr->has_graphics = true; 1916c6e76503SPaolo Bonzini machine->usb |= defaults_enabled() && !machine->usb_disabled; 191753018216SPaolo Bonzini } 191853018216SPaolo Bonzini 19194ee9ced9SMarcel Apfelbaum if (machine->usb) { 192053018216SPaolo Bonzini pci_create_simple(phb->bus, -1, "pci-ohci"); 1921c86580b8SMarkus Armbruster 192253018216SPaolo Bonzini if (spapr->has_graphics) { 1923c86580b8SMarkus Armbruster USBBus *usb_bus = usb_bus_find(-1); 1924c86580b8SMarkus Armbruster 1925c86580b8SMarkus Armbruster usb_create_simple(usb_bus, "usb-kbd"); 1926c86580b8SMarkus Armbruster usb_create_simple(usb_bus, "usb-mouse"); 192753018216SPaolo Bonzini } 192853018216SPaolo Bonzini } 192953018216SPaolo Bonzini 193053018216SPaolo Bonzini if (spapr->rma_size < (MIN_RMA_SLOF << 20)) { 193153018216SPaolo Bonzini fprintf(stderr, "qemu: pSeries SLOF firmware requires >= " 193253018216SPaolo Bonzini "%ldM guest RMA (Real Mode Area memory)\n", MIN_RMA_SLOF); 193353018216SPaolo Bonzini exit(1); 193453018216SPaolo Bonzini } 193553018216SPaolo Bonzini 193653018216SPaolo Bonzini if (kernel_filename) { 193753018216SPaolo Bonzini uint64_t lowaddr = 0; 193853018216SPaolo Bonzini 193953018216SPaolo Bonzini kernel_size = load_elf(kernel_filename, translate_kernel_address, NULL, 19404ecd4d16SPeter Crosthwaite NULL, &lowaddr, NULL, 1, PPC_ELF_MACHINE, 0); 19413b66da82SAlexey Kardashevskiy if (kernel_size == ELF_LOAD_WRONG_ENDIAN) { 194216457e7fSBenjamin Herrenschmidt kernel_size = load_elf(kernel_filename, 194316457e7fSBenjamin Herrenschmidt translate_kernel_address, NULL, 19444ecd4d16SPeter Crosthwaite NULL, &lowaddr, NULL, 0, PPC_ELF_MACHINE, 0); 194516457e7fSBenjamin Herrenschmidt kernel_le = kernel_size > 0; 194616457e7fSBenjamin Herrenschmidt } 194716457e7fSBenjamin Herrenschmidt if (kernel_size < 0) { 19483b66da82SAlexey Kardashevskiy fprintf(stderr, "qemu: error loading %s: %s\n", 19493b66da82SAlexey Kardashevskiy kernel_filename, load_elf_strerror(kernel_size)); 195053018216SPaolo Bonzini exit(1); 195153018216SPaolo Bonzini } 195253018216SPaolo Bonzini 195353018216SPaolo Bonzini /* load initrd */ 195453018216SPaolo Bonzini if (initrd_filename) { 195553018216SPaolo Bonzini /* Try to locate the initrd in the gap between the kernel 195653018216SPaolo Bonzini * and the firmware. Add a bit of space just in case 195753018216SPaolo Bonzini */ 195853018216SPaolo Bonzini initrd_base = (KERNEL_LOAD_ADDR + kernel_size + 0x1ffff) & ~0xffff; 195953018216SPaolo Bonzini initrd_size = load_image_targphys(initrd_filename, initrd_base, 196053018216SPaolo Bonzini load_limit - initrd_base); 196153018216SPaolo Bonzini if (initrd_size < 0) { 196253018216SPaolo Bonzini fprintf(stderr, "qemu: could not load initial ram disk '%s'\n", 196353018216SPaolo Bonzini initrd_filename); 196453018216SPaolo Bonzini exit(1); 196553018216SPaolo Bonzini } 196653018216SPaolo Bonzini } else { 196753018216SPaolo Bonzini initrd_base = 0; 196853018216SPaolo Bonzini initrd_size = 0; 196953018216SPaolo Bonzini } 197053018216SPaolo Bonzini } 197153018216SPaolo Bonzini 19728e7ea787SAndreas Färber if (bios_name == NULL) { 19738e7ea787SAndreas Färber bios_name = FW_FILE_NAME; 19748e7ea787SAndreas Färber } 19758e7ea787SAndreas Färber filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name); 19764c56440dSStefan Weil if (!filename) { 197768fea5a0SThomas Huth error_report("Could not find LPAR firmware '%s'", bios_name); 19784c56440dSStefan Weil exit(1); 19794c56440dSStefan Weil } 198053018216SPaolo Bonzini fw_size = load_image_targphys(filename, 0, FW_MAX_SIZE); 198168fea5a0SThomas Huth if (fw_size <= 0) { 198268fea5a0SThomas Huth error_report("Could not load LPAR firmware '%s'", filename); 198353018216SPaolo Bonzini exit(1); 198453018216SPaolo Bonzini } 198553018216SPaolo Bonzini g_free(filename); 198653018216SPaolo Bonzini 198728e02042SDavid Gibson /* FIXME: Should register things through the MachineState's qdev 198828e02042SDavid Gibson * interface, this is a legacy from the sPAPREnvironment structure 198928e02042SDavid Gibson * which predated MachineState but had a similar function */ 19904be21d56SDavid Gibson vmstate_register(NULL, 0, &vmstate_spapr, spapr); 19914be21d56SDavid Gibson register_savevm_live(NULL, "spapr/htab", -1, 1, 19924be21d56SDavid Gibson &savevm_htab_handlers, spapr); 19934be21d56SDavid Gibson 199453018216SPaolo Bonzini /* Prepare the device tree */ 19953bbf37f2SAndreas Färber spapr->fdt_skel = spapr_create_fdt_skel(initrd_base, initrd_size, 199616457e7fSBenjamin Herrenschmidt kernel_size, kernel_le, 199731fe14d1SNathan Fontenot kernel_cmdline, 199831fe14d1SNathan Fontenot spapr->check_exception_irq); 199953018216SPaolo Bonzini assert(spapr->fdt_skel != NULL); 20005b2128d2SAlexander Graf 200146503c2bSMichael Roth /* used by RTAS */ 200246503c2bSMichael Roth QTAILQ_INIT(&spapr->ccs_list); 200346503c2bSMichael Roth qemu_register_reset(spapr_ccs_reset_hook, spapr); 200446503c2bSMichael Roth 20055b2128d2SAlexander Graf qemu_register_boot_set(spapr_boot_set, spapr); 200653018216SPaolo Bonzini } 200753018216SPaolo Bonzini 2008135a129aSAneesh Kumar K.V static int spapr_kvm_type(const char *vm_type) 2009135a129aSAneesh Kumar K.V { 2010135a129aSAneesh Kumar K.V if (!vm_type) { 2011135a129aSAneesh Kumar K.V return 0; 2012135a129aSAneesh Kumar K.V } 2013135a129aSAneesh Kumar K.V 2014135a129aSAneesh Kumar K.V if (!strcmp(vm_type, "HV")) { 2015135a129aSAneesh Kumar K.V return 1; 2016135a129aSAneesh Kumar K.V } 2017135a129aSAneesh Kumar K.V 2018135a129aSAneesh Kumar K.V if (!strcmp(vm_type, "PR")) { 2019135a129aSAneesh Kumar K.V return 2; 2020135a129aSAneesh Kumar K.V } 2021135a129aSAneesh Kumar K.V 2022135a129aSAneesh Kumar K.V error_report("Unknown kvm-type specified '%s'", vm_type); 2023135a129aSAneesh Kumar K.V exit(1); 2024135a129aSAneesh Kumar K.V } 2025135a129aSAneesh Kumar K.V 202671461b0fSAlexey Kardashevskiy /* 2027627b84f4SGonglei * Implementation of an interface to adjust firmware path 202871461b0fSAlexey Kardashevskiy * for the bootindex property handling. 202971461b0fSAlexey Kardashevskiy */ 203071461b0fSAlexey Kardashevskiy static char *spapr_get_fw_dev_path(FWPathProvider *p, BusState *bus, 203171461b0fSAlexey Kardashevskiy DeviceState *dev) 203271461b0fSAlexey Kardashevskiy { 203371461b0fSAlexey Kardashevskiy #define CAST(type, obj, name) \ 203471461b0fSAlexey Kardashevskiy ((type *)object_dynamic_cast(OBJECT(obj), (name))) 203571461b0fSAlexey Kardashevskiy SCSIDevice *d = CAST(SCSIDevice, dev, TYPE_SCSI_DEVICE); 203671461b0fSAlexey Kardashevskiy sPAPRPHBState *phb = CAST(sPAPRPHBState, dev, TYPE_SPAPR_PCI_HOST_BRIDGE); 203771461b0fSAlexey Kardashevskiy 203871461b0fSAlexey Kardashevskiy if (d) { 203971461b0fSAlexey Kardashevskiy void *spapr = CAST(void, bus->parent, "spapr-vscsi"); 204071461b0fSAlexey Kardashevskiy VirtIOSCSI *virtio = CAST(VirtIOSCSI, bus->parent, TYPE_VIRTIO_SCSI); 204171461b0fSAlexey Kardashevskiy USBDevice *usb = CAST(USBDevice, bus->parent, TYPE_USB_DEVICE); 204271461b0fSAlexey Kardashevskiy 204371461b0fSAlexey Kardashevskiy if (spapr) { 204471461b0fSAlexey Kardashevskiy /* 204571461b0fSAlexey Kardashevskiy * Replace "channel@0/disk@0,0" with "disk@8000000000000000": 204671461b0fSAlexey Kardashevskiy * We use SRP luns of the form 8000 | (bus << 8) | (id << 5) | lun 204771461b0fSAlexey Kardashevskiy * in the top 16 bits of the 64-bit LUN 204871461b0fSAlexey Kardashevskiy */ 204971461b0fSAlexey Kardashevskiy unsigned id = 0x8000 | (d->id << 8) | d->lun; 205071461b0fSAlexey Kardashevskiy return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev), 205171461b0fSAlexey Kardashevskiy (uint64_t)id << 48); 205271461b0fSAlexey Kardashevskiy } else if (virtio) { 205371461b0fSAlexey Kardashevskiy /* 205471461b0fSAlexey Kardashevskiy * We use SRP luns of the form 01000000 | (target << 8) | lun 205571461b0fSAlexey Kardashevskiy * in the top 32 bits of the 64-bit LUN 205671461b0fSAlexey Kardashevskiy * Note: the quote above is from SLOF and it is wrong, 205771461b0fSAlexey Kardashevskiy * the actual binding is: 205871461b0fSAlexey Kardashevskiy * swap 0100 or 10 << or 20 << ( target lun-id -- srplun ) 205971461b0fSAlexey Kardashevskiy */ 206071461b0fSAlexey Kardashevskiy unsigned id = 0x1000000 | (d->id << 16) | d->lun; 206171461b0fSAlexey Kardashevskiy return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev), 206271461b0fSAlexey Kardashevskiy (uint64_t)id << 32); 206371461b0fSAlexey Kardashevskiy } else if (usb) { 206471461b0fSAlexey Kardashevskiy /* 206571461b0fSAlexey Kardashevskiy * We use SRP luns of the form 01000000 | (usb-port << 16) | lun 206671461b0fSAlexey Kardashevskiy * in the top 32 bits of the 64-bit LUN 206771461b0fSAlexey Kardashevskiy */ 206871461b0fSAlexey Kardashevskiy unsigned usb_port = atoi(usb->port->path); 206971461b0fSAlexey Kardashevskiy unsigned id = 0x1000000 | (usb_port << 16) | d->lun; 207071461b0fSAlexey Kardashevskiy return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev), 207171461b0fSAlexey Kardashevskiy (uint64_t)id << 32); 207271461b0fSAlexey Kardashevskiy } 207371461b0fSAlexey Kardashevskiy } 207471461b0fSAlexey Kardashevskiy 207571461b0fSAlexey Kardashevskiy if (phb) { 207671461b0fSAlexey Kardashevskiy /* Replace "pci" with "pci@800000020000000" */ 207771461b0fSAlexey Kardashevskiy return g_strdup_printf("pci@%"PRIX64, phb->buid); 207871461b0fSAlexey Kardashevskiy } 207971461b0fSAlexey Kardashevskiy 208071461b0fSAlexey Kardashevskiy return NULL; 208171461b0fSAlexey Kardashevskiy } 208271461b0fSAlexey Kardashevskiy 208323825581SEduardo Habkost static char *spapr_get_kvm_type(Object *obj, Error **errp) 208423825581SEduardo Habkost { 208528e02042SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 208623825581SEduardo Habkost 208728e02042SDavid Gibson return g_strdup(spapr->kvm_type); 208823825581SEduardo Habkost } 208923825581SEduardo Habkost 209023825581SEduardo Habkost static void spapr_set_kvm_type(Object *obj, const char *value, Error **errp) 209123825581SEduardo Habkost { 209228e02042SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 209323825581SEduardo Habkost 209428e02042SDavid Gibson g_free(spapr->kvm_type); 209528e02042SDavid Gibson spapr->kvm_type = g_strdup(value); 209623825581SEduardo Habkost } 209723825581SEduardo Habkost 209823825581SEduardo Habkost static void spapr_machine_initfn(Object *obj) 209923825581SEduardo Habkost { 210023825581SEduardo Habkost object_property_add_str(obj, "kvm-type", 210123825581SEduardo Habkost spapr_get_kvm_type, spapr_set_kvm_type, NULL); 210249d2e648SMarcel Apfelbaum object_property_set_description(obj, "kvm-type", 210349d2e648SMarcel Apfelbaum "Specifies the KVM virtualization mode (HV, PR)", 210449d2e648SMarcel Apfelbaum NULL); 210523825581SEduardo Habkost } 210623825581SEduardo Habkost 210734316482SAlexey Kardashevskiy static void ppc_cpu_do_nmi_on_cpu(void *arg) 210834316482SAlexey Kardashevskiy { 210934316482SAlexey Kardashevskiy CPUState *cs = arg; 211034316482SAlexey Kardashevskiy 211134316482SAlexey Kardashevskiy cpu_synchronize_state(cs); 211234316482SAlexey Kardashevskiy ppc_cpu_do_system_reset(cs); 211334316482SAlexey Kardashevskiy } 211434316482SAlexey Kardashevskiy 211534316482SAlexey Kardashevskiy static void spapr_nmi(NMIState *n, int cpu_index, Error **errp) 211634316482SAlexey Kardashevskiy { 211734316482SAlexey Kardashevskiy CPUState *cs; 211834316482SAlexey Kardashevskiy 211934316482SAlexey Kardashevskiy CPU_FOREACH(cs) { 212034316482SAlexey Kardashevskiy async_run_on_cpu(cs, ppc_cpu_do_nmi_on_cpu, cs); 212134316482SAlexey Kardashevskiy } 212234316482SAlexey Kardashevskiy } 212334316482SAlexey Kardashevskiy 2124c20d332aSBharata B Rao static void spapr_add_lmbs(DeviceState *dev, uint64_t addr, uint64_t size, 2125c20d332aSBharata B Rao uint32_t node, Error **errp) 2126c20d332aSBharata B Rao { 2127c20d332aSBharata B Rao sPAPRDRConnector *drc; 2128c20d332aSBharata B Rao sPAPRDRConnectorClass *drck; 2129c20d332aSBharata B Rao uint32_t nr_lmbs = size/SPAPR_MEMORY_BLOCK_SIZE; 2130c20d332aSBharata B Rao int i, fdt_offset, fdt_size; 2131c20d332aSBharata B Rao void *fdt; 2132c20d332aSBharata B Rao 2133c20d332aSBharata B Rao /* 2134c20d332aSBharata B Rao * Check for DRC connectors and send hotplug notification to the 2135c20d332aSBharata B Rao * guest only in case of hotplugged memory. This allows cold plugged 2136c20d332aSBharata B Rao * memory to be specified at boot time. 2137c20d332aSBharata B Rao */ 2138c20d332aSBharata B Rao if (!dev->hotplugged) { 2139c20d332aSBharata B Rao return; 2140c20d332aSBharata B Rao } 2141c20d332aSBharata B Rao 2142c20d332aSBharata B Rao for (i = 0; i < nr_lmbs; i++) { 2143c20d332aSBharata B Rao drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_LMB, 2144c20d332aSBharata B Rao addr/SPAPR_MEMORY_BLOCK_SIZE); 2145c20d332aSBharata B Rao g_assert(drc); 2146c20d332aSBharata B Rao 2147c20d332aSBharata B Rao fdt = create_device_tree(&fdt_size); 2148c20d332aSBharata B Rao fdt_offset = spapr_populate_memory_node(fdt, node, addr, 2149c20d332aSBharata B Rao SPAPR_MEMORY_BLOCK_SIZE); 2150c20d332aSBharata B Rao 2151c20d332aSBharata B Rao drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 2152c20d332aSBharata B Rao drck->attach(drc, dev, fdt, fdt_offset, !dev->hotplugged, errp); 2153c20d332aSBharata B Rao addr += SPAPR_MEMORY_BLOCK_SIZE; 2154c20d332aSBharata B Rao } 21550a417869SBharata B Rao spapr_hotplug_req_add_by_count(SPAPR_DR_CONNECTOR_TYPE_LMB, nr_lmbs); 2156c20d332aSBharata B Rao } 2157c20d332aSBharata B Rao 2158c20d332aSBharata B Rao static void spapr_memory_plug(HotplugHandler *hotplug_dev, DeviceState *dev, 2159c20d332aSBharata B Rao uint32_t node, Error **errp) 2160c20d332aSBharata B Rao { 2161c20d332aSBharata B Rao Error *local_err = NULL; 2162c20d332aSBharata B Rao sPAPRMachineState *ms = SPAPR_MACHINE(hotplug_dev); 2163c20d332aSBharata B Rao PCDIMMDevice *dimm = PC_DIMM(dev); 2164c20d332aSBharata B Rao PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); 2165c20d332aSBharata B Rao MemoryRegion *mr = ddc->get_memory_region(dimm); 2166c20d332aSBharata B Rao uint64_t align = memory_region_get_alignment(mr); 2167c20d332aSBharata B Rao uint64_t size = memory_region_size(mr); 2168c20d332aSBharata B Rao uint64_t addr; 2169c20d332aSBharata B Rao 2170c20d332aSBharata B Rao if (size % SPAPR_MEMORY_BLOCK_SIZE) { 2171c20d332aSBharata B Rao error_setg(&local_err, "Hotplugged memory size must be a multiple of " 2172c20d332aSBharata B Rao "%lld MB", SPAPR_MEMORY_BLOCK_SIZE/M_BYTE); 2173c20d332aSBharata B Rao goto out; 2174c20d332aSBharata B Rao } 2175c20d332aSBharata B Rao 2176d6a9b0b8SMichael S. Tsirkin pc_dimm_memory_plug(dev, &ms->hotplug_memory, mr, align, &local_err); 2177c20d332aSBharata B Rao if (local_err) { 2178c20d332aSBharata B Rao goto out; 2179c20d332aSBharata B Rao } 2180c20d332aSBharata B Rao 2181c20d332aSBharata B Rao addr = object_property_get_int(OBJECT(dimm), PC_DIMM_ADDR_PROP, &local_err); 2182c20d332aSBharata B Rao if (local_err) { 2183c20d332aSBharata B Rao pc_dimm_memory_unplug(dev, &ms->hotplug_memory, mr); 2184c20d332aSBharata B Rao goto out; 2185c20d332aSBharata B Rao } 2186c20d332aSBharata B Rao 2187c20d332aSBharata B Rao spapr_add_lmbs(dev, addr, size, node, &error_abort); 2188c20d332aSBharata B Rao 2189c20d332aSBharata B Rao out: 2190c20d332aSBharata B Rao error_propagate(errp, local_err); 2191c20d332aSBharata B Rao } 2192c20d332aSBharata B Rao 2193c20d332aSBharata B Rao static void spapr_machine_device_plug(HotplugHandler *hotplug_dev, 2194c20d332aSBharata B Rao DeviceState *dev, Error **errp) 2195c20d332aSBharata B Rao { 2196c20d332aSBharata B Rao sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(qdev_get_machine()); 2197c20d332aSBharata B Rao 2198c20d332aSBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { 2199b556854bSBharata B Rao int node; 2200c20d332aSBharata B Rao 2201c20d332aSBharata B Rao if (!smc->dr_lmb_enabled) { 2202c20d332aSBharata B Rao error_setg(errp, "Memory hotplug not supported for this machine"); 2203c20d332aSBharata B Rao return; 2204c20d332aSBharata B Rao } 2205c20d332aSBharata B Rao node = object_property_get_int(OBJECT(dev), PC_DIMM_NODE_PROP, errp); 2206c20d332aSBharata B Rao if (*errp) { 2207c20d332aSBharata B Rao return; 2208c20d332aSBharata B Rao } 2209c20d332aSBharata B Rao 2210b556854bSBharata B Rao /* 2211b556854bSBharata B Rao * Currently PowerPC kernel doesn't allow hot-adding memory to 2212b556854bSBharata B Rao * memory-less node, but instead will silently add the memory 2213b556854bSBharata B Rao * to the first node that has some memory. This causes two 2214b556854bSBharata B Rao * unexpected behaviours for the user. 2215b556854bSBharata B Rao * 2216b556854bSBharata B Rao * - Memory gets hotplugged to a different node than what the user 2217b556854bSBharata B Rao * specified. 2218b556854bSBharata B Rao * - Since pc-dimm subsystem in QEMU still thinks that memory belongs 2219b556854bSBharata B Rao * to memory-less node, a reboot will set things accordingly 2220b556854bSBharata B Rao * and the previously hotplugged memory now ends in the right node. 2221b556854bSBharata B Rao * This appears as if some memory moved from one node to another. 2222b556854bSBharata B Rao * 2223b556854bSBharata B Rao * So until kernel starts supporting memory hotplug to memory-less 2224b556854bSBharata B Rao * nodes, just prevent such attempts upfront in QEMU. 2225b556854bSBharata B Rao */ 2226b556854bSBharata B Rao if (nb_numa_nodes && !numa_info[node].node_mem) { 2227b556854bSBharata B Rao error_setg(errp, "Can't hotplug memory to memory-less node %d", 2228b556854bSBharata B Rao node); 2229b556854bSBharata B Rao return; 2230b556854bSBharata B Rao } 2231b556854bSBharata B Rao 2232c20d332aSBharata B Rao spapr_memory_plug(hotplug_dev, dev, node, errp); 2233c20d332aSBharata B Rao } 2234c20d332aSBharata B Rao } 2235c20d332aSBharata B Rao 2236c20d332aSBharata B Rao static void spapr_machine_device_unplug(HotplugHandler *hotplug_dev, 2237c20d332aSBharata B Rao DeviceState *dev, Error **errp) 2238c20d332aSBharata B Rao { 2239c20d332aSBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { 2240c20d332aSBharata B Rao error_setg(errp, "Memory hot unplug not supported by sPAPR"); 2241c20d332aSBharata B Rao } 2242c20d332aSBharata B Rao } 2243c20d332aSBharata B Rao 2244c20d332aSBharata B Rao static HotplugHandler *spapr_get_hotpug_handler(MachineState *machine, 2245c20d332aSBharata B Rao DeviceState *dev) 2246c20d332aSBharata B Rao { 2247c20d332aSBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { 2248c20d332aSBharata B Rao return HOTPLUG_HANDLER(machine); 2249c20d332aSBharata B Rao } 2250c20d332aSBharata B Rao return NULL; 2251c20d332aSBharata B Rao } 2252c20d332aSBharata B Rao 225320bb648dSDavid Gibson static unsigned spapr_cpu_index_to_socket_id(unsigned cpu_index) 225420bb648dSDavid Gibson { 225520bb648dSDavid Gibson /* Allocate to NUMA nodes on a "socket" basis (not that concept of 225620bb648dSDavid Gibson * socket means much for the paravirtualized PAPR platform) */ 225720bb648dSDavid Gibson return cpu_index / smp_threads / smp_cores; 225820bb648dSDavid Gibson } 225920bb648dSDavid Gibson 226029ee3247SAlexey Kardashevskiy static void spapr_machine_class_init(ObjectClass *oc, void *data) 226153018216SPaolo Bonzini { 226229ee3247SAlexey Kardashevskiy MachineClass *mc = MACHINE_CLASS(oc); 2263224245bfSDavid Gibson sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(oc); 226471461b0fSAlexey Kardashevskiy FWPathProviderClass *fwc = FW_PATH_PROVIDER_CLASS(oc); 226534316482SAlexey Kardashevskiy NMIClass *nc = NMI_CLASS(oc); 2266c20d332aSBharata B Rao HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(oc); 226729ee3247SAlexey Kardashevskiy 2268958db90cSMarcel Apfelbaum mc->init = ppc_spapr_init; 2269958db90cSMarcel Apfelbaum mc->reset = ppc_spapr_reset; 2270958db90cSMarcel Apfelbaum mc->block_default_type = IF_SCSI; 227138b02bd8SAlexey Kardashevskiy mc->max_cpus = MAX_CPUMASK_BITS; 2272958db90cSMarcel Apfelbaum mc->no_parallel = 1; 22735b2128d2SAlexander Graf mc->default_boot_order = ""; 2274a34944feSNikunj A Dadhania mc->default_ram_size = 512 * M_BYTE; 2275958db90cSMarcel Apfelbaum mc->kvm_type = spapr_kvm_type; 22769e3f9733SAlexander Graf mc->has_dynamic_sysbus = true; 2277e4024630SLaurent Vivier mc->pci_allow_0_address = true; 2278c20d332aSBharata B Rao mc->get_hotplug_handler = spapr_get_hotpug_handler; 2279c20d332aSBharata B Rao hc->plug = spapr_machine_device_plug; 2280c20d332aSBharata B Rao hc->unplug = spapr_machine_device_unplug; 228120bb648dSDavid Gibson mc->cpu_index_to_socket_id = spapr_cpu_index_to_socket_id; 228200b4fbe2SMarcel Apfelbaum 2283224245bfSDavid Gibson smc->dr_lmb_enabled = false; 228471461b0fSAlexey Kardashevskiy fwc->get_dev_path = spapr_get_fw_dev_path; 228534316482SAlexey Kardashevskiy nc->nmi_monitor_handler = spapr_nmi; 228653018216SPaolo Bonzini } 228753018216SPaolo Bonzini 228829ee3247SAlexey Kardashevskiy static const TypeInfo spapr_machine_info = { 228929ee3247SAlexey Kardashevskiy .name = TYPE_SPAPR_MACHINE, 229029ee3247SAlexey Kardashevskiy .parent = TYPE_MACHINE, 22914aee7362SDavid Gibson .abstract = true, 22926ca1502eSAlexey Kardashevskiy .instance_size = sizeof(sPAPRMachineState), 229323825581SEduardo Habkost .instance_init = spapr_machine_initfn, 2294183930c0SDavid Gibson .class_size = sizeof(sPAPRMachineClass), 229529ee3247SAlexey Kardashevskiy .class_init = spapr_machine_class_init, 229671461b0fSAlexey Kardashevskiy .interfaces = (InterfaceInfo[]) { 229771461b0fSAlexey Kardashevskiy { TYPE_FW_PATH_PROVIDER }, 229834316482SAlexey Kardashevskiy { TYPE_NMI }, 2299c20d332aSBharata B Rao { TYPE_HOTPLUG_HANDLER }, 230071461b0fSAlexey Kardashevskiy { } 230171461b0fSAlexey Kardashevskiy }, 230229ee3247SAlexey Kardashevskiy }; 230329ee3247SAlexey Kardashevskiy 230480fd50f9SCornelia Huck #define SPAPR_COMPAT_2_4 \ 230580fd50f9SCornelia Huck HW_COMPAT_2_4 230680fd50f9SCornelia Huck 230738ff32c6SEduardo Habkost #define SPAPR_COMPAT_2_3 \ 230880fd50f9SCornelia Huck SPAPR_COMPAT_2_4 \ 23097619c7b0SMichael Roth HW_COMPAT_2_3 \ 23107619c7b0SMichael Roth {\ 23117619c7b0SMichael Roth .driver = "spapr-pci-host-bridge",\ 23127619c7b0SMichael Roth .property = "dynamic-reconfiguration",\ 23137619c7b0SMichael Roth .value = "off",\ 23147619c7b0SMichael Roth }, 231538ff32c6SEduardo Habkost 2316b194df47SAlexey Kardashevskiy #define SPAPR_COMPAT_2_2 \ 231738ff32c6SEduardo Habkost SPAPR_COMPAT_2_3 \ 23184dfd8eaaSEduardo Habkost HW_COMPAT_2_2 \ 2319b194df47SAlexey Kardashevskiy {\ 2320b194df47SAlexey Kardashevskiy .driver = TYPE_SPAPR_PCI_HOST_BRIDGE,\ 2321b194df47SAlexey Kardashevskiy .property = "mem_win_size",\ 2322b194df47SAlexey Kardashevskiy .value = "0x20000000",\ 2323dd754bafSEduardo Habkost }, 2324b194df47SAlexey Kardashevskiy 2325b194df47SAlexey Kardashevskiy #define SPAPR_COMPAT_2_1 \ 23264dfd8eaaSEduardo Habkost SPAPR_COMPAT_2_2 \ 23274dfd8eaaSEduardo Habkost HW_COMPAT_2_1 2328b194df47SAlexey Kardashevskiy 2329d25228e7SJason Wang static void spapr_compat_2_3(Object *obj) 2330d25228e7SJason Wang { 2331ff14e817SDr. David Alan Gilbert savevm_skip_section_footers(); 233213d16814SJuan Quintela global_state_set_optional(); 2333d25228e7SJason Wang } 2334d25228e7SJason Wang 2335b0e966d0SJason Wang static void spapr_compat_2_2(Object *obj) 2336b0e966d0SJason Wang { 2337d25228e7SJason Wang spapr_compat_2_3(obj); 2338b0e966d0SJason Wang } 2339b0e966d0SJason Wang 2340b0e966d0SJason Wang static void spapr_compat_2_1(Object *obj) 2341b0e966d0SJason Wang { 2342b0e966d0SJason Wang spapr_compat_2_2(obj); 2343b0e966d0SJason Wang } 2344b0e966d0SJason Wang 2345d25228e7SJason Wang static void spapr_machine_2_3_instance_init(Object *obj) 2346d25228e7SJason Wang { 2347d25228e7SJason Wang spapr_compat_2_3(obj); 2348d25228e7SJason Wang spapr_machine_initfn(obj); 2349d25228e7SJason Wang } 2350d25228e7SJason Wang 2351b0e966d0SJason Wang static void spapr_machine_2_2_instance_init(Object *obj) 2352b0e966d0SJason Wang { 2353b0e966d0SJason Wang spapr_compat_2_2(obj); 2354b0e966d0SJason Wang spapr_machine_initfn(obj); 2355b0e966d0SJason Wang } 2356b0e966d0SJason Wang 2357b0e966d0SJason Wang static void spapr_machine_2_1_instance_init(Object *obj) 2358b0e966d0SJason Wang { 2359b0e966d0SJason Wang spapr_compat_2_1(obj); 2360b0e966d0SJason Wang spapr_machine_initfn(obj); 2361b0e966d0SJason Wang } 2362b0e966d0SJason Wang 23636026db45SAlexey Kardashevskiy static void spapr_machine_2_1_class_init(ObjectClass *oc, void *data) 23646026db45SAlexey Kardashevskiy { 23656026db45SAlexey Kardashevskiy MachineClass *mc = MACHINE_CLASS(oc); 236668a27b20SMichael S. Tsirkin static GlobalProperty compat_props[] = { 2367dd754bafSEduardo Habkost SPAPR_COMPAT_2_1 236868a27b20SMichael S. Tsirkin { /* end of list */ } 236968a27b20SMichael S. Tsirkin }; 23706026db45SAlexey Kardashevskiy 23716026db45SAlexey Kardashevskiy mc->desc = "pSeries Logical Partition (PAPR compliant) v2.1"; 237268a27b20SMichael S. Tsirkin mc->compat_props = compat_props; 23736026db45SAlexey Kardashevskiy } 23746026db45SAlexey Kardashevskiy 23756026db45SAlexey Kardashevskiy static const TypeInfo spapr_machine_2_1_info = { 2376b9f072d0SEduardo Habkost .name = MACHINE_TYPE_NAME("pseries-2.1"), 23776026db45SAlexey Kardashevskiy .parent = TYPE_SPAPR_MACHINE, 23786026db45SAlexey Kardashevskiy .class_init = spapr_machine_2_1_class_init, 2379b0e966d0SJason Wang .instance_init = spapr_machine_2_1_instance_init, 23806026db45SAlexey Kardashevskiy }; 23816026db45SAlexey Kardashevskiy 23824aee7362SDavid Gibson static void spapr_machine_2_2_class_init(ObjectClass *oc, void *data) 23834aee7362SDavid Gibson { 2384b194df47SAlexey Kardashevskiy static GlobalProperty compat_props[] = { 2385dd754bafSEduardo Habkost SPAPR_COMPAT_2_2 2386b194df47SAlexey Kardashevskiy { /* end of list */ } 2387b194df47SAlexey Kardashevskiy }; 23884aee7362SDavid Gibson MachineClass *mc = MACHINE_CLASS(oc); 23894aee7362SDavid Gibson 23904aee7362SDavid Gibson mc->desc = "pSeries Logical Partition (PAPR compliant) v2.2"; 2391b194df47SAlexey Kardashevskiy mc->compat_props = compat_props; 23924aee7362SDavid Gibson } 23934aee7362SDavid Gibson 23944aee7362SDavid Gibson static const TypeInfo spapr_machine_2_2_info = { 2395b9f072d0SEduardo Habkost .name = MACHINE_TYPE_NAME("pseries-2.2"), 23964aee7362SDavid Gibson .parent = TYPE_SPAPR_MACHINE, 23974aee7362SDavid Gibson .class_init = spapr_machine_2_2_class_init, 2398b0e966d0SJason Wang .instance_init = spapr_machine_2_2_instance_init, 23994aee7362SDavid Gibson }; 24004aee7362SDavid Gibson 24013dab0244SAlexey Kardashevskiy static void spapr_machine_2_3_class_init(ObjectClass *oc, void *data) 24023dab0244SAlexey Kardashevskiy { 2403a1a45612SDavid Gibson static GlobalProperty compat_props[] = { 24047619c7b0SMichael Roth SPAPR_COMPAT_2_3 2405a1a45612SDavid Gibson { /* end of list */ } 2406a1a45612SDavid Gibson }; 24073dab0244SAlexey Kardashevskiy MachineClass *mc = MACHINE_CLASS(oc); 24083dab0244SAlexey Kardashevskiy 24093dab0244SAlexey Kardashevskiy mc->desc = "pSeries Logical Partition (PAPR compliant) v2.3"; 2410a1a45612SDavid Gibson mc->compat_props = compat_props; 24113dab0244SAlexey Kardashevskiy } 24123dab0244SAlexey Kardashevskiy 24133dab0244SAlexey Kardashevskiy static const TypeInfo spapr_machine_2_3_info = { 2414b9f072d0SEduardo Habkost .name = MACHINE_TYPE_NAME("pseries-2.3"), 24153dab0244SAlexey Kardashevskiy .parent = TYPE_SPAPR_MACHINE, 24163dab0244SAlexey Kardashevskiy .class_init = spapr_machine_2_3_class_init, 2417d25228e7SJason Wang .instance_init = spapr_machine_2_3_instance_init, 2418d25228e7SJason Wang }; 2419d25228e7SJason Wang 2420d25228e7SJason Wang static void spapr_machine_2_4_class_init(ObjectClass *oc, void *data) 2421d25228e7SJason Wang { 242280fd50f9SCornelia Huck static GlobalProperty compat_props[] = { 242380fd50f9SCornelia Huck SPAPR_COMPAT_2_4 242480fd50f9SCornelia Huck { /* end of list */ } 242580fd50f9SCornelia Huck }; 2426d25228e7SJason Wang MachineClass *mc = MACHINE_CLASS(oc); 2427d25228e7SJason Wang 2428d25228e7SJason Wang mc->desc = "pSeries Logical Partition (PAPR compliant) v2.4"; 242980fd50f9SCornelia Huck mc->compat_props = compat_props; 2430d25228e7SJason Wang } 2431d25228e7SJason Wang 2432d25228e7SJason Wang static const TypeInfo spapr_machine_2_4_info = { 2433b9f072d0SEduardo Habkost .name = MACHINE_TYPE_NAME("pseries-2.4"), 2434d25228e7SJason Wang .parent = TYPE_SPAPR_MACHINE, 2435d25228e7SJason Wang .class_init = spapr_machine_2_4_class_init, 24363dab0244SAlexey Kardashevskiy }; 24373dab0244SAlexey Kardashevskiy 2438fb0fc8f6SDavid Gibson static void spapr_machine_2_5_class_init(ObjectClass *oc, void *data) 2439fb0fc8f6SDavid Gibson { 2440fb0fc8f6SDavid Gibson MachineClass *mc = MACHINE_CLASS(oc); 2441224245bfSDavid Gibson sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(oc); 2442fb0fc8f6SDavid Gibson 2443fb0fc8f6SDavid Gibson mc->name = "pseries-2.5"; 2444fb0fc8f6SDavid Gibson mc->desc = "pSeries Logical Partition (PAPR compliant) v2.5"; 2445fb0fc8f6SDavid Gibson mc->alias = "pseries"; 2446fb0fc8f6SDavid Gibson mc->is_default = 1; 2447224245bfSDavid Gibson smc->dr_lmb_enabled = true; 2448fb0fc8f6SDavid Gibson } 2449fb0fc8f6SDavid Gibson 2450fb0fc8f6SDavid Gibson static const TypeInfo spapr_machine_2_5_info = { 2451fb0fc8f6SDavid Gibson .name = MACHINE_TYPE_NAME("pseries-2.5"), 2452fb0fc8f6SDavid Gibson .parent = TYPE_SPAPR_MACHINE, 2453fb0fc8f6SDavid Gibson .class_init = spapr_machine_2_5_class_init, 2454fb0fc8f6SDavid Gibson }; 2455fb0fc8f6SDavid Gibson 245629ee3247SAlexey Kardashevskiy static void spapr_machine_register_types(void) 245729ee3247SAlexey Kardashevskiy { 245829ee3247SAlexey Kardashevskiy type_register_static(&spapr_machine_info); 24596026db45SAlexey Kardashevskiy type_register_static(&spapr_machine_2_1_info); 24604aee7362SDavid Gibson type_register_static(&spapr_machine_2_2_info); 24613dab0244SAlexey Kardashevskiy type_register_static(&spapr_machine_2_3_info); 2462d25228e7SJason Wang type_register_static(&spapr_machine_2_4_info); 2463fb0fc8f6SDavid Gibson type_register_static(&spapr_machine_2_5_info); 246429ee3247SAlexey Kardashevskiy } 246529ee3247SAlexey Kardashevskiy 246629ee3247SAlexey Kardashevskiy type_init(spapr_machine_register_types) 2467