153018216SPaolo Bonzini /* 253018216SPaolo Bonzini * QEMU PowerPC pSeries Logical Partition (aka sPAPR) hardware System Emulator 353018216SPaolo Bonzini * 453018216SPaolo Bonzini * Copyright (c) 2004-2007 Fabrice Bellard 553018216SPaolo Bonzini * Copyright (c) 2007 Jocelyn Mayer 653018216SPaolo Bonzini * Copyright (c) 2010 David Gibson, IBM Corporation. 753018216SPaolo Bonzini * 853018216SPaolo Bonzini * Permission is hereby granted, free of charge, to any person obtaining a copy 953018216SPaolo Bonzini * of this software and associated documentation files (the "Software"), to deal 1053018216SPaolo Bonzini * in the Software without restriction, including without limitation the rights 1153018216SPaolo Bonzini * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 1253018216SPaolo Bonzini * copies of the Software, and to permit persons to whom the Software is 1353018216SPaolo Bonzini * furnished to do so, subject to the following conditions: 1453018216SPaolo Bonzini * 1553018216SPaolo Bonzini * The above copyright notice and this permission notice shall be included in 1653018216SPaolo Bonzini * all copies or substantial portions of the Software. 1753018216SPaolo Bonzini * 1853018216SPaolo Bonzini * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 1953018216SPaolo Bonzini * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 2053018216SPaolo Bonzini * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 2153018216SPaolo Bonzini * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 2253018216SPaolo Bonzini * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 2353018216SPaolo Bonzini * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 2453018216SPaolo Bonzini * THE SOFTWARE. 2553018216SPaolo Bonzini * 2653018216SPaolo Bonzini */ 270d75590dSPeter Maydell #include "qemu/osdep.h" 2853018216SPaolo Bonzini #include "sysemu/sysemu.h" 29e35704baSEduardo Habkost #include "sysemu/numa.h" 3053018216SPaolo Bonzini #include "hw/hw.h" 3171461b0fSAlexey Kardashevskiy #include "hw/fw-path-provider.h" 3253018216SPaolo Bonzini #include "elf.h" 3353018216SPaolo Bonzini #include "net/net.h" 34ad440b4aSAndrew Jones #include "sysemu/device_tree.h" 35fa1d36dfSMarkus Armbruster #include "sysemu/block-backend.h" 3653018216SPaolo Bonzini #include "sysemu/cpus.h" 3753018216SPaolo Bonzini #include "sysemu/kvm.h" 38c20d332aSBharata B Rao #include "sysemu/device_tree.h" 3953018216SPaolo Bonzini #include "kvm_ppc.h" 40ff14e817SDr. David Alan Gilbert #include "migration/migration.h" 414be21d56SDavid Gibson #include "mmu-hash64.h" 423794d548SAlexey Kardashevskiy #include "qom/cpu.h" 4353018216SPaolo Bonzini 4453018216SPaolo Bonzini #include "hw/boards.h" 450d09e41aSPaolo Bonzini #include "hw/ppc/ppc.h" 4653018216SPaolo Bonzini #include "hw/loader.h" 4753018216SPaolo Bonzini 480d09e41aSPaolo Bonzini #include "hw/ppc/spapr.h" 490d09e41aSPaolo Bonzini #include "hw/ppc/spapr_vio.h" 500d09e41aSPaolo Bonzini #include "hw/pci-host/spapr.h" 510d09e41aSPaolo Bonzini #include "hw/ppc/xics.h" 5253018216SPaolo Bonzini #include "hw/pci/msi.h" 5353018216SPaolo Bonzini 5453018216SPaolo Bonzini #include "hw/pci/pci.h" 5571461b0fSAlexey Kardashevskiy #include "hw/scsi/scsi.h" 5671461b0fSAlexey Kardashevskiy #include "hw/virtio/virtio-scsi.h" 5753018216SPaolo Bonzini 5853018216SPaolo Bonzini #include "exec/address-spaces.h" 5953018216SPaolo Bonzini #include "hw/usb.h" 6053018216SPaolo Bonzini #include "qemu/config-file.h" 61135a129aSAneesh Kumar K.V #include "qemu/error-report.h" 622a6593cbSAlexey Kardashevskiy #include "trace.h" 6334316482SAlexey Kardashevskiy #include "hw/nmi.h" 6453018216SPaolo Bonzini 6568a27b20SMichael S. Tsirkin #include "hw/compat.h" 66224245bfSDavid Gibson #include "qemu-common.h" 6768a27b20SMichael S. Tsirkin 6853018216SPaolo Bonzini #include <libfdt.h> 6953018216SPaolo Bonzini 7053018216SPaolo Bonzini /* SLOF memory layout: 7153018216SPaolo Bonzini * 7253018216SPaolo Bonzini * SLOF raw image loaded at 0, copies its romfs right below the flat 7353018216SPaolo Bonzini * device-tree, then position SLOF itself 31M below that 7453018216SPaolo Bonzini * 7553018216SPaolo Bonzini * So we set FW_OVERHEAD to 40MB which should account for all of that 7653018216SPaolo Bonzini * and more 7753018216SPaolo Bonzini * 7853018216SPaolo Bonzini * We load our kernel at 4M, leaving space for SLOF initial image 7953018216SPaolo Bonzini */ 8038b02bd8SAlexey Kardashevskiy #define FDT_MAX_SIZE 0x100000 8153018216SPaolo Bonzini #define RTAS_MAX_SIZE 0x10000 82b7d1f77aSBenjamin Herrenschmidt #define RTAS_MAX_ADDR 0x80000000 /* RTAS must stay below that */ 8353018216SPaolo Bonzini #define FW_MAX_SIZE 0x400000 8453018216SPaolo Bonzini #define FW_FILE_NAME "slof.bin" 8553018216SPaolo Bonzini #define FW_OVERHEAD 0x2800000 8653018216SPaolo Bonzini #define KERNEL_LOAD_ADDR FW_MAX_SIZE 8753018216SPaolo Bonzini 8853018216SPaolo Bonzini #define MIN_RMA_SLOF 128UL 8953018216SPaolo Bonzini 9053018216SPaolo Bonzini #define TIMEBASE_FREQ 512000000ULL 9153018216SPaolo Bonzini 9253018216SPaolo Bonzini #define PHANDLE_XICP 0x00001111 9353018216SPaolo Bonzini 9453018216SPaolo Bonzini #define HTAB_SIZE(spapr) (1ULL << ((spapr)->htab_shift)) 9553018216SPaolo Bonzini 96c04d6cfaSAnthony Liguori static XICSState *try_create_xics(const char *type, int nr_servers, 9734f2af3dSMarkus Armbruster int nr_irqs, Error **errp) 98c04d6cfaSAnthony Liguori { 9934f2af3dSMarkus Armbruster Error *err = NULL; 100c04d6cfaSAnthony Liguori DeviceState *dev; 101c04d6cfaSAnthony Liguori 102c04d6cfaSAnthony Liguori dev = qdev_create(NULL, type); 103c04d6cfaSAnthony Liguori qdev_prop_set_uint32(dev, "nr_servers", nr_servers); 104c04d6cfaSAnthony Liguori qdev_prop_set_uint32(dev, "nr_irqs", nr_irqs); 10534f2af3dSMarkus Armbruster object_property_set_bool(OBJECT(dev), true, "realized", &err); 10634f2af3dSMarkus Armbruster if (err) { 10734f2af3dSMarkus Armbruster error_propagate(errp, err); 10834f2af3dSMarkus Armbruster object_unparent(OBJECT(dev)); 109c04d6cfaSAnthony Liguori return NULL; 110c04d6cfaSAnthony Liguori } 1115a3d7b23SAlexey Kardashevskiy return XICS_COMMON(dev); 112c04d6cfaSAnthony Liguori } 113c04d6cfaSAnthony Liguori 114446f16a6SMarcel Apfelbaum static XICSState *xics_system_init(MachineState *machine, 115*1e49182dSDavid Gibson int nr_servers, int nr_irqs, Error **errp) 116c04d6cfaSAnthony Liguori { 117c04d6cfaSAnthony Liguori XICSState *icp = NULL; 118c04d6cfaSAnthony Liguori 11911ad93f6SDavid Gibson if (kvm_enabled()) { 12034f2af3dSMarkus Armbruster Error *err = NULL; 12134f2af3dSMarkus Armbruster 122446f16a6SMarcel Apfelbaum if (machine_kernel_irqchip_allowed(machine)) { 12334f2af3dSMarkus Armbruster icp = try_create_xics(TYPE_KVM_XICS, nr_servers, nr_irqs, &err); 12411ad93f6SDavid Gibson } 125446f16a6SMarcel Apfelbaum if (machine_kernel_irqchip_required(machine) && !icp) { 126b83baa60SMarkus Armbruster error_reportf_err(err, 127b83baa60SMarkus Armbruster "kernel_irqchip requested but unavailable: "); 128b83baa60SMarkus Armbruster } else { 129903a41d3SStefano Dong (董兴水) error_free(err); 13011ad93f6SDavid Gibson } 131b83baa60SMarkus Armbruster } 13211ad93f6SDavid Gibson 13311ad93f6SDavid Gibson if (!icp) { 134*1e49182dSDavid Gibson icp = try_create_xics(TYPE_XICS, nr_servers, nr_irqs, errp); 135c04d6cfaSAnthony Liguori } 136c04d6cfaSAnthony Liguori 137c04d6cfaSAnthony Liguori return icp; 138c04d6cfaSAnthony Liguori } 139c04d6cfaSAnthony Liguori 140833d4668SAlexey Kardashevskiy static int spapr_fixup_cpu_smt_dt(void *fdt, int offset, PowerPCCPU *cpu, 141833d4668SAlexey Kardashevskiy int smt_threads) 142833d4668SAlexey Kardashevskiy { 143833d4668SAlexey Kardashevskiy int i, ret = 0; 144833d4668SAlexey Kardashevskiy uint32_t servers_prop[smt_threads]; 145833d4668SAlexey Kardashevskiy uint32_t gservers_prop[smt_threads * 2]; 146833d4668SAlexey Kardashevskiy int index = ppc_get_vcpu_dt_id(cpu); 147833d4668SAlexey Kardashevskiy 1486d9412eaSAlexey Kardashevskiy if (cpu->cpu_version) { 1494bce526eSLaurent Dufour ret = fdt_setprop_cell(fdt, offset, "cpu-version", cpu->cpu_version); 1506d9412eaSAlexey Kardashevskiy if (ret < 0) { 1516d9412eaSAlexey Kardashevskiy return ret; 1526d9412eaSAlexey Kardashevskiy } 1536d9412eaSAlexey Kardashevskiy } 1546d9412eaSAlexey Kardashevskiy 155833d4668SAlexey Kardashevskiy /* Build interrupt servers and gservers properties */ 156833d4668SAlexey Kardashevskiy for (i = 0; i < smt_threads; i++) { 157833d4668SAlexey Kardashevskiy servers_prop[i] = cpu_to_be32(index + i); 158833d4668SAlexey Kardashevskiy /* Hack, direct the group queues back to cpu 0 */ 159833d4668SAlexey Kardashevskiy gservers_prop[i*2] = cpu_to_be32(index + i); 160833d4668SAlexey Kardashevskiy gservers_prop[i*2 + 1] = 0; 161833d4668SAlexey Kardashevskiy } 162833d4668SAlexey Kardashevskiy ret = fdt_setprop(fdt, offset, "ibm,ppc-interrupt-server#s", 163833d4668SAlexey Kardashevskiy servers_prop, sizeof(servers_prop)); 164833d4668SAlexey Kardashevskiy if (ret < 0) { 165833d4668SAlexey Kardashevskiy return ret; 166833d4668SAlexey Kardashevskiy } 167833d4668SAlexey Kardashevskiy ret = fdt_setprop(fdt, offset, "ibm,ppc-interrupt-gserver#s", 168833d4668SAlexey Kardashevskiy gservers_prop, sizeof(gservers_prop)); 169833d4668SAlexey Kardashevskiy 170833d4668SAlexey Kardashevskiy return ret; 171833d4668SAlexey Kardashevskiy } 172833d4668SAlexey Kardashevskiy 1730da6f3feSBharata B Rao static int spapr_fixup_cpu_numa_dt(void *fdt, int offset, CPUState *cs) 1740da6f3feSBharata B Rao { 1750da6f3feSBharata B Rao int ret = 0; 1760da6f3feSBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(cs); 1770da6f3feSBharata B Rao int index = ppc_get_vcpu_dt_id(cpu); 1780da6f3feSBharata B Rao uint32_t associativity[] = {cpu_to_be32(0x5), 1790da6f3feSBharata B Rao cpu_to_be32(0x0), 1800da6f3feSBharata B Rao cpu_to_be32(0x0), 1810da6f3feSBharata B Rao cpu_to_be32(0x0), 1820da6f3feSBharata B Rao cpu_to_be32(cs->numa_node), 1830da6f3feSBharata B Rao cpu_to_be32(index)}; 1840da6f3feSBharata B Rao 1850da6f3feSBharata B Rao /* Advertise NUMA via ibm,associativity */ 1860da6f3feSBharata B Rao if (nb_numa_nodes > 1) { 1870da6f3feSBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,associativity", associativity, 1880da6f3feSBharata B Rao sizeof(associativity)); 1890da6f3feSBharata B Rao } 1900da6f3feSBharata B Rao 1910da6f3feSBharata B Rao return ret; 1920da6f3feSBharata B Rao } 1930da6f3feSBharata B Rao 19428e02042SDavid Gibson static int spapr_fixup_cpu_dt(void *fdt, sPAPRMachineState *spapr) 19553018216SPaolo Bonzini { 19682677ed2SAlexey Kardashevskiy int ret = 0, offset, cpus_offset; 19782677ed2SAlexey Kardashevskiy CPUState *cs; 19853018216SPaolo Bonzini char cpu_model[32]; 19953018216SPaolo Bonzini int smt = kvmppc_smt_threads(); 20053018216SPaolo Bonzini uint32_t pft_size_prop[] = {0, cpu_to_be32(spapr->htab_shift)}; 20153018216SPaolo Bonzini 20282677ed2SAlexey Kardashevskiy CPU_FOREACH(cs) { 20382677ed2SAlexey Kardashevskiy PowerPCCPU *cpu = POWERPC_CPU(cs); 20482677ed2SAlexey Kardashevskiy DeviceClass *dc = DEVICE_GET_CLASS(cs); 20582677ed2SAlexey Kardashevskiy int index = ppc_get_vcpu_dt_id(cpu); 20653018216SPaolo Bonzini 2070f20ba62SAlexey Kardashevskiy if ((index % smt) != 0) { 20853018216SPaolo Bonzini continue; 20953018216SPaolo Bonzini } 21053018216SPaolo Bonzini 21182677ed2SAlexey Kardashevskiy snprintf(cpu_model, 32, "%s@%x", dc->fw_name, index); 21253018216SPaolo Bonzini 21382677ed2SAlexey Kardashevskiy cpus_offset = fdt_path_offset(fdt, "/cpus"); 21482677ed2SAlexey Kardashevskiy if (cpus_offset < 0) { 21582677ed2SAlexey Kardashevskiy cpus_offset = fdt_add_subnode(fdt, fdt_path_offset(fdt, "/"), 21682677ed2SAlexey Kardashevskiy "cpus"); 21782677ed2SAlexey Kardashevskiy if (cpus_offset < 0) { 21882677ed2SAlexey Kardashevskiy return cpus_offset; 21982677ed2SAlexey Kardashevskiy } 22082677ed2SAlexey Kardashevskiy } 22182677ed2SAlexey Kardashevskiy offset = fdt_subnode_offset(fdt, cpus_offset, cpu_model); 22282677ed2SAlexey Kardashevskiy if (offset < 0) { 22382677ed2SAlexey Kardashevskiy offset = fdt_add_subnode(fdt, cpus_offset, cpu_model); 22453018216SPaolo Bonzini if (offset < 0) { 22553018216SPaolo Bonzini return offset; 22653018216SPaolo Bonzini } 22782677ed2SAlexey Kardashevskiy } 22853018216SPaolo Bonzini 2290da6f3feSBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,pft-size", 2300da6f3feSBharata B Rao pft_size_prop, sizeof(pft_size_prop)); 23153018216SPaolo Bonzini if (ret < 0) { 23253018216SPaolo Bonzini return ret; 23353018216SPaolo Bonzini } 23453018216SPaolo Bonzini 2350da6f3feSBharata B Rao ret = spapr_fixup_cpu_numa_dt(fdt, offset, cs); 23653018216SPaolo Bonzini if (ret < 0) { 23753018216SPaolo Bonzini return ret; 23853018216SPaolo Bonzini } 239833d4668SAlexey Kardashevskiy 24082677ed2SAlexey Kardashevskiy ret = spapr_fixup_cpu_smt_dt(fdt, offset, cpu, 2412a48d993SAlexey Kardashevskiy ppc_get_compat_smt_threads(cpu)); 242833d4668SAlexey Kardashevskiy if (ret < 0) { 243833d4668SAlexey Kardashevskiy return ret; 244833d4668SAlexey Kardashevskiy } 24553018216SPaolo Bonzini } 24653018216SPaolo Bonzini return ret; 24753018216SPaolo Bonzini } 24853018216SPaolo Bonzini 24953018216SPaolo Bonzini 25053018216SPaolo Bonzini static size_t create_page_sizes_prop(CPUPPCState *env, uint32_t *prop, 25153018216SPaolo Bonzini size_t maxsize) 25253018216SPaolo Bonzini { 25353018216SPaolo Bonzini size_t maxcells = maxsize / sizeof(uint32_t); 25453018216SPaolo Bonzini int i, j, count; 25553018216SPaolo Bonzini uint32_t *p = prop; 25653018216SPaolo Bonzini 25753018216SPaolo Bonzini for (i = 0; i < PPC_PAGE_SIZES_MAX_SZ; i++) { 25853018216SPaolo Bonzini struct ppc_one_seg_page_size *sps = &env->sps.sps[i]; 25953018216SPaolo Bonzini 26053018216SPaolo Bonzini if (!sps->page_shift) { 26153018216SPaolo Bonzini break; 26253018216SPaolo Bonzini } 26353018216SPaolo Bonzini for (count = 0; count < PPC_PAGE_SIZES_MAX_SZ; count++) { 26453018216SPaolo Bonzini if (sps->enc[count].page_shift == 0) { 26553018216SPaolo Bonzini break; 26653018216SPaolo Bonzini } 26753018216SPaolo Bonzini } 26853018216SPaolo Bonzini if ((p - prop) >= (maxcells - 3 - count * 2)) { 26953018216SPaolo Bonzini break; 27053018216SPaolo Bonzini } 27153018216SPaolo Bonzini *(p++) = cpu_to_be32(sps->page_shift); 27253018216SPaolo Bonzini *(p++) = cpu_to_be32(sps->slb_enc); 27353018216SPaolo Bonzini *(p++) = cpu_to_be32(count); 27453018216SPaolo Bonzini for (j = 0; j < count; j++) { 27553018216SPaolo Bonzini *(p++) = cpu_to_be32(sps->enc[j].page_shift); 27653018216SPaolo Bonzini *(p++) = cpu_to_be32(sps->enc[j].pte_enc); 27753018216SPaolo Bonzini } 27853018216SPaolo Bonzini } 27953018216SPaolo Bonzini 28053018216SPaolo Bonzini return (p - prop) * sizeof(uint32_t); 28153018216SPaolo Bonzini } 28253018216SPaolo Bonzini 283b082d65aSAlexey Kardashevskiy static hwaddr spapr_node0_size(void) 284b082d65aSAlexey Kardashevskiy { 285fb164994SDavid Gibson MachineState *machine = MACHINE(qdev_get_machine()); 286fb164994SDavid Gibson 287b082d65aSAlexey Kardashevskiy if (nb_numa_nodes) { 288b082d65aSAlexey Kardashevskiy int i; 289b082d65aSAlexey Kardashevskiy for (i = 0; i < nb_numa_nodes; ++i) { 290b082d65aSAlexey Kardashevskiy if (numa_info[i].node_mem) { 291fb164994SDavid Gibson return MIN(pow2floor(numa_info[i].node_mem), 292fb164994SDavid Gibson machine->ram_size); 293b082d65aSAlexey Kardashevskiy } 294b082d65aSAlexey Kardashevskiy } 295b082d65aSAlexey Kardashevskiy } 296fb164994SDavid Gibson return machine->ram_size; 297b082d65aSAlexey Kardashevskiy } 298b082d65aSAlexey Kardashevskiy 29953018216SPaolo Bonzini #define _FDT(exp) \ 30053018216SPaolo Bonzini do { \ 30153018216SPaolo Bonzini int ret = (exp); \ 30253018216SPaolo Bonzini if (ret < 0) { \ 30353018216SPaolo Bonzini fprintf(stderr, "qemu: error creating device tree: %s: %s\n", \ 30453018216SPaolo Bonzini #exp, fdt_strerror(ret)); \ 30553018216SPaolo Bonzini exit(1); \ 30653018216SPaolo Bonzini } \ 30753018216SPaolo Bonzini } while (0) 30853018216SPaolo Bonzini 309a1d59c0fSAlexey Kardashevskiy static void add_str(GString *s, const gchar *s1) 310a1d59c0fSAlexey Kardashevskiy { 311a1d59c0fSAlexey Kardashevskiy g_string_append_len(s, s1, strlen(s1) + 1); 312a1d59c0fSAlexey Kardashevskiy } 31353018216SPaolo Bonzini 3143bbf37f2SAndreas Färber static void *spapr_create_fdt_skel(hwaddr initrd_base, 31553018216SPaolo Bonzini hwaddr initrd_size, 31653018216SPaolo Bonzini hwaddr kernel_size, 31716457e7fSBenjamin Herrenschmidt bool little_endian, 31853018216SPaolo Bonzini const char *kernel_cmdline, 31953018216SPaolo Bonzini uint32_t epow_irq) 32053018216SPaolo Bonzini { 32153018216SPaolo Bonzini void *fdt; 32253018216SPaolo Bonzini uint32_t start_prop = cpu_to_be32(initrd_base); 32353018216SPaolo Bonzini uint32_t end_prop = cpu_to_be32(initrd_base + initrd_size); 324a1d59c0fSAlexey Kardashevskiy GString *hypertas = g_string_sized_new(256); 325a1d59c0fSAlexey Kardashevskiy GString *qemu_hypertas = g_string_sized_new(256); 32653018216SPaolo Bonzini uint32_t refpoints[] = {cpu_to_be32(0x4), cpu_to_be32(0x4)}; 3279e734e3dSBharata B Rao uint32_t interrupt_server_ranges_prop[] = {0, cpu_to_be32(max_cpus)}; 32853018216SPaolo Bonzini unsigned char vec5[] = {0x0, 0x0, 0x0, 0x0, 0x0, 0x80}; 329ef951443SNikunj A Dadhania char *buf; 33053018216SPaolo Bonzini 331a1d59c0fSAlexey Kardashevskiy add_str(hypertas, "hcall-pft"); 332a1d59c0fSAlexey Kardashevskiy add_str(hypertas, "hcall-term"); 333a1d59c0fSAlexey Kardashevskiy add_str(hypertas, "hcall-dabr"); 334a1d59c0fSAlexey Kardashevskiy add_str(hypertas, "hcall-interrupt"); 335a1d59c0fSAlexey Kardashevskiy add_str(hypertas, "hcall-tce"); 336a1d59c0fSAlexey Kardashevskiy add_str(hypertas, "hcall-vio"); 337a1d59c0fSAlexey Kardashevskiy add_str(hypertas, "hcall-splpar"); 338a1d59c0fSAlexey Kardashevskiy add_str(hypertas, "hcall-bulk"); 339a1d59c0fSAlexey Kardashevskiy add_str(hypertas, "hcall-set-mode"); 340a1d59c0fSAlexey Kardashevskiy add_str(qemu_hypertas, "hcall-memop1"); 341a1d59c0fSAlexey Kardashevskiy 34253018216SPaolo Bonzini fdt = g_malloc0(FDT_MAX_SIZE); 34353018216SPaolo Bonzini _FDT((fdt_create(fdt, FDT_MAX_SIZE))); 34453018216SPaolo Bonzini 34553018216SPaolo Bonzini if (kernel_size) { 34653018216SPaolo Bonzini _FDT((fdt_add_reservemap_entry(fdt, KERNEL_LOAD_ADDR, kernel_size))); 34753018216SPaolo Bonzini } 34853018216SPaolo Bonzini if (initrd_size) { 34953018216SPaolo Bonzini _FDT((fdt_add_reservemap_entry(fdt, initrd_base, initrd_size))); 35053018216SPaolo Bonzini } 35153018216SPaolo Bonzini _FDT((fdt_finish_reservemap(fdt))); 35253018216SPaolo Bonzini 35353018216SPaolo Bonzini /* Root node */ 35453018216SPaolo Bonzini _FDT((fdt_begin_node(fdt, ""))); 35553018216SPaolo Bonzini _FDT((fdt_property_string(fdt, "device_type", "chrp"))); 35653018216SPaolo Bonzini _FDT((fdt_property_string(fdt, "model", "IBM pSeries (emulated by qemu)"))); 357fa388916SAnthony Liguori _FDT((fdt_property_string(fdt, "compatible", "qemu,pseries"))); 35853018216SPaolo Bonzini 359ef951443SNikunj A Dadhania /* 360ef951443SNikunj A Dadhania * Add info to guest to indentify which host is it being run on 361ef951443SNikunj A Dadhania * and what is the uuid of the guest 362ef951443SNikunj A Dadhania */ 363ef951443SNikunj A Dadhania if (kvmppc_get_host_model(&buf)) { 364ef951443SNikunj A Dadhania _FDT((fdt_property_string(fdt, "host-model", buf))); 365ef951443SNikunj A Dadhania g_free(buf); 366ef951443SNikunj A Dadhania } 367ef951443SNikunj A Dadhania if (kvmppc_get_host_serial(&buf)) { 368ef951443SNikunj A Dadhania _FDT((fdt_property_string(fdt, "host-serial", buf))); 369ef951443SNikunj A Dadhania g_free(buf); 370ef951443SNikunj A Dadhania } 371ef951443SNikunj A Dadhania 372ef951443SNikunj A Dadhania buf = g_strdup_printf(UUID_FMT, qemu_uuid[0], qemu_uuid[1], 373ef951443SNikunj A Dadhania qemu_uuid[2], qemu_uuid[3], qemu_uuid[4], 374ef951443SNikunj A Dadhania qemu_uuid[5], qemu_uuid[6], qemu_uuid[7], 375ef951443SNikunj A Dadhania qemu_uuid[8], qemu_uuid[9], qemu_uuid[10], 376ef951443SNikunj A Dadhania qemu_uuid[11], qemu_uuid[12], qemu_uuid[13], 377ef951443SNikunj A Dadhania qemu_uuid[14], qemu_uuid[15]); 378ef951443SNikunj A Dadhania 379ef951443SNikunj A Dadhania _FDT((fdt_property_string(fdt, "vm,uuid", buf))); 3803dc0a66dSAlexey Kardashevskiy if (qemu_uuid_set) { 3813dc0a66dSAlexey Kardashevskiy _FDT((fdt_property_string(fdt, "system-id", buf))); 3823dc0a66dSAlexey Kardashevskiy } 383ef951443SNikunj A Dadhania g_free(buf); 384ef951443SNikunj A Dadhania 3852c1aaa81SSam Bobroff if (qemu_get_vm_name()) { 3862c1aaa81SSam Bobroff _FDT((fdt_property_string(fdt, "ibm,partition-name", 3872c1aaa81SSam Bobroff qemu_get_vm_name()))); 3882c1aaa81SSam Bobroff } 3892c1aaa81SSam Bobroff 39053018216SPaolo Bonzini _FDT((fdt_property_cell(fdt, "#address-cells", 0x2))); 39153018216SPaolo Bonzini _FDT((fdt_property_cell(fdt, "#size-cells", 0x2))); 39253018216SPaolo Bonzini 39353018216SPaolo Bonzini /* /chosen */ 39453018216SPaolo Bonzini _FDT((fdt_begin_node(fdt, "chosen"))); 39553018216SPaolo Bonzini 39653018216SPaolo Bonzini /* Set Form1_affinity */ 39753018216SPaolo Bonzini _FDT((fdt_property(fdt, "ibm,architecture-vec-5", vec5, sizeof(vec5)))); 39853018216SPaolo Bonzini 39953018216SPaolo Bonzini _FDT((fdt_property_string(fdt, "bootargs", kernel_cmdline))); 40053018216SPaolo Bonzini _FDT((fdt_property(fdt, "linux,initrd-start", 40153018216SPaolo Bonzini &start_prop, sizeof(start_prop)))); 40253018216SPaolo Bonzini _FDT((fdt_property(fdt, "linux,initrd-end", 40353018216SPaolo Bonzini &end_prop, sizeof(end_prop)))); 40453018216SPaolo Bonzini if (kernel_size) { 40553018216SPaolo Bonzini uint64_t kprop[2] = { cpu_to_be64(KERNEL_LOAD_ADDR), 40653018216SPaolo Bonzini cpu_to_be64(kernel_size) }; 40753018216SPaolo Bonzini 40853018216SPaolo Bonzini _FDT((fdt_property(fdt, "qemu,boot-kernel", &kprop, sizeof(kprop)))); 40916457e7fSBenjamin Herrenschmidt if (little_endian) { 41016457e7fSBenjamin Herrenschmidt _FDT((fdt_property(fdt, "qemu,boot-kernel-le", NULL, 0))); 41116457e7fSBenjamin Herrenschmidt } 41253018216SPaolo Bonzini } 413cc84c0f3SAvik Sil if (boot_menu) { 414cc84c0f3SAvik Sil _FDT((fdt_property_cell(fdt, "qemu,boot-menu", boot_menu))); 415cc84c0f3SAvik Sil } 41653018216SPaolo Bonzini _FDT((fdt_property_cell(fdt, "qemu,graphic-width", graphic_width))); 41753018216SPaolo Bonzini _FDT((fdt_property_cell(fdt, "qemu,graphic-height", graphic_height))); 41853018216SPaolo Bonzini _FDT((fdt_property_cell(fdt, "qemu,graphic-depth", graphic_depth))); 41953018216SPaolo Bonzini 42053018216SPaolo Bonzini _FDT((fdt_end_node(fdt))); 42153018216SPaolo Bonzini 42253018216SPaolo Bonzini /* RTAS */ 42353018216SPaolo Bonzini _FDT((fdt_begin_node(fdt, "rtas"))); 42453018216SPaolo Bonzini 425da95324eSAlexey Kardashevskiy if (!kvm_enabled() || kvmppc_spapr_use_multitce()) { 426da95324eSAlexey Kardashevskiy add_str(hypertas, "hcall-multi-tce"); 427da95324eSAlexey Kardashevskiy } 428a1d59c0fSAlexey Kardashevskiy _FDT((fdt_property(fdt, "ibm,hypertas-functions", hypertas->str, 429a1d59c0fSAlexey Kardashevskiy hypertas->len))); 430a1d59c0fSAlexey Kardashevskiy g_string_free(hypertas, TRUE); 431a1d59c0fSAlexey Kardashevskiy _FDT((fdt_property(fdt, "qemu,hypertas-functions", qemu_hypertas->str, 432a1d59c0fSAlexey Kardashevskiy qemu_hypertas->len))); 433a1d59c0fSAlexey Kardashevskiy g_string_free(qemu_hypertas, TRUE); 43453018216SPaolo Bonzini 43553018216SPaolo Bonzini _FDT((fdt_property(fdt, "ibm,associativity-reference-points", 43653018216SPaolo Bonzini refpoints, sizeof(refpoints)))); 43753018216SPaolo Bonzini 43853018216SPaolo Bonzini _FDT((fdt_property_cell(fdt, "rtas-error-log-max", RTAS_ERROR_LOG_MAX))); 43979853e18STyrel Datwyler _FDT((fdt_property_cell(fdt, "rtas-event-scan-rate", 44079853e18STyrel Datwyler RTAS_EVENT_SCAN_RATE))); 44153018216SPaolo Bonzini 442a95f9922SSam Bobroff if (msi_supported) { 443a95f9922SSam Bobroff _FDT((fdt_property(fdt, "ibm,change-msix-capable", NULL, 0))); 444a95f9922SSam Bobroff } 445a95f9922SSam Bobroff 4462e14072fSNikunj A Dadhania /* 4479d632f5fSzhanghailiang * According to PAPR, rtas ibm,os-term does not guarantee a return 4482e14072fSNikunj A Dadhania * back to the guest cpu. 4492e14072fSNikunj A Dadhania * 4502e14072fSNikunj A Dadhania * While an additional ibm,extended-os-term property indicates that 4512e14072fSNikunj A Dadhania * rtas call return will always occur. Set this property. 4522e14072fSNikunj A Dadhania */ 4532e14072fSNikunj A Dadhania _FDT((fdt_property(fdt, "ibm,extended-os-term", NULL, 0))); 4542e14072fSNikunj A Dadhania 45553018216SPaolo Bonzini _FDT((fdt_end_node(fdt))); 45653018216SPaolo Bonzini 45753018216SPaolo Bonzini /* interrupt controller */ 45853018216SPaolo Bonzini _FDT((fdt_begin_node(fdt, "interrupt-controller"))); 45953018216SPaolo Bonzini 46053018216SPaolo Bonzini _FDT((fdt_property_string(fdt, "device_type", 46153018216SPaolo Bonzini "PowerPC-External-Interrupt-Presentation"))); 46253018216SPaolo Bonzini _FDT((fdt_property_string(fdt, "compatible", "IBM,ppc-xicp"))); 46353018216SPaolo Bonzini _FDT((fdt_property(fdt, "interrupt-controller", NULL, 0))); 46453018216SPaolo Bonzini _FDT((fdt_property(fdt, "ibm,interrupt-server-ranges", 46553018216SPaolo Bonzini interrupt_server_ranges_prop, 46653018216SPaolo Bonzini sizeof(interrupt_server_ranges_prop)))); 46753018216SPaolo Bonzini _FDT((fdt_property_cell(fdt, "#interrupt-cells", 2))); 46853018216SPaolo Bonzini _FDT((fdt_property_cell(fdt, "linux,phandle", PHANDLE_XICP))); 46953018216SPaolo Bonzini _FDT((fdt_property_cell(fdt, "phandle", PHANDLE_XICP))); 47053018216SPaolo Bonzini 47153018216SPaolo Bonzini _FDT((fdt_end_node(fdt))); 47253018216SPaolo Bonzini 47353018216SPaolo Bonzini /* vdevice */ 47453018216SPaolo Bonzini _FDT((fdt_begin_node(fdt, "vdevice"))); 47553018216SPaolo Bonzini 47653018216SPaolo Bonzini _FDT((fdt_property_string(fdt, "device_type", "vdevice"))); 47753018216SPaolo Bonzini _FDT((fdt_property_string(fdt, "compatible", "IBM,vdevice"))); 47853018216SPaolo Bonzini _FDT((fdt_property_cell(fdt, "#address-cells", 0x1))); 47953018216SPaolo Bonzini _FDT((fdt_property_cell(fdt, "#size-cells", 0x0))); 48053018216SPaolo Bonzini _FDT((fdt_property_cell(fdt, "#interrupt-cells", 0x2))); 48153018216SPaolo Bonzini _FDT((fdt_property(fdt, "interrupt-controller", NULL, 0))); 48253018216SPaolo Bonzini 48353018216SPaolo Bonzini _FDT((fdt_end_node(fdt))); 48453018216SPaolo Bonzini 48553018216SPaolo Bonzini /* event-sources */ 48653018216SPaolo Bonzini spapr_events_fdt_skel(fdt, epow_irq); 48753018216SPaolo Bonzini 488f7d69146SAlexander Graf /* /hypervisor node */ 489f7d69146SAlexander Graf if (kvm_enabled()) { 490f7d69146SAlexander Graf uint8_t hypercall[16]; 491f7d69146SAlexander Graf 492f7d69146SAlexander Graf /* indicate KVM hypercall interface */ 493f7d69146SAlexander Graf _FDT((fdt_begin_node(fdt, "hypervisor"))); 494f7d69146SAlexander Graf _FDT((fdt_property_string(fdt, "compatible", "linux,kvm"))); 495f7d69146SAlexander Graf if (kvmppc_has_cap_fixup_hcalls()) { 496f7d69146SAlexander Graf /* 497f7d69146SAlexander Graf * Older KVM versions with older guest kernels were broken with the 498f7d69146SAlexander Graf * magic page, don't allow the guest to map it. 499f7d69146SAlexander Graf */ 500f7d69146SAlexander Graf kvmppc_get_hypercall(first_cpu->env_ptr, hypercall, 501f7d69146SAlexander Graf sizeof(hypercall)); 502f7d69146SAlexander Graf _FDT((fdt_property(fdt, "hcall-instructions", hypercall, 503f7d69146SAlexander Graf sizeof(hypercall)))); 504f7d69146SAlexander Graf } 505f7d69146SAlexander Graf _FDT((fdt_end_node(fdt))); 506f7d69146SAlexander Graf } 507f7d69146SAlexander Graf 50853018216SPaolo Bonzini _FDT((fdt_end_node(fdt))); /* close root node */ 50953018216SPaolo Bonzini _FDT((fdt_finish(fdt))); 51053018216SPaolo Bonzini 51153018216SPaolo Bonzini return fdt; 51253018216SPaolo Bonzini } 51353018216SPaolo Bonzini 51403d196b7SBharata B Rao static int spapr_populate_memory_node(void *fdt, int nodeid, hwaddr start, 51526a8c353SAlexey Kardashevskiy hwaddr size) 51626a8c353SAlexey Kardashevskiy { 51726a8c353SAlexey Kardashevskiy uint32_t associativity[] = { 51826a8c353SAlexey Kardashevskiy cpu_to_be32(0x4), /* length */ 51926a8c353SAlexey Kardashevskiy cpu_to_be32(0x0), cpu_to_be32(0x0), 520c3b4f589SAlexey Kardashevskiy cpu_to_be32(0x0), cpu_to_be32(nodeid) 52126a8c353SAlexey Kardashevskiy }; 52226a8c353SAlexey Kardashevskiy char mem_name[32]; 52326a8c353SAlexey Kardashevskiy uint64_t mem_reg_property[2]; 52426a8c353SAlexey Kardashevskiy int off; 52526a8c353SAlexey Kardashevskiy 52626a8c353SAlexey Kardashevskiy mem_reg_property[0] = cpu_to_be64(start); 52726a8c353SAlexey Kardashevskiy mem_reg_property[1] = cpu_to_be64(size); 52826a8c353SAlexey Kardashevskiy 52926a8c353SAlexey Kardashevskiy sprintf(mem_name, "memory@" TARGET_FMT_lx, start); 53026a8c353SAlexey Kardashevskiy off = fdt_add_subnode(fdt, 0, mem_name); 53126a8c353SAlexey Kardashevskiy _FDT(off); 53226a8c353SAlexey Kardashevskiy _FDT((fdt_setprop_string(fdt, off, "device_type", "memory"))); 53326a8c353SAlexey Kardashevskiy _FDT((fdt_setprop(fdt, off, "reg", mem_reg_property, 53426a8c353SAlexey Kardashevskiy sizeof(mem_reg_property)))); 53526a8c353SAlexey Kardashevskiy _FDT((fdt_setprop(fdt, off, "ibm,associativity", associativity, 53626a8c353SAlexey Kardashevskiy sizeof(associativity)))); 53703d196b7SBharata B Rao return off; 53826a8c353SAlexey Kardashevskiy } 53926a8c353SAlexey Kardashevskiy 54028e02042SDavid Gibson static int spapr_populate_memory(sPAPRMachineState *spapr, void *fdt) 54153018216SPaolo Bonzini { 542fb164994SDavid Gibson MachineState *machine = MACHINE(spapr); 5437db8a127SAlexey Kardashevskiy hwaddr mem_start, node_size; 5447db8a127SAlexey Kardashevskiy int i, nb_nodes = nb_numa_nodes; 5457db8a127SAlexey Kardashevskiy NodeInfo *nodes = numa_info; 5467db8a127SAlexey Kardashevskiy NodeInfo ramnode; 54753018216SPaolo Bonzini 5487db8a127SAlexey Kardashevskiy /* No NUMA nodes, assume there is just one node with whole RAM */ 5497db8a127SAlexey Kardashevskiy if (!nb_numa_nodes) { 5507db8a127SAlexey Kardashevskiy nb_nodes = 1; 551fb164994SDavid Gibson ramnode.node_mem = machine->ram_size; 5527db8a127SAlexey Kardashevskiy nodes = &ramnode; 5535fe269b1SPaul Mackerras } 55453018216SPaolo Bonzini 5557db8a127SAlexey Kardashevskiy for (i = 0, mem_start = 0; i < nb_nodes; ++i) { 5567db8a127SAlexey Kardashevskiy if (!nodes[i].node_mem) { 5577db8a127SAlexey Kardashevskiy continue; 55853018216SPaolo Bonzini } 559fb164994SDavid Gibson if (mem_start >= machine->ram_size) { 5605fe269b1SPaul Mackerras node_size = 0; 5615fe269b1SPaul Mackerras } else { 5627db8a127SAlexey Kardashevskiy node_size = nodes[i].node_mem; 563fb164994SDavid Gibson if (node_size > machine->ram_size - mem_start) { 564fb164994SDavid Gibson node_size = machine->ram_size - mem_start; 5655fe269b1SPaul Mackerras } 5665fe269b1SPaul Mackerras } 5677db8a127SAlexey Kardashevskiy if (!mem_start) { 5687db8a127SAlexey Kardashevskiy /* ppc_spapr_init() checks for rma_size <= node0_size already */ 569e8f986fcSBharata B Rao spapr_populate_memory_node(fdt, i, 0, spapr->rma_size); 5707db8a127SAlexey Kardashevskiy mem_start += spapr->rma_size; 5717db8a127SAlexey Kardashevskiy node_size -= spapr->rma_size; 5727db8a127SAlexey Kardashevskiy } 5736010818cSAlexey Kardashevskiy for ( ; node_size; ) { 5746010818cSAlexey Kardashevskiy hwaddr sizetmp = pow2floor(node_size); 5756010818cSAlexey Kardashevskiy 5766010818cSAlexey Kardashevskiy /* mem_start != 0 here */ 5776010818cSAlexey Kardashevskiy if (ctzl(mem_start) < ctzl(sizetmp)) { 5786010818cSAlexey Kardashevskiy sizetmp = 1ULL << ctzl(mem_start); 5796010818cSAlexey Kardashevskiy } 5806010818cSAlexey Kardashevskiy 5816010818cSAlexey Kardashevskiy spapr_populate_memory_node(fdt, i, mem_start, sizetmp); 5826010818cSAlexey Kardashevskiy node_size -= sizetmp; 5836010818cSAlexey Kardashevskiy mem_start += sizetmp; 5846010818cSAlexey Kardashevskiy } 58553018216SPaolo Bonzini } 58653018216SPaolo Bonzini 58753018216SPaolo Bonzini return 0; 58853018216SPaolo Bonzini } 58953018216SPaolo Bonzini 5900da6f3feSBharata B Rao static void spapr_populate_cpu_dt(CPUState *cs, void *fdt, int offset, 5910da6f3feSBharata B Rao sPAPRMachineState *spapr) 5920da6f3feSBharata B Rao { 5930da6f3feSBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(cs); 5940da6f3feSBharata B Rao CPUPPCState *env = &cpu->env; 5950da6f3feSBharata B Rao PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(cs); 5960da6f3feSBharata B Rao int index = ppc_get_vcpu_dt_id(cpu); 5970da6f3feSBharata B Rao uint32_t segs[] = {cpu_to_be32(28), cpu_to_be32(40), 5980da6f3feSBharata B Rao 0xffffffff, 0xffffffff}; 5990da6f3feSBharata B Rao uint32_t tbfreq = kvm_enabled() ? kvmppc_get_tbfreq() : TIMEBASE_FREQ; 6000da6f3feSBharata B Rao uint32_t cpufreq = kvm_enabled() ? kvmppc_get_clockfreq() : 1000000000; 6010da6f3feSBharata B Rao uint32_t page_sizes_prop[64]; 6020da6f3feSBharata B Rao size_t page_sizes_prop_size; 60322419c2aSDavid Gibson uint32_t vcpus_per_socket = smp_threads * smp_cores; 6040da6f3feSBharata B Rao uint32_t pft_size_prop[] = {0, cpu_to_be32(spapr->htab_shift)}; 6050da6f3feSBharata B Rao 60690da0d5aSBenjamin Herrenschmidt /* Note: we keep CI large pages off for now because a 64K capable guest 60790da0d5aSBenjamin Herrenschmidt * provisioned with large pages might otherwise try to map a qemu 60890da0d5aSBenjamin Herrenschmidt * framebuffer (or other kind of memory mapped PCI BAR) using 64K pages 60990da0d5aSBenjamin Herrenschmidt * even if that qemu runs on a 4k host. 61090da0d5aSBenjamin Herrenschmidt * 61190da0d5aSBenjamin Herrenschmidt * We can later add this bit back when we are confident this is not 61290da0d5aSBenjamin Herrenschmidt * an issue (!HV KVM or 64K host) 61390da0d5aSBenjamin Herrenschmidt */ 61490da0d5aSBenjamin Herrenschmidt uint8_t pa_features_206[] = { 6, 0, 61590da0d5aSBenjamin Herrenschmidt 0xf6, 0x1f, 0xc7, 0x00, 0x80, 0xc0 }; 61690da0d5aSBenjamin Herrenschmidt uint8_t pa_features_207[] = { 24, 0, 61790da0d5aSBenjamin Herrenschmidt 0xf6, 0x1f, 0xc7, 0xc0, 0x80, 0xf0, 61890da0d5aSBenjamin Herrenschmidt 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 61990da0d5aSBenjamin Herrenschmidt 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 62090da0d5aSBenjamin Herrenschmidt 0x80, 0x00, 0x80, 0x00, 0x80, 0x00 }; 62190da0d5aSBenjamin Herrenschmidt uint8_t *pa_features; 62290da0d5aSBenjamin Herrenschmidt size_t pa_size; 62390da0d5aSBenjamin Herrenschmidt 6240da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "reg", index))); 6250da6f3feSBharata B Rao _FDT((fdt_setprop_string(fdt, offset, "device_type", "cpu"))); 6260da6f3feSBharata B Rao 6270da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "cpu-version", env->spr[SPR_PVR]))); 6280da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "d-cache-block-size", 6290da6f3feSBharata B Rao env->dcache_line_size))); 6300da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "d-cache-line-size", 6310da6f3feSBharata B Rao env->dcache_line_size))); 6320da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "i-cache-block-size", 6330da6f3feSBharata B Rao env->icache_line_size))); 6340da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "i-cache-line-size", 6350da6f3feSBharata B Rao env->icache_line_size))); 6360da6f3feSBharata B Rao 6370da6f3feSBharata B Rao if (pcc->l1_dcache_size) { 6380da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "d-cache-size", 6390da6f3feSBharata B Rao pcc->l1_dcache_size))); 6400da6f3feSBharata B Rao } else { 6410da6f3feSBharata B Rao fprintf(stderr, "Warning: Unknown L1 dcache size for cpu\n"); 6420da6f3feSBharata B Rao } 6430da6f3feSBharata B Rao if (pcc->l1_icache_size) { 6440da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "i-cache-size", 6450da6f3feSBharata B Rao pcc->l1_icache_size))); 6460da6f3feSBharata B Rao } else { 6470da6f3feSBharata B Rao fprintf(stderr, "Warning: Unknown L1 icache size for cpu\n"); 6480da6f3feSBharata B Rao } 6490da6f3feSBharata B Rao 6500da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "timebase-frequency", tbfreq))); 6510da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "clock-frequency", cpufreq))); 652fd5da5c4SThomas Huth _FDT((fdt_setprop_cell(fdt, offset, "slb-size", env->slb_nr))); 6530da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,slb-size", env->slb_nr))); 6540da6f3feSBharata B Rao _FDT((fdt_setprop_string(fdt, offset, "status", "okay"))); 6550da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "64-bit", NULL, 0))); 6560da6f3feSBharata B Rao 6570da6f3feSBharata B Rao if (env->spr_cb[SPR_PURR].oea_read) { 6580da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,purr", NULL, 0))); 6590da6f3feSBharata B Rao } 6600da6f3feSBharata B Rao 6610da6f3feSBharata B Rao if (env->mmu_model & POWERPC_MMU_1TSEG) { 6620da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,processor-segment-sizes", 6630da6f3feSBharata B Rao segs, sizeof(segs)))); 6640da6f3feSBharata B Rao } 6650da6f3feSBharata B Rao 6660da6f3feSBharata B Rao /* Advertise VMX/VSX (vector extensions) if available 6670da6f3feSBharata B Rao * 0 / no property == no vector extensions 6680da6f3feSBharata B Rao * 1 == VMX / Altivec available 6690da6f3feSBharata B Rao * 2 == VSX available */ 6700da6f3feSBharata B Rao if (env->insns_flags & PPC_ALTIVEC) { 6710da6f3feSBharata B Rao uint32_t vmx = (env->insns_flags2 & PPC2_VSX) ? 2 : 1; 6720da6f3feSBharata B Rao 6730da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,vmx", vmx))); 6740da6f3feSBharata B Rao } 6750da6f3feSBharata B Rao 6760da6f3feSBharata B Rao /* Advertise DFP (Decimal Floating Point) if available 6770da6f3feSBharata B Rao * 0 / no property == no DFP 6780da6f3feSBharata B Rao * 1 == DFP available */ 6790da6f3feSBharata B Rao if (env->insns_flags2 & PPC2_DFP) { 6800da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,dfp", 1))); 6810da6f3feSBharata B Rao } 6820da6f3feSBharata B Rao 6830da6f3feSBharata B Rao page_sizes_prop_size = create_page_sizes_prop(env, page_sizes_prop, 6840da6f3feSBharata B Rao sizeof(page_sizes_prop)); 6850da6f3feSBharata B Rao if (page_sizes_prop_size) { 6860da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,segment-page-sizes", 6870da6f3feSBharata B Rao page_sizes_prop, page_sizes_prop_size))); 6880da6f3feSBharata B Rao } 6890da6f3feSBharata B Rao 69090da0d5aSBenjamin Herrenschmidt /* Do the ibm,pa-features property, adjust it for ci-large-pages */ 69190da0d5aSBenjamin Herrenschmidt if (env->mmu_model == POWERPC_MMU_2_06) { 69290da0d5aSBenjamin Herrenschmidt pa_features = pa_features_206; 69390da0d5aSBenjamin Herrenschmidt pa_size = sizeof(pa_features_206); 69490da0d5aSBenjamin Herrenschmidt } else /* env->mmu_model == POWERPC_MMU_2_07 */ { 69590da0d5aSBenjamin Herrenschmidt pa_features = pa_features_207; 69690da0d5aSBenjamin Herrenschmidt pa_size = sizeof(pa_features_207); 69790da0d5aSBenjamin Herrenschmidt } 69890da0d5aSBenjamin Herrenschmidt if (env->ci_large_pages) { 69990da0d5aSBenjamin Herrenschmidt pa_features[3] |= 0x20; 70090da0d5aSBenjamin Herrenschmidt } 70190da0d5aSBenjamin Herrenschmidt _FDT((fdt_setprop(fdt, offset, "ibm,pa-features", pa_features, pa_size))); 70290da0d5aSBenjamin Herrenschmidt 7030da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, offset, "ibm,chip-id", 70422419c2aSDavid Gibson cs->cpu_index / vcpus_per_socket))); 7050da6f3feSBharata B Rao 7060da6f3feSBharata B Rao _FDT((fdt_setprop(fdt, offset, "ibm,pft-size", 7070da6f3feSBharata B Rao pft_size_prop, sizeof(pft_size_prop)))); 7080da6f3feSBharata B Rao 7090da6f3feSBharata B Rao _FDT(spapr_fixup_cpu_numa_dt(fdt, offset, cs)); 7100da6f3feSBharata B Rao 7110da6f3feSBharata B Rao _FDT(spapr_fixup_cpu_smt_dt(fdt, offset, cpu, 7120da6f3feSBharata B Rao ppc_get_compat_smt_threads(cpu))); 7130da6f3feSBharata B Rao } 7140da6f3feSBharata B Rao 7150da6f3feSBharata B Rao static void spapr_populate_cpus_dt_node(void *fdt, sPAPRMachineState *spapr) 7160da6f3feSBharata B Rao { 7170da6f3feSBharata B Rao CPUState *cs; 7180da6f3feSBharata B Rao int cpus_offset; 7190da6f3feSBharata B Rao char *nodename; 7200da6f3feSBharata B Rao int smt = kvmppc_smt_threads(); 7210da6f3feSBharata B Rao 7220da6f3feSBharata B Rao cpus_offset = fdt_add_subnode(fdt, 0, "cpus"); 7230da6f3feSBharata B Rao _FDT(cpus_offset); 7240da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, cpus_offset, "#address-cells", 0x1))); 7250da6f3feSBharata B Rao _FDT((fdt_setprop_cell(fdt, cpus_offset, "#size-cells", 0x0))); 7260da6f3feSBharata B Rao 7270da6f3feSBharata B Rao /* 7280da6f3feSBharata B Rao * We walk the CPUs in reverse order to ensure that CPU DT nodes 7290da6f3feSBharata B Rao * created by fdt_add_subnode() end up in the right order in FDT 7300da6f3feSBharata B Rao * for the guest kernel the enumerate the CPUs correctly. 7310da6f3feSBharata B Rao */ 7320da6f3feSBharata B Rao CPU_FOREACH_REVERSE(cs) { 7330da6f3feSBharata B Rao PowerPCCPU *cpu = POWERPC_CPU(cs); 7340da6f3feSBharata B Rao int index = ppc_get_vcpu_dt_id(cpu); 7350da6f3feSBharata B Rao DeviceClass *dc = DEVICE_GET_CLASS(cs); 7360da6f3feSBharata B Rao int offset; 7370da6f3feSBharata B Rao 7380da6f3feSBharata B Rao if ((index % smt) != 0) { 7390da6f3feSBharata B Rao continue; 7400da6f3feSBharata B Rao } 7410da6f3feSBharata B Rao 7420da6f3feSBharata B Rao nodename = g_strdup_printf("%s@%x", dc->fw_name, index); 7430da6f3feSBharata B Rao offset = fdt_add_subnode(fdt, cpus_offset, nodename); 7440da6f3feSBharata B Rao g_free(nodename); 7450da6f3feSBharata B Rao _FDT(offset); 7460da6f3feSBharata B Rao spapr_populate_cpu_dt(cs, fdt, offset, spapr); 7470da6f3feSBharata B Rao } 7480da6f3feSBharata B Rao 7490da6f3feSBharata B Rao } 7500da6f3feSBharata B Rao 75103d196b7SBharata B Rao /* 75203d196b7SBharata B Rao * Adds ibm,dynamic-reconfiguration-memory node. 75303d196b7SBharata B Rao * Refer to docs/specs/ppc-spapr-hotplug.txt for the documentation 75403d196b7SBharata B Rao * of this device tree node. 75503d196b7SBharata B Rao */ 75603d196b7SBharata B Rao static int spapr_populate_drconf_memory(sPAPRMachineState *spapr, void *fdt) 75703d196b7SBharata B Rao { 75803d196b7SBharata B Rao MachineState *machine = MACHINE(spapr); 75903d196b7SBharata B Rao int ret, i, offset; 76003d196b7SBharata B Rao uint64_t lmb_size = SPAPR_MEMORY_BLOCK_SIZE; 76103d196b7SBharata B Rao uint32_t prop_lmb_size[] = {0, cpu_to_be32(lmb_size)}; 762e8f986fcSBharata B Rao uint32_t nr_lmbs = (machine->maxram_size - machine->ram_size)/lmb_size; 76303d196b7SBharata B Rao uint32_t *int_buf, *cur_index, buf_len; 7646663864eSBharata B Rao int nr_nodes = nb_numa_nodes ? nb_numa_nodes : 1; 76503d196b7SBharata B Rao 766ef001f06SThomas Huth /* 76716c25aefSBharata B Rao * Don't create the node if there are no DR LMBs. 76816c25aefSBharata B Rao */ 76916c25aefSBharata B Rao if (!nr_lmbs) { 77016c25aefSBharata B Rao return 0; 77116c25aefSBharata B Rao } 77216c25aefSBharata B Rao 77316c25aefSBharata B Rao /* 774ef001f06SThomas Huth * Allocate enough buffer size to fit in ibm,dynamic-memory 775ef001f06SThomas Huth * or ibm,associativity-lookup-arrays 776ef001f06SThomas Huth */ 777ef001f06SThomas Huth buf_len = MAX(nr_lmbs * SPAPR_DR_LMB_LIST_ENTRY_SIZE + 1, nr_nodes * 4 + 2) 778ef001f06SThomas Huth * sizeof(uint32_t); 77903d196b7SBharata B Rao cur_index = int_buf = g_malloc0(buf_len); 78003d196b7SBharata B Rao 78103d196b7SBharata B Rao offset = fdt_add_subnode(fdt, 0, "ibm,dynamic-reconfiguration-memory"); 78203d196b7SBharata B Rao 78303d196b7SBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,lmb-size", prop_lmb_size, 78403d196b7SBharata B Rao sizeof(prop_lmb_size)); 78503d196b7SBharata B Rao if (ret < 0) { 78603d196b7SBharata B Rao goto out; 78703d196b7SBharata B Rao } 78803d196b7SBharata B Rao 78903d196b7SBharata B Rao ret = fdt_setprop_cell(fdt, offset, "ibm,memory-flags-mask", 0xff); 79003d196b7SBharata B Rao if (ret < 0) { 79103d196b7SBharata B Rao goto out; 79203d196b7SBharata B Rao } 79303d196b7SBharata B Rao 79403d196b7SBharata B Rao ret = fdt_setprop_cell(fdt, offset, "ibm,memory-preservation-time", 0x0); 79503d196b7SBharata B Rao if (ret < 0) { 79603d196b7SBharata B Rao goto out; 79703d196b7SBharata B Rao } 79803d196b7SBharata B Rao 79903d196b7SBharata B Rao /* ibm,dynamic-memory */ 80003d196b7SBharata B Rao int_buf[0] = cpu_to_be32(nr_lmbs); 80103d196b7SBharata B Rao cur_index++; 80203d196b7SBharata B Rao for (i = 0; i < nr_lmbs; i++) { 80303d196b7SBharata B Rao sPAPRDRConnector *drc; 80403d196b7SBharata B Rao sPAPRDRConnectorClass *drck; 805e8f986fcSBharata B Rao uint64_t addr = i * lmb_size + spapr->hotplug_memory.base;; 80603d196b7SBharata B Rao uint32_t *dynamic_memory = cur_index; 80703d196b7SBharata B Rao 80803d196b7SBharata B Rao drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_LMB, 80903d196b7SBharata B Rao addr/lmb_size); 81003d196b7SBharata B Rao g_assert(drc); 81103d196b7SBharata B Rao drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 81203d196b7SBharata B Rao 81303d196b7SBharata B Rao dynamic_memory[0] = cpu_to_be32(addr >> 32); 81403d196b7SBharata B Rao dynamic_memory[1] = cpu_to_be32(addr & 0xffffffff); 81503d196b7SBharata B Rao dynamic_memory[2] = cpu_to_be32(drck->get_index(drc)); 81603d196b7SBharata B Rao dynamic_memory[3] = cpu_to_be32(0); /* reserved */ 81703d196b7SBharata B Rao dynamic_memory[4] = cpu_to_be32(numa_get_node(addr, NULL)); 81803d196b7SBharata B Rao if (addr < machine->ram_size || 81903d196b7SBharata B Rao memory_region_present(get_system_memory(), addr)) { 82003d196b7SBharata B Rao dynamic_memory[5] = cpu_to_be32(SPAPR_LMB_FLAGS_ASSIGNED); 82103d196b7SBharata B Rao } else { 82203d196b7SBharata B Rao dynamic_memory[5] = cpu_to_be32(0); 82303d196b7SBharata B Rao } 82403d196b7SBharata B Rao 82503d196b7SBharata B Rao cur_index += SPAPR_DR_LMB_LIST_ENTRY_SIZE; 82603d196b7SBharata B Rao } 82703d196b7SBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,dynamic-memory", int_buf, buf_len); 82803d196b7SBharata B Rao if (ret < 0) { 82903d196b7SBharata B Rao goto out; 83003d196b7SBharata B Rao } 83103d196b7SBharata B Rao 83203d196b7SBharata B Rao /* ibm,associativity-lookup-arrays */ 83303d196b7SBharata B Rao cur_index = int_buf; 8346663864eSBharata B Rao int_buf[0] = cpu_to_be32(nr_nodes); 83503d196b7SBharata B Rao int_buf[1] = cpu_to_be32(4); /* Number of entries per associativity list */ 83603d196b7SBharata B Rao cur_index += 2; 8376663864eSBharata B Rao for (i = 0; i < nr_nodes; i++) { 83803d196b7SBharata B Rao uint32_t associativity[] = { 83903d196b7SBharata B Rao cpu_to_be32(0x0), 84003d196b7SBharata B Rao cpu_to_be32(0x0), 84103d196b7SBharata B Rao cpu_to_be32(0x0), 84203d196b7SBharata B Rao cpu_to_be32(i) 84303d196b7SBharata B Rao }; 84403d196b7SBharata B Rao memcpy(cur_index, associativity, sizeof(associativity)); 84503d196b7SBharata B Rao cur_index += 4; 84603d196b7SBharata B Rao } 84703d196b7SBharata B Rao ret = fdt_setprop(fdt, offset, "ibm,associativity-lookup-arrays", int_buf, 84803d196b7SBharata B Rao (cur_index - int_buf) * sizeof(uint32_t)); 84903d196b7SBharata B Rao out: 85003d196b7SBharata B Rao g_free(int_buf); 85103d196b7SBharata B Rao return ret; 85203d196b7SBharata B Rao } 85303d196b7SBharata B Rao 85403d196b7SBharata B Rao int spapr_h_cas_compose_response(sPAPRMachineState *spapr, 85503d196b7SBharata B Rao target_ulong addr, target_ulong size, 85603d196b7SBharata B Rao bool cpu_update, bool memory_update) 85703d196b7SBharata B Rao { 85803d196b7SBharata B Rao void *fdt, *fdt_skel; 85903d196b7SBharata B Rao sPAPRDeviceTreeUpdateHeader hdr = { .version_id = 1 }; 86003d196b7SBharata B Rao sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(qdev_get_machine()); 86103d196b7SBharata B Rao 86203d196b7SBharata B Rao size -= sizeof(hdr); 86303d196b7SBharata B Rao 86403d196b7SBharata B Rao /* Create sceleton */ 86503d196b7SBharata B Rao fdt_skel = g_malloc0(size); 86603d196b7SBharata B Rao _FDT((fdt_create(fdt_skel, size))); 86703d196b7SBharata B Rao _FDT((fdt_begin_node(fdt_skel, ""))); 86803d196b7SBharata B Rao _FDT((fdt_end_node(fdt_skel))); 86903d196b7SBharata B Rao _FDT((fdt_finish(fdt_skel))); 87003d196b7SBharata B Rao fdt = g_malloc0(size); 87103d196b7SBharata B Rao _FDT((fdt_open_into(fdt_skel, fdt, size))); 87203d196b7SBharata B Rao g_free(fdt_skel); 87303d196b7SBharata B Rao 87403d196b7SBharata B Rao /* Fixup cpu nodes */ 87503d196b7SBharata B Rao if (cpu_update) { 87603d196b7SBharata B Rao _FDT((spapr_fixup_cpu_dt(fdt, spapr))); 87703d196b7SBharata B Rao } 87803d196b7SBharata B Rao 87916c25aefSBharata B Rao /* Generate ibm,dynamic-reconfiguration-memory node if required */ 88003d196b7SBharata B Rao if (memory_update && smc->dr_lmb_enabled) { 88103d196b7SBharata B Rao _FDT((spapr_populate_drconf_memory(spapr, fdt))); 88203d196b7SBharata B Rao } 88303d196b7SBharata B Rao 88403d196b7SBharata B Rao /* Pack resulting tree */ 88503d196b7SBharata B Rao _FDT((fdt_pack(fdt))); 88603d196b7SBharata B Rao 88703d196b7SBharata B Rao if (fdt_totalsize(fdt) + sizeof(hdr) > size) { 88803d196b7SBharata B Rao trace_spapr_cas_failed(size); 88903d196b7SBharata B Rao return -1; 89003d196b7SBharata B Rao } 89103d196b7SBharata B Rao 89203d196b7SBharata B Rao cpu_physical_memory_write(addr, &hdr, sizeof(hdr)); 89303d196b7SBharata B Rao cpu_physical_memory_write(addr + sizeof(hdr), fdt, fdt_totalsize(fdt)); 89403d196b7SBharata B Rao trace_spapr_cas_continue(fdt_totalsize(fdt) + sizeof(hdr)); 89503d196b7SBharata B Rao g_free(fdt); 89603d196b7SBharata B Rao 89703d196b7SBharata B Rao return 0; 89803d196b7SBharata B Rao } 89903d196b7SBharata B Rao 90028e02042SDavid Gibson static void spapr_finalize_fdt(sPAPRMachineState *spapr, 90153018216SPaolo Bonzini hwaddr fdt_addr, 90253018216SPaolo Bonzini hwaddr rtas_addr, 90353018216SPaolo Bonzini hwaddr rtas_size) 90453018216SPaolo Bonzini { 9055b2128d2SAlexander Graf MachineState *machine = MACHINE(qdev_get_machine()); 906c20d332aSBharata B Rao sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(machine); 9075b2128d2SAlexander Graf const char *boot_device = machine->boot_order; 90871461b0fSAlexey Kardashevskiy int ret, i; 90971461b0fSAlexey Kardashevskiy size_t cb = 0; 91071461b0fSAlexey Kardashevskiy char *bootlist; 91153018216SPaolo Bonzini void *fdt; 91253018216SPaolo Bonzini sPAPRPHBState *phb; 91353018216SPaolo Bonzini 91453018216SPaolo Bonzini fdt = g_malloc(FDT_MAX_SIZE); 91553018216SPaolo Bonzini 91653018216SPaolo Bonzini /* open out the base tree into a temp buffer for the final tweaks */ 91753018216SPaolo Bonzini _FDT((fdt_open_into(spapr->fdt_skel, fdt, FDT_MAX_SIZE))); 91853018216SPaolo Bonzini 919e8f986fcSBharata B Rao ret = spapr_populate_memory(spapr, fdt); 920e8f986fcSBharata B Rao if (ret < 0) { 921e8f986fcSBharata B Rao fprintf(stderr, "couldn't setup memory nodes in fdt\n"); 922e8f986fcSBharata B Rao exit(1); 92353018216SPaolo Bonzini } 92453018216SPaolo Bonzini 92553018216SPaolo Bonzini ret = spapr_populate_vdevice(spapr->vio_bus, fdt); 92653018216SPaolo Bonzini if (ret < 0) { 92753018216SPaolo Bonzini fprintf(stderr, "couldn't setup vio devices in fdt\n"); 92853018216SPaolo Bonzini exit(1); 92953018216SPaolo Bonzini } 93053018216SPaolo Bonzini 9314d9392beSThomas Huth if (object_resolve_path_type("", TYPE_SPAPR_RNG, NULL)) { 9324d9392beSThomas Huth ret = spapr_rng_populate_dt(fdt); 9334d9392beSThomas Huth if (ret < 0) { 9344d9392beSThomas Huth fprintf(stderr, "could not set up rng device in the fdt\n"); 9354d9392beSThomas Huth exit(1); 9364d9392beSThomas Huth } 9374d9392beSThomas Huth } 9384d9392beSThomas Huth 93953018216SPaolo Bonzini QLIST_FOREACH(phb, &spapr->phbs, list) { 94053018216SPaolo Bonzini ret = spapr_populate_pci_dt(phb, PHANDLE_XICP, fdt); 94153018216SPaolo Bonzini } 94253018216SPaolo Bonzini 94353018216SPaolo Bonzini if (ret < 0) { 94453018216SPaolo Bonzini fprintf(stderr, "couldn't setup PCI devices in fdt\n"); 94553018216SPaolo Bonzini exit(1); 94653018216SPaolo Bonzini } 94753018216SPaolo Bonzini 94853018216SPaolo Bonzini /* RTAS */ 94953018216SPaolo Bonzini ret = spapr_rtas_device_tree_setup(fdt, rtas_addr, rtas_size); 95053018216SPaolo Bonzini if (ret < 0) { 95153018216SPaolo Bonzini fprintf(stderr, "Couldn't set up RTAS device tree properties\n"); 95253018216SPaolo Bonzini } 95353018216SPaolo Bonzini 9540da6f3feSBharata B Rao /* cpus */ 9550da6f3feSBharata B Rao spapr_populate_cpus_dt_node(fdt, spapr); 95653018216SPaolo Bonzini 95771461b0fSAlexey Kardashevskiy bootlist = get_boot_devices_list(&cb, true); 95871461b0fSAlexey Kardashevskiy if (cb && bootlist) { 95971461b0fSAlexey Kardashevskiy int offset = fdt_path_offset(fdt, "/chosen"); 96071461b0fSAlexey Kardashevskiy if (offset < 0) { 96171461b0fSAlexey Kardashevskiy exit(1); 96271461b0fSAlexey Kardashevskiy } 96371461b0fSAlexey Kardashevskiy for (i = 0; i < cb; i++) { 96471461b0fSAlexey Kardashevskiy if (bootlist[i] == '\n') { 96571461b0fSAlexey Kardashevskiy bootlist[i] = ' '; 96671461b0fSAlexey Kardashevskiy } 96771461b0fSAlexey Kardashevskiy 96871461b0fSAlexey Kardashevskiy } 96971461b0fSAlexey Kardashevskiy ret = fdt_setprop_string(fdt, offset, "qemu,boot-list", bootlist); 97071461b0fSAlexey Kardashevskiy } 97171461b0fSAlexey Kardashevskiy 9725b2128d2SAlexander Graf if (boot_device && strlen(boot_device)) { 9735b2128d2SAlexander Graf int offset = fdt_path_offset(fdt, "/chosen"); 9745b2128d2SAlexander Graf 9755b2128d2SAlexander Graf if (offset < 0) { 9765b2128d2SAlexander Graf exit(1); 9775b2128d2SAlexander Graf } 9785b2128d2SAlexander Graf fdt_setprop_string(fdt, offset, "qemu,boot-device", boot_device); 9795b2128d2SAlexander Graf } 9805b2128d2SAlexander Graf 98153018216SPaolo Bonzini if (!spapr->has_graphics) { 98253018216SPaolo Bonzini spapr_populate_chosen_stdout(fdt, spapr->vio_bus); 98353018216SPaolo Bonzini } 98453018216SPaolo Bonzini 985c20d332aSBharata B Rao if (smc->dr_lmb_enabled) { 986c20d332aSBharata B Rao _FDT(spapr_drc_populate_dt(fdt, 0, NULL, SPAPR_DR_CONNECTOR_TYPE_LMB)); 987c20d332aSBharata B Rao } 988c20d332aSBharata B Rao 98953018216SPaolo Bonzini _FDT((fdt_pack(fdt))); 99053018216SPaolo Bonzini 99153018216SPaolo Bonzini if (fdt_totalsize(fdt) > FDT_MAX_SIZE) { 992730fce59SThomas Huth error_report("FDT too big ! 0x%x bytes (max is 0x%x)", 99353018216SPaolo Bonzini fdt_totalsize(fdt), FDT_MAX_SIZE); 99453018216SPaolo Bonzini exit(1); 99553018216SPaolo Bonzini } 99653018216SPaolo Bonzini 997ad440b4aSAndrew Jones qemu_fdt_dumpdtb(fdt, fdt_totalsize(fdt)); 99853018216SPaolo Bonzini cpu_physical_memory_write(fdt_addr, fdt, fdt_totalsize(fdt)); 99953018216SPaolo Bonzini 1000a21a7a70SGonglei g_free(bootlist); 100153018216SPaolo Bonzini g_free(fdt); 100253018216SPaolo Bonzini } 100353018216SPaolo Bonzini 100453018216SPaolo Bonzini static uint64_t translate_kernel_address(void *opaque, uint64_t addr) 100553018216SPaolo Bonzini { 100653018216SPaolo Bonzini return (addr & 0x0fffffff) + KERNEL_LOAD_ADDR; 100753018216SPaolo Bonzini } 100853018216SPaolo Bonzini 100953018216SPaolo Bonzini static void emulate_spapr_hypercall(PowerPCCPU *cpu) 101053018216SPaolo Bonzini { 101153018216SPaolo Bonzini CPUPPCState *env = &cpu->env; 101253018216SPaolo Bonzini 101353018216SPaolo Bonzini if (msr_pr) { 101453018216SPaolo Bonzini hcall_dprintf("Hypercall made with MSR[PR]=1\n"); 101553018216SPaolo Bonzini env->gpr[3] = H_PRIVILEGE; 101653018216SPaolo Bonzini } else { 101753018216SPaolo Bonzini env->gpr[3] = spapr_hypercall(cpu, env->gpr[3], &env->gpr[4]); 101853018216SPaolo Bonzini } 101953018216SPaolo Bonzini } 102053018216SPaolo Bonzini 1021e6b8fd24SSamuel Mendoza-Jonas #define HPTE(_table, _i) (void *)(((uint64_t *)(_table)) + ((_i) * 2)) 1022e6b8fd24SSamuel Mendoza-Jonas #define HPTE_VALID(_hpte) (tswap64(*((uint64_t *)(_hpte))) & HPTE64_V_VALID) 1023e6b8fd24SSamuel Mendoza-Jonas #define HPTE_DIRTY(_hpte) (tswap64(*((uint64_t *)(_hpte))) & HPTE64_V_HPTE_DIRTY) 1024e6b8fd24SSamuel Mendoza-Jonas #define CLEAN_HPTE(_hpte) ((*(uint64_t *)(_hpte)) &= tswap64(~HPTE64_V_HPTE_DIRTY)) 1025e6b8fd24SSamuel Mendoza-Jonas #define DIRTY_HPTE(_hpte) ((*(uint64_t *)(_hpte)) |= tswap64(HPTE64_V_HPTE_DIRTY)) 1026e6b8fd24SSamuel Mendoza-Jonas 1027b817772aSBharata B Rao static void spapr_alloc_htab(sPAPRMachineState *spapr) 102853018216SPaolo Bonzini { 102953018216SPaolo Bonzini long shift; 1030e6b8fd24SSamuel Mendoza-Jonas int index; 103153018216SPaolo Bonzini 103253018216SPaolo Bonzini /* allocate hash page table. For now we always make this 16mb, 103353018216SPaolo Bonzini * later we should probably make it scale to the size of guest 103453018216SPaolo Bonzini * RAM */ 103553018216SPaolo Bonzini 103653018216SPaolo Bonzini shift = kvmppc_reset_htab(spapr->htab_shift); 1037b41d320fSBharata B Rao if (shift < 0) { 1038b41d320fSBharata B Rao /* 1039b41d320fSBharata B Rao * For HV KVM, host kernel will return -ENOMEM when requested 1040b41d320fSBharata B Rao * HTAB size can't be allocated. 1041b41d320fSBharata B Rao */ 1042b41d320fSBharata B Rao error_setg(&error_abort, "Failed to allocate HTAB of requested size, try with smaller maxmem"); 1043b41d320fSBharata B Rao } else if (shift > 0) { 1044b41d320fSBharata B Rao /* 1045b41d320fSBharata B Rao * Kernel handles htab, we don't need to allocate one 1046b41d320fSBharata B Rao * 1047b41d320fSBharata B Rao * Older kernels can fall back to lower HTAB shift values, 1048b41d320fSBharata B Rao * but we don't allow booting of such guests. 1049b41d320fSBharata B Rao */ 10507735fedaSBharata B Rao if (shift != spapr->htab_shift) { 10517735fedaSBharata B Rao error_setg(&error_abort, "Failed to allocate HTAB of requested size, try with smaller maxmem"); 10527735fedaSBharata B Rao } 10537735fedaSBharata B Rao 105453018216SPaolo Bonzini spapr->htab_shift = shift; 10557c43bca0SAneesh Kumar K.V kvmppc_kern_htab = true; 1056b817772aSBharata B Rao } else { 1057b817772aSBharata B Rao /* Allocate htab */ 1058b817772aSBharata B Rao spapr->htab = qemu_memalign(HTAB_SIZE(spapr), HTAB_SIZE(spapr)); 105901a57972SSamuel Mendoza-Jonas 1060b817772aSBharata B Rao /* And clear it */ 1061b817772aSBharata B Rao memset(spapr->htab, 0, HTAB_SIZE(spapr)); 1062b817772aSBharata B Rao 1063b817772aSBharata B Rao for (index = 0; index < HTAB_SIZE(spapr) / HASH_PTE_SIZE_64; index++) { 1064b817772aSBharata B Rao DIRTY_HPTE(HPTE(spapr->htab, index)); 1065b817772aSBharata B Rao } 1066b817772aSBharata B Rao } 1067b817772aSBharata B Rao } 1068b817772aSBharata B Rao 1069b817772aSBharata B Rao /* 1070b817772aSBharata B Rao * Clear HTAB entries during reset. 1071b817772aSBharata B Rao * 1072b817772aSBharata B Rao * If host kernel has allocated HTAB, KVM_PPC_ALLOCATE_HTAB ioctl is 1073b817772aSBharata B Rao * used to clear HTAB. Otherwise QEMU-allocated HTAB is cleared manually. 1074b817772aSBharata B Rao */ 1075b817772aSBharata B Rao static void spapr_reset_htab(sPAPRMachineState *spapr) 1076b817772aSBharata B Rao { 1077b817772aSBharata B Rao long shift; 1078b817772aSBharata B Rao int index; 1079b817772aSBharata B Rao 1080b817772aSBharata B Rao shift = kvmppc_reset_htab(spapr->htab_shift); 1081b41d320fSBharata B Rao if (shift < 0) { 1082b41d320fSBharata B Rao error_setg(&error_abort, "Failed to reset HTAB"); 1083b41d320fSBharata B Rao } else if (shift > 0) { 10847735fedaSBharata B Rao if (shift != spapr->htab_shift) { 10857735fedaSBharata B Rao error_setg(&error_abort, "Requested HTAB allocation failed during reset"); 10867735fedaSBharata B Rao } 10877735fedaSBharata B Rao 108801a57972SSamuel Mendoza-Jonas /* Tell readers to update their file descriptor */ 108901a57972SSamuel Mendoza-Jonas if (spapr->htab_fd >= 0) { 109001a57972SSamuel Mendoza-Jonas spapr->htab_fd_stale = true; 109101a57972SSamuel Mendoza-Jonas } 109253018216SPaolo Bonzini } else { 109353018216SPaolo Bonzini memset(spapr->htab, 0, HTAB_SIZE(spapr)); 1094e6b8fd24SSamuel Mendoza-Jonas 1095e6b8fd24SSamuel Mendoza-Jonas for (index = 0; index < HTAB_SIZE(spapr) / HASH_PTE_SIZE_64; index++) { 1096e6b8fd24SSamuel Mendoza-Jonas DIRTY_HPTE(HPTE(spapr->htab, index)); 1097e6b8fd24SSamuel Mendoza-Jonas } 109853018216SPaolo Bonzini } 109953018216SPaolo Bonzini 110053018216SPaolo Bonzini /* Update the RMA size if necessary */ 110153018216SPaolo Bonzini if (spapr->vrma_adjust) { 1102b082d65aSAlexey Kardashevskiy spapr->rma_size = kvmppc_rma_size(spapr_node0_size(), 1103b082d65aSAlexey Kardashevskiy spapr->htab_shift); 110453018216SPaolo Bonzini } 110553018216SPaolo Bonzini } 110653018216SPaolo Bonzini 11079e3f9733SAlexander Graf static int find_unknown_sysbus_device(SysBusDevice *sbdev, void *opaque) 11089e3f9733SAlexander Graf { 11099e3f9733SAlexander Graf bool matched = false; 11109e3f9733SAlexander Graf 11119e3f9733SAlexander Graf if (object_dynamic_cast(OBJECT(sbdev), TYPE_SPAPR_PCI_HOST_BRIDGE)) { 11129e3f9733SAlexander Graf matched = true; 11139e3f9733SAlexander Graf } 11149e3f9733SAlexander Graf 11159e3f9733SAlexander Graf if (!matched) { 11169e3f9733SAlexander Graf error_report("Device %s is not supported by this machine yet.", 11179e3f9733SAlexander Graf qdev_fw_name(DEVICE(sbdev))); 11189e3f9733SAlexander Graf exit(1); 11199e3f9733SAlexander Graf } 11209e3f9733SAlexander Graf 11219e3f9733SAlexander Graf return 0; 11229e3f9733SAlexander Graf } 11239e3f9733SAlexander Graf 112401a57972SSamuel Mendoza-Jonas /* 112501a57972SSamuel Mendoza-Jonas * A guest reset will cause spapr->htab_fd to become stale if being used. 112601a57972SSamuel Mendoza-Jonas * Reopen the file descriptor to make sure the whole HTAB is properly read. 112701a57972SSamuel Mendoza-Jonas */ 112828e02042SDavid Gibson static int spapr_check_htab_fd(sPAPRMachineState *spapr) 112901a57972SSamuel Mendoza-Jonas { 113001a57972SSamuel Mendoza-Jonas int rc = 0; 113101a57972SSamuel Mendoza-Jonas 113201a57972SSamuel Mendoza-Jonas if (spapr->htab_fd_stale) { 113301a57972SSamuel Mendoza-Jonas close(spapr->htab_fd); 113401a57972SSamuel Mendoza-Jonas spapr->htab_fd = kvmppc_get_htab_fd(false); 113501a57972SSamuel Mendoza-Jonas if (spapr->htab_fd < 0) { 113601a57972SSamuel Mendoza-Jonas error_report("Unable to open fd for reading hash table from KVM: " 113701a57972SSamuel Mendoza-Jonas "%s", strerror(errno)); 113801a57972SSamuel Mendoza-Jonas rc = -1; 113901a57972SSamuel Mendoza-Jonas } 114001a57972SSamuel Mendoza-Jonas spapr->htab_fd_stale = false; 114101a57972SSamuel Mendoza-Jonas } 114201a57972SSamuel Mendoza-Jonas 114301a57972SSamuel Mendoza-Jonas return rc; 114401a57972SSamuel Mendoza-Jonas } 114501a57972SSamuel Mendoza-Jonas 114653018216SPaolo Bonzini static void ppc_spapr_reset(void) 114753018216SPaolo Bonzini { 114828e02042SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(qdev_get_machine()); 1149182735efSAndreas Färber PowerPCCPU *first_ppc_cpu; 1150b7d1f77aSBenjamin Herrenschmidt uint32_t rtas_limit; 1151259186a7SAndreas Färber 11529e3f9733SAlexander Graf /* Check for unknown sysbus devices */ 11539e3f9733SAlexander Graf foreach_dynamic_sysbus_device(find_unknown_sysbus_device, NULL); 11549e3f9733SAlexander Graf 115553018216SPaolo Bonzini /* Reset the hash table & recalc the RMA */ 115653018216SPaolo Bonzini spapr_reset_htab(spapr); 115753018216SPaolo Bonzini 115853018216SPaolo Bonzini qemu_devices_reset(); 115953018216SPaolo Bonzini 1160b7d1f77aSBenjamin Herrenschmidt /* 1161b7d1f77aSBenjamin Herrenschmidt * We place the device tree and RTAS just below either the top of the RMA, 1162b7d1f77aSBenjamin Herrenschmidt * or just below 2GB, whichever is lowere, so that it can be 1163b7d1f77aSBenjamin Herrenschmidt * processed with 32-bit real mode code if necessary 1164b7d1f77aSBenjamin Herrenschmidt */ 1165b7d1f77aSBenjamin Herrenschmidt rtas_limit = MIN(spapr->rma_size, RTAS_MAX_ADDR); 1166b7d1f77aSBenjamin Herrenschmidt spapr->rtas_addr = rtas_limit - RTAS_MAX_SIZE; 1167b7d1f77aSBenjamin Herrenschmidt spapr->fdt_addr = spapr->rtas_addr - FDT_MAX_SIZE; 1168b7d1f77aSBenjamin Herrenschmidt 116953018216SPaolo Bonzini /* Load the fdt */ 117053018216SPaolo Bonzini spapr_finalize_fdt(spapr, spapr->fdt_addr, spapr->rtas_addr, 117153018216SPaolo Bonzini spapr->rtas_size); 117253018216SPaolo Bonzini 1173b7d1f77aSBenjamin Herrenschmidt /* Copy RTAS over */ 1174b7d1f77aSBenjamin Herrenschmidt cpu_physical_memory_write(spapr->rtas_addr, spapr->rtas_blob, 1175b7d1f77aSBenjamin Herrenschmidt spapr->rtas_size); 1176b7d1f77aSBenjamin Herrenschmidt 117753018216SPaolo Bonzini /* Set up the entry state */ 1178182735efSAndreas Färber first_ppc_cpu = POWERPC_CPU(first_cpu); 1179182735efSAndreas Färber first_ppc_cpu->env.gpr[3] = spapr->fdt_addr; 1180182735efSAndreas Färber first_ppc_cpu->env.gpr[5] = 0; 1181182735efSAndreas Färber first_cpu->halted = 0; 11821b718907SDavid Gibson first_ppc_cpu->env.nip = SPAPR_ENTRY_POINT; 118353018216SPaolo Bonzini 118453018216SPaolo Bonzini } 118553018216SPaolo Bonzini 118653018216SPaolo Bonzini static void spapr_cpu_reset(void *opaque) 118753018216SPaolo Bonzini { 118828e02042SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(qdev_get_machine()); 118953018216SPaolo Bonzini PowerPCCPU *cpu = opaque; 1190259186a7SAndreas Färber CPUState *cs = CPU(cpu); 119153018216SPaolo Bonzini CPUPPCState *env = &cpu->env; 119253018216SPaolo Bonzini 1193259186a7SAndreas Färber cpu_reset(cs); 119453018216SPaolo Bonzini 119553018216SPaolo Bonzini /* All CPUs start halted. CPU0 is unhalted from the machine level 119653018216SPaolo Bonzini * reset code and the rest are explicitly started up by the guest 119753018216SPaolo Bonzini * using an RTAS call */ 1198259186a7SAndreas Färber cs->halted = 1; 119953018216SPaolo Bonzini 120053018216SPaolo Bonzini env->spr[SPR_HIOR] = 0; 120153018216SPaolo Bonzini 12024be21d56SDavid Gibson env->external_htab = (uint8_t *)spapr->htab; 12035736245cSAneesh Kumar K.V if (kvm_enabled() && !env->external_htab) { 12045736245cSAneesh Kumar K.V /* 12055736245cSAneesh Kumar K.V * HV KVM, set external_htab to 1 so our ppc_hash64_load_hpte* 12065736245cSAneesh Kumar K.V * functions do the right thing. 12075736245cSAneesh Kumar K.V */ 12085736245cSAneesh Kumar K.V env->external_htab = (void *)1; 12095736245cSAneesh Kumar K.V } 121053018216SPaolo Bonzini env->htab_base = -1; 1211f3c75d42SAneesh Kumar K.V /* 1212f3c75d42SAneesh Kumar K.V * htab_mask is the mask used to normalize hash value to PTEG index. 1213f3c75d42SAneesh Kumar K.V * htab_shift is log2 of hash table size. 1214f3c75d42SAneesh Kumar K.V * We have 8 hpte per group, and each hpte is 16 bytes. 1215f3c75d42SAneesh Kumar K.V * ie have 128 bytes per hpte entry. 1216f3c75d42SAneesh Kumar K.V */ 121728e02042SDavid Gibson env->htab_mask = (1ULL << (spapr->htab_shift - 7)) - 1; 1218ec4936e1SStefan Weil env->spr[SPR_SDR1] = (target_ulong)(uintptr_t)spapr->htab | 121953018216SPaolo Bonzini (spapr->htab_shift - 18); 122053018216SPaolo Bonzini } 122153018216SPaolo Bonzini 122228e02042SDavid Gibson static void spapr_create_nvram(sPAPRMachineState *spapr) 122353018216SPaolo Bonzini { 12242ff3de68SMarkus Armbruster DeviceState *dev = qdev_create(&spapr->vio_bus->bus, "spapr-nvram"); 12253978b863SPaolo Bonzini DriveInfo *dinfo = drive_get(IF_PFLASH, 0, 0); 122653018216SPaolo Bonzini 12273978b863SPaolo Bonzini if (dinfo) { 12286231a6daSMarkus Armbruster qdev_prop_set_drive(dev, "drive", blk_by_legacy_dinfo(dinfo), 12296231a6daSMarkus Armbruster &error_fatal); 123053018216SPaolo Bonzini } 123153018216SPaolo Bonzini 123253018216SPaolo Bonzini qdev_init_nofail(dev); 123353018216SPaolo Bonzini 123453018216SPaolo Bonzini spapr->nvram = (struct sPAPRNVRAM *)dev; 123553018216SPaolo Bonzini } 123653018216SPaolo Bonzini 123728e02042SDavid Gibson static void spapr_rtc_create(sPAPRMachineState *spapr) 123828df36a1SDavid Gibson { 123928df36a1SDavid Gibson DeviceState *dev = qdev_create(NULL, TYPE_SPAPR_RTC); 124028df36a1SDavid Gibson 124128df36a1SDavid Gibson qdev_init_nofail(dev); 124228df36a1SDavid Gibson spapr->rtc = dev; 124374e5ae28SDavid Gibson 124474e5ae28SDavid Gibson object_property_add_alias(qdev_get_machine(), "rtc-time", 124574e5ae28SDavid Gibson OBJECT(spapr->rtc), "date", NULL); 124628df36a1SDavid Gibson } 124728df36a1SDavid Gibson 124853018216SPaolo Bonzini /* Returns whether we want to use VGA or not */ 124914c6a894SDavid Gibson static bool spapr_vga_init(PCIBus *pci_bus, Error **errp) 125053018216SPaolo Bonzini { 125153018216SPaolo Bonzini switch (vga_interface_type) { 125253018216SPaolo Bonzini case VGA_NONE: 12537effdaa3SMark Wu return false; 12547effdaa3SMark Wu case VGA_DEVICE: 12557effdaa3SMark Wu return true; 125653018216SPaolo Bonzini case VGA_STD: 1257b798c190SBenjamin Herrenschmidt case VGA_VIRTIO: 125853018216SPaolo Bonzini return pci_vga_init(pci_bus) != NULL; 125953018216SPaolo Bonzini default: 126014c6a894SDavid Gibson error_setg(errp, 126114c6a894SDavid Gibson "Unsupported VGA mode, only -vga std or -vga virtio is supported"); 126214c6a894SDavid Gibson return false; 126353018216SPaolo Bonzini } 126453018216SPaolo Bonzini } 126553018216SPaolo Bonzini 1266880ae7deSDavid Gibson static int spapr_post_load(void *opaque, int version_id) 1267880ae7deSDavid Gibson { 126828e02042SDavid Gibson sPAPRMachineState *spapr = (sPAPRMachineState *)opaque; 1269880ae7deSDavid Gibson int err = 0; 1270880ae7deSDavid Gibson 1271631b22eaSStefan Weil /* In earlier versions, there was no separate qdev for the PAPR 1272880ae7deSDavid Gibson * RTC, so the RTC offset was stored directly in sPAPREnvironment. 1273880ae7deSDavid Gibson * So when migrating from those versions, poke the incoming offset 1274880ae7deSDavid Gibson * value into the RTC device */ 1275880ae7deSDavid Gibson if (version_id < 3) { 1276880ae7deSDavid Gibson err = spapr_rtc_import_offset(spapr->rtc, spapr->rtc_offset); 1277880ae7deSDavid Gibson } 1278880ae7deSDavid Gibson 1279880ae7deSDavid Gibson return err; 1280880ae7deSDavid Gibson } 1281880ae7deSDavid Gibson 1282880ae7deSDavid Gibson static bool version_before_3(void *opaque, int version_id) 1283880ae7deSDavid Gibson { 1284880ae7deSDavid Gibson return version_id < 3; 1285880ae7deSDavid Gibson } 1286880ae7deSDavid Gibson 12874be21d56SDavid Gibson static const VMStateDescription vmstate_spapr = { 12884be21d56SDavid Gibson .name = "spapr", 1289880ae7deSDavid Gibson .version_id = 3, 12904be21d56SDavid Gibson .minimum_version_id = 1, 1291880ae7deSDavid Gibson .post_load = spapr_post_load, 12924be21d56SDavid Gibson .fields = (VMStateField[]) { 1293880ae7deSDavid Gibson /* used to be @next_irq */ 1294880ae7deSDavid Gibson VMSTATE_UNUSED_BUFFER(version_before_3, 0, 4), 12954be21d56SDavid Gibson 12964be21d56SDavid Gibson /* RTC offset */ 129728e02042SDavid Gibson VMSTATE_UINT64_TEST(rtc_offset, sPAPRMachineState, version_before_3), 1298880ae7deSDavid Gibson 129928e02042SDavid Gibson VMSTATE_PPC_TIMEBASE_V(tb, sPAPRMachineState, 2), 13004be21d56SDavid Gibson VMSTATE_END_OF_LIST() 13014be21d56SDavid Gibson }, 13024be21d56SDavid Gibson }; 13034be21d56SDavid Gibson 13044be21d56SDavid Gibson static int htab_save_setup(QEMUFile *f, void *opaque) 13054be21d56SDavid Gibson { 130628e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 13074be21d56SDavid Gibson 13084be21d56SDavid Gibson /* "Iteration" header */ 13094be21d56SDavid Gibson qemu_put_be32(f, spapr->htab_shift); 13104be21d56SDavid Gibson 1311e68cb8b4SAlexey Kardashevskiy if (spapr->htab) { 1312e68cb8b4SAlexey Kardashevskiy spapr->htab_save_index = 0; 1313e68cb8b4SAlexey Kardashevskiy spapr->htab_first_pass = true; 1314e68cb8b4SAlexey Kardashevskiy } else { 1315e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 1316e68cb8b4SAlexey Kardashevskiy 1317e68cb8b4SAlexey Kardashevskiy spapr->htab_fd = kvmppc_get_htab_fd(false); 131801a57972SSamuel Mendoza-Jonas spapr->htab_fd_stale = false; 1319e68cb8b4SAlexey Kardashevskiy if (spapr->htab_fd < 0) { 1320e68cb8b4SAlexey Kardashevskiy fprintf(stderr, "Unable to open fd for reading hash table from KVM: %s\n", 1321e68cb8b4SAlexey Kardashevskiy strerror(errno)); 1322e68cb8b4SAlexey Kardashevskiy return -1; 1323e68cb8b4SAlexey Kardashevskiy } 13244be21d56SDavid Gibson } 13254be21d56SDavid Gibson 1326e68cb8b4SAlexey Kardashevskiy 1327e68cb8b4SAlexey Kardashevskiy return 0; 1328e68cb8b4SAlexey Kardashevskiy } 13294be21d56SDavid Gibson 133028e02042SDavid Gibson static void htab_save_first_pass(QEMUFile *f, sPAPRMachineState *spapr, 13314be21d56SDavid Gibson int64_t max_ns) 13324be21d56SDavid Gibson { 13334be21d56SDavid Gibson int htabslots = HTAB_SIZE(spapr) / HASH_PTE_SIZE_64; 13344be21d56SDavid Gibson int index = spapr->htab_save_index; 1335bc72ad67SAlex Bligh int64_t starttime = qemu_clock_get_ns(QEMU_CLOCK_REALTIME); 13364be21d56SDavid Gibson 13374be21d56SDavid Gibson assert(spapr->htab_first_pass); 13384be21d56SDavid Gibson 13394be21d56SDavid Gibson do { 13404be21d56SDavid Gibson int chunkstart; 13414be21d56SDavid Gibson 13424be21d56SDavid Gibson /* Consume invalid HPTEs */ 13434be21d56SDavid Gibson while ((index < htabslots) 13444be21d56SDavid Gibson && !HPTE_VALID(HPTE(spapr->htab, index))) { 13454be21d56SDavid Gibson index++; 13464be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 13474be21d56SDavid Gibson } 13484be21d56SDavid Gibson 13494be21d56SDavid Gibson /* Consume valid HPTEs */ 13504be21d56SDavid Gibson chunkstart = index; 1351338c25b6SSamuel Mendoza-Jonas while ((index < htabslots) && (index - chunkstart < USHRT_MAX) 13524be21d56SDavid Gibson && HPTE_VALID(HPTE(spapr->htab, index))) { 13534be21d56SDavid Gibson index++; 13544be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 13554be21d56SDavid Gibson } 13564be21d56SDavid Gibson 13574be21d56SDavid Gibson if (index > chunkstart) { 13584be21d56SDavid Gibson int n_valid = index - chunkstart; 13594be21d56SDavid Gibson 13604be21d56SDavid Gibson qemu_put_be32(f, chunkstart); 13614be21d56SDavid Gibson qemu_put_be16(f, n_valid); 13624be21d56SDavid Gibson qemu_put_be16(f, 0); 13634be21d56SDavid Gibson qemu_put_buffer(f, HPTE(spapr->htab, chunkstart), 13644be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_valid); 13654be21d56SDavid Gibson 1366bc72ad67SAlex Bligh if ((qemu_clock_get_ns(QEMU_CLOCK_REALTIME) - starttime) > max_ns) { 13674be21d56SDavid Gibson break; 13684be21d56SDavid Gibson } 13694be21d56SDavid Gibson } 13704be21d56SDavid Gibson } while ((index < htabslots) && !qemu_file_rate_limit(f)); 13714be21d56SDavid Gibson 13724be21d56SDavid Gibson if (index >= htabslots) { 13734be21d56SDavid Gibson assert(index == htabslots); 13744be21d56SDavid Gibson index = 0; 13754be21d56SDavid Gibson spapr->htab_first_pass = false; 13764be21d56SDavid Gibson } 13774be21d56SDavid Gibson spapr->htab_save_index = index; 13784be21d56SDavid Gibson } 13794be21d56SDavid Gibson 138028e02042SDavid Gibson static int htab_save_later_pass(QEMUFile *f, sPAPRMachineState *spapr, 13814be21d56SDavid Gibson int64_t max_ns) 13824be21d56SDavid Gibson { 13834be21d56SDavid Gibson bool final = max_ns < 0; 13844be21d56SDavid Gibson int htabslots = HTAB_SIZE(spapr) / HASH_PTE_SIZE_64; 13854be21d56SDavid Gibson int examined = 0, sent = 0; 13864be21d56SDavid Gibson int index = spapr->htab_save_index; 1387bc72ad67SAlex Bligh int64_t starttime = qemu_clock_get_ns(QEMU_CLOCK_REALTIME); 13884be21d56SDavid Gibson 13894be21d56SDavid Gibson assert(!spapr->htab_first_pass); 13904be21d56SDavid Gibson 13914be21d56SDavid Gibson do { 13924be21d56SDavid Gibson int chunkstart, invalidstart; 13934be21d56SDavid Gibson 13944be21d56SDavid Gibson /* Consume non-dirty HPTEs */ 13954be21d56SDavid Gibson while ((index < htabslots) 13964be21d56SDavid Gibson && !HPTE_DIRTY(HPTE(spapr->htab, index))) { 13974be21d56SDavid Gibson index++; 13984be21d56SDavid Gibson examined++; 13994be21d56SDavid Gibson } 14004be21d56SDavid Gibson 14014be21d56SDavid Gibson chunkstart = index; 14024be21d56SDavid Gibson /* Consume valid dirty HPTEs */ 1403338c25b6SSamuel Mendoza-Jonas while ((index < htabslots) && (index - chunkstart < 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 invalidstart = index; 14124be21d56SDavid Gibson /* Consume invalid dirty HPTEs */ 1413338c25b6SSamuel Mendoza-Jonas while ((index < htabslots) && (index - invalidstart < USHRT_MAX) 14144be21d56SDavid Gibson && HPTE_DIRTY(HPTE(spapr->htab, index)) 14154be21d56SDavid Gibson && !HPTE_VALID(HPTE(spapr->htab, index))) { 14164be21d56SDavid Gibson CLEAN_HPTE(HPTE(spapr->htab, index)); 14174be21d56SDavid Gibson index++; 14184be21d56SDavid Gibson examined++; 14194be21d56SDavid Gibson } 14204be21d56SDavid Gibson 14214be21d56SDavid Gibson if (index > chunkstart) { 14224be21d56SDavid Gibson int n_valid = invalidstart - chunkstart; 14234be21d56SDavid Gibson int n_invalid = index - invalidstart; 14244be21d56SDavid Gibson 14254be21d56SDavid Gibson qemu_put_be32(f, chunkstart); 14264be21d56SDavid Gibson qemu_put_be16(f, n_valid); 14274be21d56SDavid Gibson qemu_put_be16(f, n_invalid); 14284be21d56SDavid Gibson qemu_put_buffer(f, HPTE(spapr->htab, chunkstart), 14294be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_valid); 14304be21d56SDavid Gibson sent += index - chunkstart; 14314be21d56SDavid Gibson 1432bc72ad67SAlex Bligh if (!final && (qemu_clock_get_ns(QEMU_CLOCK_REALTIME) - starttime) > max_ns) { 14334be21d56SDavid Gibson break; 14344be21d56SDavid Gibson } 14354be21d56SDavid Gibson } 14364be21d56SDavid Gibson 14374be21d56SDavid Gibson if (examined >= htabslots) { 14384be21d56SDavid Gibson break; 14394be21d56SDavid Gibson } 14404be21d56SDavid Gibson 14414be21d56SDavid Gibson if (index >= htabslots) { 14424be21d56SDavid Gibson assert(index == htabslots); 14434be21d56SDavid Gibson index = 0; 14444be21d56SDavid Gibson } 14454be21d56SDavid Gibson } while ((examined < htabslots) && (!qemu_file_rate_limit(f) || final)); 14464be21d56SDavid Gibson 14474be21d56SDavid Gibson if (index >= htabslots) { 14484be21d56SDavid Gibson assert(index == htabslots); 14494be21d56SDavid Gibson index = 0; 14504be21d56SDavid Gibson } 14514be21d56SDavid Gibson 14524be21d56SDavid Gibson spapr->htab_save_index = index; 14534be21d56SDavid Gibson 1454e68cb8b4SAlexey Kardashevskiy return (examined >= htabslots) && (sent == 0) ? 1 : 0; 14554be21d56SDavid Gibson } 14564be21d56SDavid Gibson 1457e68cb8b4SAlexey Kardashevskiy #define MAX_ITERATION_NS 5000000 /* 5 ms */ 1458e68cb8b4SAlexey Kardashevskiy #define MAX_KVM_BUF_SIZE 2048 1459e68cb8b4SAlexey Kardashevskiy 14604be21d56SDavid Gibson static int htab_save_iterate(QEMUFile *f, void *opaque) 14614be21d56SDavid Gibson { 146228e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 1463e68cb8b4SAlexey Kardashevskiy int rc = 0; 14644be21d56SDavid Gibson 14654be21d56SDavid Gibson /* Iteration header */ 14664be21d56SDavid Gibson qemu_put_be32(f, 0); 14674be21d56SDavid Gibson 1468e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1469e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 1470e68cb8b4SAlexey Kardashevskiy 147101a57972SSamuel Mendoza-Jonas rc = spapr_check_htab_fd(spapr); 147201a57972SSamuel Mendoza-Jonas if (rc < 0) { 147301a57972SSamuel Mendoza-Jonas return rc; 147401a57972SSamuel Mendoza-Jonas } 147501a57972SSamuel Mendoza-Jonas 1476e68cb8b4SAlexey Kardashevskiy rc = kvmppc_save_htab(f, spapr->htab_fd, 1477e68cb8b4SAlexey Kardashevskiy MAX_KVM_BUF_SIZE, MAX_ITERATION_NS); 1478e68cb8b4SAlexey Kardashevskiy if (rc < 0) { 1479e68cb8b4SAlexey Kardashevskiy return rc; 1480e68cb8b4SAlexey Kardashevskiy } 1481e68cb8b4SAlexey Kardashevskiy } else if (spapr->htab_first_pass) { 14824be21d56SDavid Gibson htab_save_first_pass(f, spapr, MAX_ITERATION_NS); 14834be21d56SDavid Gibson } else { 1484e68cb8b4SAlexey Kardashevskiy rc = htab_save_later_pass(f, spapr, MAX_ITERATION_NS); 14854be21d56SDavid Gibson } 14864be21d56SDavid Gibson 14874be21d56SDavid Gibson /* End marker */ 14884be21d56SDavid Gibson qemu_put_be32(f, 0); 14894be21d56SDavid Gibson qemu_put_be16(f, 0); 14904be21d56SDavid Gibson qemu_put_be16(f, 0); 14914be21d56SDavid Gibson 1492e68cb8b4SAlexey Kardashevskiy return rc; 14934be21d56SDavid Gibson } 14944be21d56SDavid Gibson 14954be21d56SDavid Gibson static int htab_save_complete(QEMUFile *f, void *opaque) 14964be21d56SDavid Gibson { 149728e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 14984be21d56SDavid Gibson 14994be21d56SDavid Gibson /* Iteration header */ 15004be21d56SDavid Gibson qemu_put_be32(f, 0); 15014be21d56SDavid Gibson 1502e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1503e68cb8b4SAlexey Kardashevskiy int rc; 1504e68cb8b4SAlexey Kardashevskiy 1505e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 1506e68cb8b4SAlexey Kardashevskiy 150701a57972SSamuel Mendoza-Jonas rc = spapr_check_htab_fd(spapr); 150801a57972SSamuel Mendoza-Jonas if (rc < 0) { 150901a57972SSamuel Mendoza-Jonas return rc; 151001a57972SSamuel Mendoza-Jonas } 151101a57972SSamuel Mendoza-Jonas 1512e68cb8b4SAlexey Kardashevskiy rc = kvmppc_save_htab(f, spapr->htab_fd, MAX_KVM_BUF_SIZE, -1); 1513e68cb8b4SAlexey Kardashevskiy if (rc < 0) { 1514e68cb8b4SAlexey Kardashevskiy return rc; 1515e68cb8b4SAlexey Kardashevskiy } 1516e68cb8b4SAlexey Kardashevskiy close(spapr->htab_fd); 1517e68cb8b4SAlexey Kardashevskiy spapr->htab_fd = -1; 1518e68cb8b4SAlexey Kardashevskiy } else { 15194be21d56SDavid Gibson htab_save_later_pass(f, spapr, -1); 1520e68cb8b4SAlexey Kardashevskiy } 15214be21d56SDavid Gibson 15224be21d56SDavid Gibson /* End marker */ 15234be21d56SDavid Gibson qemu_put_be32(f, 0); 15244be21d56SDavid Gibson qemu_put_be16(f, 0); 15254be21d56SDavid Gibson qemu_put_be16(f, 0); 15264be21d56SDavid Gibson 15274be21d56SDavid Gibson return 0; 15284be21d56SDavid Gibson } 15294be21d56SDavid Gibson 15304be21d56SDavid Gibson static int htab_load(QEMUFile *f, void *opaque, int version_id) 15314be21d56SDavid Gibson { 153228e02042SDavid Gibson sPAPRMachineState *spapr = opaque; 15334be21d56SDavid Gibson uint32_t section_hdr; 1534e68cb8b4SAlexey Kardashevskiy int fd = -1; 15354be21d56SDavid Gibson 15364be21d56SDavid Gibson if (version_id < 1 || version_id > 1) { 15374be21d56SDavid Gibson fprintf(stderr, "htab_load() bad version\n"); 15384be21d56SDavid Gibson return -EINVAL; 15394be21d56SDavid Gibson } 15404be21d56SDavid Gibson 15414be21d56SDavid Gibson section_hdr = qemu_get_be32(f); 15424be21d56SDavid Gibson 15434be21d56SDavid Gibson if (section_hdr) { 15444be21d56SDavid Gibson /* First section, just the hash shift */ 15454be21d56SDavid Gibson if (spapr->htab_shift != section_hdr) { 1546613e7a76SBharata B Rao error_report("htab_shift mismatch: source %d target %d", 1547613e7a76SBharata B Rao section_hdr, spapr->htab_shift); 15484be21d56SDavid Gibson return -EINVAL; 15494be21d56SDavid Gibson } 15504be21d56SDavid Gibson return 0; 15514be21d56SDavid Gibson } 15524be21d56SDavid Gibson 1553e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1554e68cb8b4SAlexey Kardashevskiy assert(kvm_enabled()); 1555e68cb8b4SAlexey Kardashevskiy 1556e68cb8b4SAlexey Kardashevskiy fd = kvmppc_get_htab_fd(true); 1557e68cb8b4SAlexey Kardashevskiy if (fd < 0) { 1558e68cb8b4SAlexey Kardashevskiy fprintf(stderr, "Unable to open fd to restore KVM hash table: %s\n", 1559e68cb8b4SAlexey Kardashevskiy strerror(errno)); 1560e68cb8b4SAlexey Kardashevskiy } 1561e68cb8b4SAlexey Kardashevskiy } 1562e68cb8b4SAlexey Kardashevskiy 15634be21d56SDavid Gibson while (true) { 15644be21d56SDavid Gibson uint32_t index; 15654be21d56SDavid Gibson uint16_t n_valid, n_invalid; 15664be21d56SDavid Gibson 15674be21d56SDavid Gibson index = qemu_get_be32(f); 15684be21d56SDavid Gibson n_valid = qemu_get_be16(f); 15694be21d56SDavid Gibson n_invalid = qemu_get_be16(f); 15704be21d56SDavid Gibson 15714be21d56SDavid Gibson if ((index == 0) && (n_valid == 0) && (n_invalid == 0)) { 15724be21d56SDavid Gibson /* End of Stream */ 15734be21d56SDavid Gibson break; 15744be21d56SDavid Gibson } 15754be21d56SDavid Gibson 1576e68cb8b4SAlexey Kardashevskiy if ((index + n_valid + n_invalid) > 15774be21d56SDavid Gibson (HTAB_SIZE(spapr) / HASH_PTE_SIZE_64)) { 15784be21d56SDavid Gibson /* Bad index in stream */ 15794be21d56SDavid Gibson fprintf(stderr, "htab_load() bad index %d (%hd+%hd entries) " 1580e68cb8b4SAlexey Kardashevskiy "in htab stream (htab_shift=%d)\n", index, n_valid, n_invalid, 1581e68cb8b4SAlexey Kardashevskiy spapr->htab_shift); 15824be21d56SDavid Gibson return -EINVAL; 15834be21d56SDavid Gibson } 15844be21d56SDavid Gibson 1585e68cb8b4SAlexey Kardashevskiy if (spapr->htab) { 15864be21d56SDavid Gibson if (n_valid) { 15874be21d56SDavid Gibson qemu_get_buffer(f, HPTE(spapr->htab, index), 15884be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_valid); 15894be21d56SDavid Gibson } 15904be21d56SDavid Gibson if (n_invalid) { 15914be21d56SDavid Gibson memset(HPTE(spapr->htab, index + n_valid), 0, 15924be21d56SDavid Gibson HASH_PTE_SIZE_64 * n_invalid); 15934be21d56SDavid Gibson } 1594e68cb8b4SAlexey Kardashevskiy } else { 1595e68cb8b4SAlexey Kardashevskiy int rc; 1596e68cb8b4SAlexey Kardashevskiy 1597e68cb8b4SAlexey Kardashevskiy assert(fd >= 0); 1598e68cb8b4SAlexey Kardashevskiy 1599e68cb8b4SAlexey Kardashevskiy rc = kvmppc_load_htab_chunk(f, fd, index, n_valid, n_invalid); 1600e68cb8b4SAlexey Kardashevskiy if (rc < 0) { 1601e68cb8b4SAlexey Kardashevskiy return rc; 1602e68cb8b4SAlexey Kardashevskiy } 1603e68cb8b4SAlexey Kardashevskiy } 1604e68cb8b4SAlexey Kardashevskiy } 1605e68cb8b4SAlexey Kardashevskiy 1606e68cb8b4SAlexey Kardashevskiy if (!spapr->htab) { 1607e68cb8b4SAlexey Kardashevskiy assert(fd >= 0); 1608e68cb8b4SAlexey Kardashevskiy close(fd); 16094be21d56SDavid Gibson } 16104be21d56SDavid Gibson 16114be21d56SDavid Gibson return 0; 16124be21d56SDavid Gibson } 16134be21d56SDavid Gibson 16144be21d56SDavid Gibson static SaveVMHandlers savevm_htab_handlers = { 16154be21d56SDavid Gibson .save_live_setup = htab_save_setup, 16164be21d56SDavid Gibson .save_live_iterate = htab_save_iterate, 1617a3e06c3dSDr. David Alan Gilbert .save_live_complete_precopy = htab_save_complete, 16184be21d56SDavid Gibson .load_state = htab_load, 16194be21d56SDavid Gibson }; 16204be21d56SDavid Gibson 16215b2128d2SAlexander Graf static void spapr_boot_set(void *opaque, const char *boot_device, 16225b2128d2SAlexander Graf Error **errp) 16235b2128d2SAlexander Graf { 16245b2128d2SAlexander Graf MachineState *machine = MACHINE(qdev_get_machine()); 16255b2128d2SAlexander Graf machine->boot_order = g_strdup(boot_device); 16265b2128d2SAlexander Graf } 16275b2128d2SAlexander Graf 1628569f4967SDavid Gibson static void spapr_cpu_init(sPAPRMachineState *spapr, PowerPCCPU *cpu, 1629569f4967SDavid Gibson Error **errp) 1630bab99ea0SBharata B Rao { 1631bab99ea0SBharata B Rao CPUPPCState *env = &cpu->env; 1632bab99ea0SBharata B Rao 1633bab99ea0SBharata B Rao /* Set time-base frequency to 512 MHz */ 1634bab99ea0SBharata B Rao cpu_ppc_tb_init(env, TIMEBASE_FREQ); 1635bab99ea0SBharata B Rao 1636bab99ea0SBharata B Rao /* PAPR always has exception vectors in RAM not ROM. To ensure this, 1637bab99ea0SBharata B Rao * MSR[IP] should never be set. 1638bab99ea0SBharata B Rao */ 1639bab99ea0SBharata B Rao env->msr_mask &= ~(1 << 6); 1640bab99ea0SBharata B Rao 1641bab99ea0SBharata B Rao /* Tell KVM that we're in PAPR mode */ 1642bab99ea0SBharata B Rao if (kvm_enabled()) { 1643bab99ea0SBharata B Rao kvmppc_set_papr(cpu); 1644bab99ea0SBharata B Rao } 1645bab99ea0SBharata B Rao 1646bab99ea0SBharata B Rao if (cpu->max_compat) { 1647569f4967SDavid Gibson Error *local_err = NULL; 1648569f4967SDavid Gibson 1649569f4967SDavid Gibson ppc_set_compat(cpu, cpu->max_compat, &local_err); 1650569f4967SDavid Gibson if (local_err) { 1651569f4967SDavid Gibson error_propagate(errp, local_err); 1652569f4967SDavid Gibson return; 1653569f4967SDavid Gibson } 1654bab99ea0SBharata B Rao } 1655bab99ea0SBharata B Rao 1656bab99ea0SBharata B Rao xics_cpu_setup(spapr->icp, cpu); 1657bab99ea0SBharata B Rao 1658bab99ea0SBharata B Rao qemu_register_reset(spapr_cpu_reset, cpu); 1659bab99ea0SBharata B Rao } 1660bab99ea0SBharata B Rao 1661224245bfSDavid Gibson /* 1662224245bfSDavid Gibson * Reset routine for LMB DR devices. 1663224245bfSDavid Gibson * 1664224245bfSDavid Gibson * Unlike PCI DR devices, LMB DR devices explicitly register this reset 1665224245bfSDavid Gibson * routine. Reset for PCI DR devices will be handled by PHB reset routine 1666224245bfSDavid Gibson * when it walks all its children devices. LMB devices reset occurs 1667224245bfSDavid Gibson * as part of spapr_ppc_reset(). 1668224245bfSDavid Gibson */ 1669224245bfSDavid Gibson static void spapr_drc_reset(void *opaque) 1670224245bfSDavid Gibson { 1671224245bfSDavid Gibson sPAPRDRConnector *drc = opaque; 1672224245bfSDavid Gibson DeviceState *d = DEVICE(drc); 1673224245bfSDavid Gibson 1674224245bfSDavid Gibson if (d) { 1675224245bfSDavid Gibson device_reset(d); 1676224245bfSDavid Gibson } 1677224245bfSDavid Gibson } 1678224245bfSDavid Gibson 1679224245bfSDavid Gibson static void spapr_create_lmb_dr_connectors(sPAPRMachineState *spapr) 1680224245bfSDavid Gibson { 1681224245bfSDavid Gibson MachineState *machine = MACHINE(spapr); 1682224245bfSDavid Gibson uint64_t lmb_size = SPAPR_MEMORY_BLOCK_SIZE; 1683e8f986fcSBharata B Rao uint32_t nr_lmbs = (machine->maxram_size - machine->ram_size)/lmb_size; 1684224245bfSDavid Gibson int i; 1685224245bfSDavid Gibson 1686224245bfSDavid Gibson for (i = 0; i < nr_lmbs; i++) { 1687224245bfSDavid Gibson sPAPRDRConnector *drc; 1688224245bfSDavid Gibson uint64_t addr; 1689224245bfSDavid Gibson 1690e8f986fcSBharata B Rao addr = i * lmb_size + spapr->hotplug_memory.base; 1691224245bfSDavid Gibson drc = spapr_dr_connector_new(OBJECT(spapr), SPAPR_DR_CONNECTOR_TYPE_LMB, 1692224245bfSDavid Gibson addr/lmb_size); 1693224245bfSDavid Gibson qemu_register_reset(spapr_drc_reset, drc); 1694224245bfSDavid Gibson } 1695224245bfSDavid Gibson } 1696224245bfSDavid Gibson 1697224245bfSDavid Gibson /* 1698224245bfSDavid Gibson * If RAM size, maxmem size and individual node mem sizes aren't aligned 1699224245bfSDavid Gibson * to SPAPR_MEMORY_BLOCK_SIZE(256MB), then refuse to start the guest 1700224245bfSDavid Gibson * since we can't support such unaligned sizes with DRCONF_MEMORY. 1701224245bfSDavid Gibson */ 17027c150d6fSDavid Gibson static void spapr_validate_node_memory(MachineState *machine, Error **errp) 1703224245bfSDavid Gibson { 1704224245bfSDavid Gibson int i; 1705224245bfSDavid Gibson 17067c150d6fSDavid Gibson if (machine->ram_size % SPAPR_MEMORY_BLOCK_SIZE) { 17077c150d6fSDavid Gibson error_setg(errp, "Memory size 0x" RAM_ADDR_FMT 17087c150d6fSDavid Gibson " is not aligned to %llu MiB", 17097c150d6fSDavid Gibson machine->ram_size, 1710224245bfSDavid Gibson SPAPR_MEMORY_BLOCK_SIZE / M_BYTE); 17117c150d6fSDavid Gibson return; 17127c150d6fSDavid Gibson } 17137c150d6fSDavid Gibson 17147c150d6fSDavid Gibson if (machine->maxram_size % SPAPR_MEMORY_BLOCK_SIZE) { 17157c150d6fSDavid Gibson error_setg(errp, "Maximum memory size 0x" RAM_ADDR_FMT 17167c150d6fSDavid Gibson " is not aligned to %llu MiB", 17177c150d6fSDavid Gibson machine->ram_size, 17187c150d6fSDavid Gibson SPAPR_MEMORY_BLOCK_SIZE / M_BYTE); 17197c150d6fSDavid Gibson return; 1720224245bfSDavid Gibson } 1721224245bfSDavid Gibson 1722224245bfSDavid Gibson for (i = 0; i < nb_numa_nodes; i++) { 1723224245bfSDavid Gibson if (numa_info[i].node_mem % SPAPR_MEMORY_BLOCK_SIZE) { 17247c150d6fSDavid Gibson error_setg(errp, 17257c150d6fSDavid Gibson "Node %d memory size 0x%" PRIx64 17267c150d6fSDavid Gibson " is not aligned to %llu MiB", 17277c150d6fSDavid Gibson i, numa_info[i].node_mem, 1728224245bfSDavid Gibson SPAPR_MEMORY_BLOCK_SIZE / M_BYTE); 17297c150d6fSDavid Gibson return; 1730224245bfSDavid Gibson } 1731224245bfSDavid Gibson } 1732224245bfSDavid Gibson } 1733224245bfSDavid Gibson 173453018216SPaolo Bonzini /* pSeries LPAR / sPAPR hardware init */ 17353ef96221SMarcel Apfelbaum static void ppc_spapr_init(MachineState *machine) 173653018216SPaolo Bonzini { 173728e02042SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(machine); 1738224245bfSDavid Gibson sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(machine); 17393ef96221SMarcel Apfelbaum const char *kernel_filename = machine->kernel_filename; 17403ef96221SMarcel Apfelbaum const char *kernel_cmdline = machine->kernel_cmdline; 17413ef96221SMarcel Apfelbaum const char *initrd_filename = machine->initrd_filename; 174253018216SPaolo Bonzini PowerPCCPU *cpu; 174353018216SPaolo Bonzini PCIHostState *phb; 174453018216SPaolo Bonzini int i; 174553018216SPaolo Bonzini MemoryRegion *sysmem = get_system_memory(); 174653018216SPaolo Bonzini MemoryRegion *ram = g_new(MemoryRegion, 1); 1747658fa66bSAlexey Kardashevskiy MemoryRegion *rma_region; 1748658fa66bSAlexey Kardashevskiy void *rma = NULL; 174953018216SPaolo Bonzini hwaddr rma_alloc_size; 1750b082d65aSAlexey Kardashevskiy hwaddr node0_size = spapr_node0_size(); 175153018216SPaolo Bonzini uint32_t initrd_base = 0; 175253018216SPaolo Bonzini long kernel_size = 0, initrd_size = 0; 1753b7d1f77aSBenjamin Herrenschmidt long load_limit, fw_size; 175416457e7fSBenjamin Herrenschmidt bool kernel_le = false; 175553018216SPaolo Bonzini char *filename; 175653018216SPaolo Bonzini 175753018216SPaolo Bonzini msi_supported = true; 175853018216SPaolo Bonzini 175953018216SPaolo Bonzini QLIST_INIT(&spapr->phbs); 176053018216SPaolo Bonzini 176153018216SPaolo Bonzini cpu_ppc_hypercall = emulate_spapr_hypercall; 176253018216SPaolo Bonzini 176353018216SPaolo Bonzini /* Allocate RMA if necessary */ 1764658fa66bSAlexey Kardashevskiy rma_alloc_size = kvmppc_alloc_rma(&rma); 176553018216SPaolo Bonzini 176653018216SPaolo Bonzini if (rma_alloc_size == -1) { 1767730fce59SThomas Huth error_report("Unable to create RMA"); 176853018216SPaolo Bonzini exit(1); 176953018216SPaolo Bonzini } 177053018216SPaolo Bonzini 1771c4177479SAlexey Kardashevskiy if (rma_alloc_size && (rma_alloc_size < node0_size)) { 177253018216SPaolo Bonzini spapr->rma_size = rma_alloc_size; 177353018216SPaolo Bonzini } else { 1774c4177479SAlexey Kardashevskiy spapr->rma_size = node0_size; 177553018216SPaolo Bonzini 177653018216SPaolo Bonzini /* With KVM, we don't actually know whether KVM supports an 177753018216SPaolo Bonzini * unbounded RMA (PR KVM) or is limited by the hash table size 177853018216SPaolo Bonzini * (HV KVM using VRMA), so we always assume the latter 177953018216SPaolo Bonzini * 178053018216SPaolo Bonzini * In that case, we also limit the initial allocations for RTAS 178153018216SPaolo Bonzini * etc... to 256M since we have no way to know what the VRMA size 178253018216SPaolo Bonzini * is going to be as it depends on the size of the hash table 178353018216SPaolo Bonzini * isn't determined yet. 178453018216SPaolo Bonzini */ 178553018216SPaolo Bonzini if (kvm_enabled()) { 178653018216SPaolo Bonzini spapr->vrma_adjust = 1; 178753018216SPaolo Bonzini spapr->rma_size = MIN(spapr->rma_size, 0x10000000); 178853018216SPaolo Bonzini } 178953018216SPaolo Bonzini } 179053018216SPaolo Bonzini 1791c4177479SAlexey Kardashevskiy if (spapr->rma_size > node0_size) { 1792c4177479SAlexey Kardashevskiy fprintf(stderr, "Error: Numa node 0 has to span the RMA (%#08"HWADDR_PRIx")\n", 1793c4177479SAlexey Kardashevskiy spapr->rma_size); 1794c4177479SAlexey Kardashevskiy exit(1); 1795c4177479SAlexey Kardashevskiy } 1796c4177479SAlexey Kardashevskiy 1797b7d1f77aSBenjamin Herrenschmidt /* Setup a load limit for the ramdisk leaving room for SLOF and FDT */ 1798b7d1f77aSBenjamin Herrenschmidt load_limit = MIN(spapr->rma_size, RTAS_MAX_ADDR) - FW_OVERHEAD; 179953018216SPaolo Bonzini 180053018216SPaolo Bonzini /* We aim for a hash table of size 1/128 the size of RAM. The 180153018216SPaolo Bonzini * normal rule of thumb is 1/64 the size of RAM, but that's much 180253018216SPaolo Bonzini * more than needed for the Linux guests we support. */ 180353018216SPaolo Bonzini spapr->htab_shift = 18; /* Minimum architected size */ 180453018216SPaolo Bonzini while (spapr->htab_shift <= 46) { 1805ce881f77SBharata B Rao if ((1ULL << (spapr->htab_shift + 7)) >= machine->maxram_size) { 180653018216SPaolo Bonzini break; 180753018216SPaolo Bonzini } 180853018216SPaolo Bonzini spapr->htab_shift++; 180953018216SPaolo Bonzini } 1810b817772aSBharata B Rao spapr_alloc_htab(spapr); 181153018216SPaolo Bonzini 18127b565160SDavid Gibson /* Set up Interrupt Controller before we create the VCPUs */ 1813446f16a6SMarcel Apfelbaum spapr->icp = xics_system_init(machine, 18149e734e3dSBharata B Rao DIV_ROUND_UP(max_cpus * kvmppc_smt_threads(), 1815f303f117SGreg Kurz smp_threads), 1816*1e49182dSDavid Gibson XICS_IRQS, &error_fatal); 18177b565160SDavid Gibson 1818224245bfSDavid Gibson if (smc->dr_lmb_enabled) { 18197c150d6fSDavid Gibson spapr_validate_node_memory(machine, &error_fatal); 1820224245bfSDavid Gibson } 1821224245bfSDavid Gibson 182253018216SPaolo Bonzini /* init CPUs */ 182319fb2c36SBharata B Rao if (machine->cpu_model == NULL) { 182419fb2c36SBharata B Rao machine->cpu_model = kvm_enabled() ? "host" : "POWER7"; 182553018216SPaolo Bonzini } 182653018216SPaolo Bonzini for (i = 0; i < smp_cpus; i++) { 182719fb2c36SBharata B Rao cpu = cpu_ppc_init(machine->cpu_model); 182853018216SPaolo Bonzini if (cpu == NULL) { 1829569f4967SDavid Gibson error_report("Unable to find PowerPC CPU definition"); 183053018216SPaolo Bonzini exit(1); 183153018216SPaolo Bonzini } 1832569f4967SDavid Gibson spapr_cpu_init(spapr, cpu, &error_fatal); 183353018216SPaolo Bonzini } 183453018216SPaolo Bonzini 1835026bfd89SDavid Gibson if (kvm_enabled()) { 1836026bfd89SDavid Gibson /* Enable H_LOGICAL_CI_* so SLOF can talk to in-kernel devices */ 1837026bfd89SDavid Gibson kvmppc_enable_logical_ci_hcalls(); 1838ef9971ddSAlexey Kardashevskiy kvmppc_enable_set_mode_hcall(); 1839026bfd89SDavid Gibson } 1840026bfd89SDavid Gibson 184153018216SPaolo Bonzini /* allocate RAM */ 1842f92f5da1SAlexey Kardashevskiy memory_region_allocate_system_memory(ram, NULL, "ppc_spapr.ram", 1843fb164994SDavid Gibson machine->ram_size); 1844f92f5da1SAlexey Kardashevskiy memory_region_add_subregion(sysmem, 0, ram); 184553018216SPaolo Bonzini 1846658fa66bSAlexey Kardashevskiy if (rma_alloc_size && rma) { 1847658fa66bSAlexey Kardashevskiy rma_region = g_new(MemoryRegion, 1); 1848658fa66bSAlexey Kardashevskiy memory_region_init_ram_ptr(rma_region, NULL, "ppc_spapr.rma", 1849658fa66bSAlexey Kardashevskiy rma_alloc_size, rma); 1850658fa66bSAlexey Kardashevskiy vmstate_register_ram_global(rma_region); 1851658fa66bSAlexey Kardashevskiy memory_region_add_subregion(sysmem, 0, rma_region); 1852658fa66bSAlexey Kardashevskiy } 1853658fa66bSAlexey Kardashevskiy 18544a1c9cf0SBharata B Rao /* initialize hotplug memory address space */ 18554a1c9cf0SBharata B Rao if (machine->ram_size < machine->maxram_size) { 18564a1c9cf0SBharata B Rao ram_addr_t hotplug_mem_size = machine->maxram_size - machine->ram_size; 18574a1c9cf0SBharata B Rao 18584a1c9cf0SBharata B Rao if (machine->ram_slots > SPAPR_MAX_RAM_SLOTS) { 18599af9e0feSMarkus Armbruster error_report("Specified number of memory slots %" PRIu64 18609af9e0feSMarkus Armbruster " exceeds max supported %d", 186119a35c9eSBharata B Rao machine->ram_slots, SPAPR_MAX_RAM_SLOTS); 18624a1c9cf0SBharata B Rao exit(EXIT_FAILURE); 18634a1c9cf0SBharata B Rao } 18644a1c9cf0SBharata B Rao 18654a1c9cf0SBharata B Rao spapr->hotplug_memory.base = ROUND_UP(machine->ram_size, 18664a1c9cf0SBharata B Rao SPAPR_HOTPLUG_MEM_ALIGN); 18674a1c9cf0SBharata B Rao memory_region_init(&spapr->hotplug_memory.mr, OBJECT(spapr), 18684a1c9cf0SBharata B Rao "hotplug-memory", hotplug_mem_size); 18694a1c9cf0SBharata B Rao memory_region_add_subregion(sysmem, spapr->hotplug_memory.base, 18704a1c9cf0SBharata B Rao &spapr->hotplug_memory.mr); 18714a1c9cf0SBharata B Rao } 18724a1c9cf0SBharata B Rao 1873224245bfSDavid Gibson if (smc->dr_lmb_enabled) { 1874224245bfSDavid Gibson spapr_create_lmb_dr_connectors(spapr); 1875224245bfSDavid Gibson } 1876224245bfSDavid Gibson 187753018216SPaolo Bonzini filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, "spapr-rtas.bin"); 18784c56440dSStefan Weil if (!filename) { 1879730fce59SThomas Huth error_report("Could not find LPAR rtas '%s'", "spapr-rtas.bin"); 18804c56440dSStefan Weil exit(1); 18814c56440dSStefan Weil } 1882b7d1f77aSBenjamin Herrenschmidt spapr->rtas_size = get_image_size(filename); 1883b7d1f77aSBenjamin Herrenschmidt spapr->rtas_blob = g_malloc(spapr->rtas_size); 1884b7d1f77aSBenjamin Herrenschmidt if (load_image_size(filename, spapr->rtas_blob, spapr->rtas_size) < 0) { 1885730fce59SThomas Huth error_report("Could not load LPAR rtas '%s'", filename); 188653018216SPaolo Bonzini exit(1); 188753018216SPaolo Bonzini } 188853018216SPaolo Bonzini if (spapr->rtas_size > RTAS_MAX_SIZE) { 1889730fce59SThomas Huth error_report("RTAS too big ! 0x%zx bytes (max is 0x%x)", 18902f285bddSPeter Maydell (size_t)spapr->rtas_size, RTAS_MAX_SIZE); 189153018216SPaolo Bonzini exit(1); 189253018216SPaolo Bonzini } 189353018216SPaolo Bonzini g_free(filename); 189453018216SPaolo Bonzini 189553018216SPaolo Bonzini /* Set up EPOW events infrastructure */ 189653018216SPaolo Bonzini spapr_events_init(spapr); 189753018216SPaolo Bonzini 189812f42174SDavid Gibson /* Set up the RTC RTAS interfaces */ 189928df36a1SDavid Gibson spapr_rtc_create(spapr); 190012f42174SDavid Gibson 190153018216SPaolo Bonzini /* Set up VIO bus */ 190253018216SPaolo Bonzini spapr->vio_bus = spapr_vio_bus_init(); 190353018216SPaolo Bonzini 190453018216SPaolo Bonzini for (i = 0; i < MAX_SERIAL_PORTS; i++) { 190553018216SPaolo Bonzini if (serial_hds[i]) { 190653018216SPaolo Bonzini spapr_vty_create(spapr->vio_bus, serial_hds[i]); 190753018216SPaolo Bonzini } 190853018216SPaolo Bonzini } 190953018216SPaolo Bonzini 191053018216SPaolo Bonzini /* We always have at least the nvram device on VIO */ 191153018216SPaolo Bonzini spapr_create_nvram(spapr); 191253018216SPaolo Bonzini 191353018216SPaolo Bonzini /* Set up PCI */ 191453018216SPaolo Bonzini spapr_pci_rtas_init(); 191553018216SPaolo Bonzini 191689dfd6e1SDavid Gibson phb = spapr_create_phb(spapr, 0); 191753018216SPaolo Bonzini 191853018216SPaolo Bonzini for (i = 0; i < nb_nics; i++) { 191953018216SPaolo Bonzini NICInfo *nd = &nd_table[i]; 192053018216SPaolo Bonzini 192153018216SPaolo Bonzini if (!nd->model) { 192253018216SPaolo Bonzini nd->model = g_strdup("ibmveth"); 192353018216SPaolo Bonzini } 192453018216SPaolo Bonzini 192553018216SPaolo Bonzini if (strcmp(nd->model, "ibmveth") == 0) { 192653018216SPaolo Bonzini spapr_vlan_create(spapr->vio_bus, nd); 192753018216SPaolo Bonzini } else { 192829b358f9SDavid Gibson pci_nic_init_nofail(&nd_table[i], phb->bus, nd->model, NULL); 192953018216SPaolo Bonzini } 193053018216SPaolo Bonzini } 193153018216SPaolo Bonzini 193253018216SPaolo Bonzini for (i = 0; i <= drive_get_max_bus(IF_SCSI); i++) { 193353018216SPaolo Bonzini spapr_vscsi_create(spapr->vio_bus); 193453018216SPaolo Bonzini } 193553018216SPaolo Bonzini 193653018216SPaolo Bonzini /* Graphics */ 193714c6a894SDavid Gibson if (spapr_vga_init(phb->bus, &error_fatal)) { 193853018216SPaolo Bonzini spapr->has_graphics = true; 1939c6e76503SPaolo Bonzini machine->usb |= defaults_enabled() && !machine->usb_disabled; 194053018216SPaolo Bonzini } 194153018216SPaolo Bonzini 19424ee9ced9SMarcel Apfelbaum if (machine->usb) { 194357040d45SThomas Huth if (smc->use_ohci_by_default) { 194453018216SPaolo Bonzini pci_create_simple(phb->bus, -1, "pci-ohci"); 194557040d45SThomas Huth } else { 194657040d45SThomas Huth pci_create_simple(phb->bus, -1, "nec-usb-xhci"); 194757040d45SThomas Huth } 1948c86580b8SMarkus Armbruster 194953018216SPaolo Bonzini if (spapr->has_graphics) { 1950c86580b8SMarkus Armbruster USBBus *usb_bus = usb_bus_find(-1); 1951c86580b8SMarkus Armbruster 1952c86580b8SMarkus Armbruster usb_create_simple(usb_bus, "usb-kbd"); 1953c86580b8SMarkus Armbruster usb_create_simple(usb_bus, "usb-mouse"); 195453018216SPaolo Bonzini } 195553018216SPaolo Bonzini } 195653018216SPaolo Bonzini 195753018216SPaolo Bonzini if (spapr->rma_size < (MIN_RMA_SLOF << 20)) { 195853018216SPaolo Bonzini fprintf(stderr, "qemu: pSeries SLOF firmware requires >= " 195953018216SPaolo Bonzini "%ldM guest RMA (Real Mode Area memory)\n", MIN_RMA_SLOF); 196053018216SPaolo Bonzini exit(1); 196153018216SPaolo Bonzini } 196253018216SPaolo Bonzini 196353018216SPaolo Bonzini if (kernel_filename) { 196453018216SPaolo Bonzini uint64_t lowaddr = 0; 196553018216SPaolo Bonzini 196653018216SPaolo Bonzini kernel_size = load_elf(kernel_filename, translate_kernel_address, NULL, 19674ecd4d16SPeter Crosthwaite NULL, &lowaddr, NULL, 1, PPC_ELF_MACHINE, 0); 19683b66da82SAlexey Kardashevskiy if (kernel_size == ELF_LOAD_WRONG_ENDIAN) { 196916457e7fSBenjamin Herrenschmidt kernel_size = load_elf(kernel_filename, 197016457e7fSBenjamin Herrenschmidt translate_kernel_address, NULL, 19714ecd4d16SPeter Crosthwaite NULL, &lowaddr, NULL, 0, PPC_ELF_MACHINE, 0); 197216457e7fSBenjamin Herrenschmidt kernel_le = kernel_size > 0; 197316457e7fSBenjamin Herrenschmidt } 197416457e7fSBenjamin Herrenschmidt if (kernel_size < 0) { 19753b66da82SAlexey Kardashevskiy fprintf(stderr, "qemu: error loading %s: %s\n", 19763b66da82SAlexey Kardashevskiy kernel_filename, load_elf_strerror(kernel_size)); 197753018216SPaolo Bonzini exit(1); 197853018216SPaolo Bonzini } 197953018216SPaolo Bonzini 198053018216SPaolo Bonzini /* load initrd */ 198153018216SPaolo Bonzini if (initrd_filename) { 198253018216SPaolo Bonzini /* Try to locate the initrd in the gap between the kernel 198353018216SPaolo Bonzini * and the firmware. Add a bit of space just in case 198453018216SPaolo Bonzini */ 198553018216SPaolo Bonzini initrd_base = (KERNEL_LOAD_ADDR + kernel_size + 0x1ffff) & ~0xffff; 198653018216SPaolo Bonzini initrd_size = load_image_targphys(initrd_filename, initrd_base, 198753018216SPaolo Bonzini load_limit - initrd_base); 198853018216SPaolo Bonzini if (initrd_size < 0) { 198953018216SPaolo Bonzini fprintf(stderr, "qemu: could not load initial ram disk '%s'\n", 199053018216SPaolo Bonzini initrd_filename); 199153018216SPaolo Bonzini exit(1); 199253018216SPaolo Bonzini } 199353018216SPaolo Bonzini } else { 199453018216SPaolo Bonzini initrd_base = 0; 199553018216SPaolo Bonzini initrd_size = 0; 199653018216SPaolo Bonzini } 199753018216SPaolo Bonzini } 199853018216SPaolo Bonzini 19998e7ea787SAndreas Färber if (bios_name == NULL) { 20008e7ea787SAndreas Färber bios_name = FW_FILE_NAME; 20018e7ea787SAndreas Färber } 20028e7ea787SAndreas Färber filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name); 20034c56440dSStefan Weil if (!filename) { 200468fea5a0SThomas Huth error_report("Could not find LPAR firmware '%s'", bios_name); 20054c56440dSStefan Weil exit(1); 20064c56440dSStefan Weil } 200753018216SPaolo Bonzini fw_size = load_image_targphys(filename, 0, FW_MAX_SIZE); 200868fea5a0SThomas Huth if (fw_size <= 0) { 200968fea5a0SThomas Huth error_report("Could not load LPAR firmware '%s'", filename); 201053018216SPaolo Bonzini exit(1); 201153018216SPaolo Bonzini } 201253018216SPaolo Bonzini g_free(filename); 201353018216SPaolo Bonzini 201428e02042SDavid Gibson /* FIXME: Should register things through the MachineState's qdev 201528e02042SDavid Gibson * interface, this is a legacy from the sPAPREnvironment structure 201628e02042SDavid Gibson * which predated MachineState but had a similar function */ 20174be21d56SDavid Gibson vmstate_register(NULL, 0, &vmstate_spapr, spapr); 20184be21d56SDavid Gibson register_savevm_live(NULL, "spapr/htab", -1, 1, 20194be21d56SDavid Gibson &savevm_htab_handlers, spapr); 20204be21d56SDavid Gibson 202153018216SPaolo Bonzini /* Prepare the device tree */ 20223bbf37f2SAndreas Färber spapr->fdt_skel = spapr_create_fdt_skel(initrd_base, initrd_size, 202316457e7fSBenjamin Herrenschmidt kernel_size, kernel_le, 202431fe14d1SNathan Fontenot kernel_cmdline, 202531fe14d1SNathan Fontenot spapr->check_exception_irq); 202653018216SPaolo Bonzini assert(spapr->fdt_skel != NULL); 20275b2128d2SAlexander Graf 202846503c2bSMichael Roth /* used by RTAS */ 202946503c2bSMichael Roth QTAILQ_INIT(&spapr->ccs_list); 203046503c2bSMichael Roth qemu_register_reset(spapr_ccs_reset_hook, spapr); 203146503c2bSMichael Roth 20325b2128d2SAlexander Graf qemu_register_boot_set(spapr_boot_set, spapr); 203353018216SPaolo Bonzini } 203453018216SPaolo Bonzini 2035135a129aSAneesh Kumar K.V static int spapr_kvm_type(const char *vm_type) 2036135a129aSAneesh Kumar K.V { 2037135a129aSAneesh Kumar K.V if (!vm_type) { 2038135a129aSAneesh Kumar K.V return 0; 2039135a129aSAneesh Kumar K.V } 2040135a129aSAneesh Kumar K.V 2041135a129aSAneesh Kumar K.V if (!strcmp(vm_type, "HV")) { 2042135a129aSAneesh Kumar K.V return 1; 2043135a129aSAneesh Kumar K.V } 2044135a129aSAneesh Kumar K.V 2045135a129aSAneesh Kumar K.V if (!strcmp(vm_type, "PR")) { 2046135a129aSAneesh Kumar K.V return 2; 2047135a129aSAneesh Kumar K.V } 2048135a129aSAneesh Kumar K.V 2049135a129aSAneesh Kumar K.V error_report("Unknown kvm-type specified '%s'", vm_type); 2050135a129aSAneesh Kumar K.V exit(1); 2051135a129aSAneesh Kumar K.V } 2052135a129aSAneesh Kumar K.V 205371461b0fSAlexey Kardashevskiy /* 2054627b84f4SGonglei * Implementation of an interface to adjust firmware path 205571461b0fSAlexey Kardashevskiy * for the bootindex property handling. 205671461b0fSAlexey Kardashevskiy */ 205771461b0fSAlexey Kardashevskiy static char *spapr_get_fw_dev_path(FWPathProvider *p, BusState *bus, 205871461b0fSAlexey Kardashevskiy DeviceState *dev) 205971461b0fSAlexey Kardashevskiy { 206071461b0fSAlexey Kardashevskiy #define CAST(type, obj, name) \ 206171461b0fSAlexey Kardashevskiy ((type *)object_dynamic_cast(OBJECT(obj), (name))) 206271461b0fSAlexey Kardashevskiy SCSIDevice *d = CAST(SCSIDevice, dev, TYPE_SCSI_DEVICE); 206371461b0fSAlexey Kardashevskiy sPAPRPHBState *phb = CAST(sPAPRPHBState, dev, TYPE_SPAPR_PCI_HOST_BRIDGE); 206471461b0fSAlexey Kardashevskiy 206571461b0fSAlexey Kardashevskiy if (d) { 206671461b0fSAlexey Kardashevskiy void *spapr = CAST(void, bus->parent, "spapr-vscsi"); 206771461b0fSAlexey Kardashevskiy VirtIOSCSI *virtio = CAST(VirtIOSCSI, bus->parent, TYPE_VIRTIO_SCSI); 206871461b0fSAlexey Kardashevskiy USBDevice *usb = CAST(USBDevice, bus->parent, TYPE_USB_DEVICE); 206971461b0fSAlexey Kardashevskiy 207071461b0fSAlexey Kardashevskiy if (spapr) { 207171461b0fSAlexey Kardashevskiy /* 207271461b0fSAlexey Kardashevskiy * Replace "channel@0/disk@0,0" with "disk@8000000000000000": 207371461b0fSAlexey Kardashevskiy * We use SRP luns of the form 8000 | (bus << 8) | (id << 5) | lun 207471461b0fSAlexey Kardashevskiy * in the top 16 bits of the 64-bit LUN 207571461b0fSAlexey Kardashevskiy */ 207671461b0fSAlexey Kardashevskiy unsigned id = 0x8000 | (d->id << 8) | d->lun; 207771461b0fSAlexey Kardashevskiy return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev), 207871461b0fSAlexey Kardashevskiy (uint64_t)id << 48); 207971461b0fSAlexey Kardashevskiy } else if (virtio) { 208071461b0fSAlexey Kardashevskiy /* 208171461b0fSAlexey Kardashevskiy * We use SRP luns of the form 01000000 | (target << 8) | lun 208271461b0fSAlexey Kardashevskiy * in the top 32 bits of the 64-bit LUN 208371461b0fSAlexey Kardashevskiy * Note: the quote above is from SLOF and it is wrong, 208471461b0fSAlexey Kardashevskiy * the actual binding is: 208571461b0fSAlexey Kardashevskiy * swap 0100 or 10 << or 20 << ( target lun-id -- srplun ) 208671461b0fSAlexey Kardashevskiy */ 208771461b0fSAlexey Kardashevskiy unsigned id = 0x1000000 | (d->id << 16) | d->lun; 208871461b0fSAlexey Kardashevskiy return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev), 208971461b0fSAlexey Kardashevskiy (uint64_t)id << 32); 209071461b0fSAlexey Kardashevskiy } else if (usb) { 209171461b0fSAlexey Kardashevskiy /* 209271461b0fSAlexey Kardashevskiy * We use SRP luns of the form 01000000 | (usb-port << 16) | lun 209371461b0fSAlexey Kardashevskiy * in the top 32 bits of the 64-bit LUN 209471461b0fSAlexey Kardashevskiy */ 209571461b0fSAlexey Kardashevskiy unsigned usb_port = atoi(usb->port->path); 209671461b0fSAlexey Kardashevskiy unsigned id = 0x1000000 | (usb_port << 16) | d->lun; 209771461b0fSAlexey Kardashevskiy return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev), 209871461b0fSAlexey Kardashevskiy (uint64_t)id << 32); 209971461b0fSAlexey Kardashevskiy } 210071461b0fSAlexey Kardashevskiy } 210171461b0fSAlexey Kardashevskiy 210271461b0fSAlexey Kardashevskiy if (phb) { 210371461b0fSAlexey Kardashevskiy /* Replace "pci" with "pci@800000020000000" */ 210471461b0fSAlexey Kardashevskiy return g_strdup_printf("pci@%"PRIX64, phb->buid); 210571461b0fSAlexey Kardashevskiy } 210671461b0fSAlexey Kardashevskiy 210771461b0fSAlexey Kardashevskiy return NULL; 210871461b0fSAlexey Kardashevskiy } 210971461b0fSAlexey Kardashevskiy 211023825581SEduardo Habkost static char *spapr_get_kvm_type(Object *obj, Error **errp) 211123825581SEduardo Habkost { 211228e02042SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 211323825581SEduardo Habkost 211428e02042SDavid Gibson return g_strdup(spapr->kvm_type); 211523825581SEduardo Habkost } 211623825581SEduardo Habkost 211723825581SEduardo Habkost static void spapr_set_kvm_type(Object *obj, const char *value, Error **errp) 211823825581SEduardo Habkost { 211928e02042SDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 212023825581SEduardo Habkost 212128e02042SDavid Gibson g_free(spapr->kvm_type); 212228e02042SDavid Gibson spapr->kvm_type = g_strdup(value); 212323825581SEduardo Habkost } 212423825581SEduardo Habkost 212523825581SEduardo Habkost static void spapr_machine_initfn(Object *obj) 212623825581SEduardo Habkost { 212723825581SEduardo Habkost object_property_add_str(obj, "kvm-type", 212823825581SEduardo Habkost spapr_get_kvm_type, spapr_set_kvm_type, NULL); 212949d2e648SMarcel Apfelbaum object_property_set_description(obj, "kvm-type", 213049d2e648SMarcel Apfelbaum "Specifies the KVM virtualization mode (HV, PR)", 213149d2e648SMarcel Apfelbaum NULL); 213223825581SEduardo Habkost } 213323825581SEduardo Habkost 213487bbdd9cSDavid Gibson static void spapr_machine_finalizefn(Object *obj) 213587bbdd9cSDavid Gibson { 213687bbdd9cSDavid Gibson sPAPRMachineState *spapr = SPAPR_MACHINE(obj); 213787bbdd9cSDavid Gibson 213887bbdd9cSDavid Gibson g_free(spapr->kvm_type); 213987bbdd9cSDavid Gibson } 214087bbdd9cSDavid Gibson 214134316482SAlexey Kardashevskiy static void ppc_cpu_do_nmi_on_cpu(void *arg) 214234316482SAlexey Kardashevskiy { 214334316482SAlexey Kardashevskiy CPUState *cs = arg; 214434316482SAlexey Kardashevskiy 214534316482SAlexey Kardashevskiy cpu_synchronize_state(cs); 214634316482SAlexey Kardashevskiy ppc_cpu_do_system_reset(cs); 214734316482SAlexey Kardashevskiy } 214834316482SAlexey Kardashevskiy 214934316482SAlexey Kardashevskiy static void spapr_nmi(NMIState *n, int cpu_index, Error **errp) 215034316482SAlexey Kardashevskiy { 215134316482SAlexey Kardashevskiy CPUState *cs; 215234316482SAlexey Kardashevskiy 215334316482SAlexey Kardashevskiy CPU_FOREACH(cs) { 215434316482SAlexey Kardashevskiy async_run_on_cpu(cs, ppc_cpu_do_nmi_on_cpu, cs); 215534316482SAlexey Kardashevskiy } 215634316482SAlexey Kardashevskiy } 215734316482SAlexey Kardashevskiy 2158c20d332aSBharata B Rao static void spapr_add_lmbs(DeviceState *dev, uint64_t addr, uint64_t size, 2159c20d332aSBharata B Rao uint32_t node, Error **errp) 2160c20d332aSBharata B Rao { 2161c20d332aSBharata B Rao sPAPRDRConnector *drc; 2162c20d332aSBharata B Rao sPAPRDRConnectorClass *drck; 2163c20d332aSBharata B Rao uint32_t nr_lmbs = size/SPAPR_MEMORY_BLOCK_SIZE; 2164c20d332aSBharata B Rao int i, fdt_offset, fdt_size; 2165c20d332aSBharata B Rao void *fdt; 2166c20d332aSBharata B Rao 2167c20d332aSBharata B Rao /* 2168c20d332aSBharata B Rao * Check for DRC connectors and send hotplug notification to the 2169c20d332aSBharata B Rao * guest only in case of hotplugged memory. This allows cold plugged 2170c20d332aSBharata B Rao * memory to be specified at boot time. 2171c20d332aSBharata B Rao */ 2172c20d332aSBharata B Rao if (!dev->hotplugged) { 2173c20d332aSBharata B Rao return; 2174c20d332aSBharata B Rao } 2175c20d332aSBharata B Rao 2176c20d332aSBharata B Rao for (i = 0; i < nr_lmbs; i++) { 2177c20d332aSBharata B Rao drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_LMB, 2178c20d332aSBharata B Rao addr/SPAPR_MEMORY_BLOCK_SIZE); 2179c20d332aSBharata B Rao g_assert(drc); 2180c20d332aSBharata B Rao 2181c20d332aSBharata B Rao fdt = create_device_tree(&fdt_size); 2182c20d332aSBharata B Rao fdt_offset = spapr_populate_memory_node(fdt, node, addr, 2183c20d332aSBharata B Rao SPAPR_MEMORY_BLOCK_SIZE); 2184c20d332aSBharata B Rao 2185c20d332aSBharata B Rao drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 2186c20d332aSBharata B Rao drck->attach(drc, dev, fdt, fdt_offset, !dev->hotplugged, errp); 2187c20d332aSBharata B Rao addr += SPAPR_MEMORY_BLOCK_SIZE; 2188c20d332aSBharata B Rao } 21890a417869SBharata B Rao spapr_hotplug_req_add_by_count(SPAPR_DR_CONNECTOR_TYPE_LMB, nr_lmbs); 2190c20d332aSBharata B Rao } 2191c20d332aSBharata B Rao 2192c20d332aSBharata B Rao static void spapr_memory_plug(HotplugHandler *hotplug_dev, DeviceState *dev, 2193c20d332aSBharata B Rao uint32_t node, Error **errp) 2194c20d332aSBharata B Rao { 2195c20d332aSBharata B Rao Error *local_err = NULL; 2196c20d332aSBharata B Rao sPAPRMachineState *ms = SPAPR_MACHINE(hotplug_dev); 2197c20d332aSBharata B Rao PCDIMMDevice *dimm = PC_DIMM(dev); 2198c20d332aSBharata B Rao PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); 2199c20d332aSBharata B Rao MemoryRegion *mr = ddc->get_memory_region(dimm); 2200c20d332aSBharata B Rao uint64_t align = memory_region_get_alignment(mr); 2201c20d332aSBharata B Rao uint64_t size = memory_region_size(mr); 2202c20d332aSBharata B Rao uint64_t addr; 2203c20d332aSBharata B Rao 2204c20d332aSBharata B Rao if (size % SPAPR_MEMORY_BLOCK_SIZE) { 2205c20d332aSBharata B Rao error_setg(&local_err, "Hotplugged memory size must be a multiple of " 2206c20d332aSBharata B Rao "%lld MB", SPAPR_MEMORY_BLOCK_SIZE/M_BYTE); 2207c20d332aSBharata B Rao goto out; 2208c20d332aSBharata B Rao } 2209c20d332aSBharata B Rao 2210d6a9b0b8SMichael S. Tsirkin pc_dimm_memory_plug(dev, &ms->hotplug_memory, mr, align, &local_err); 2211c20d332aSBharata B Rao if (local_err) { 2212c20d332aSBharata B Rao goto out; 2213c20d332aSBharata B Rao } 2214c20d332aSBharata B Rao 2215c20d332aSBharata B Rao addr = object_property_get_int(OBJECT(dimm), PC_DIMM_ADDR_PROP, &local_err); 2216c20d332aSBharata B Rao if (local_err) { 2217c20d332aSBharata B Rao pc_dimm_memory_unplug(dev, &ms->hotplug_memory, mr); 2218c20d332aSBharata B Rao goto out; 2219c20d332aSBharata B Rao } 2220c20d332aSBharata B Rao 2221c20d332aSBharata B Rao spapr_add_lmbs(dev, addr, size, node, &error_abort); 2222c20d332aSBharata B Rao 2223c20d332aSBharata B Rao out: 2224c20d332aSBharata B Rao error_propagate(errp, local_err); 2225c20d332aSBharata B Rao } 2226c20d332aSBharata B Rao 2227c20d332aSBharata B Rao static void spapr_machine_device_plug(HotplugHandler *hotplug_dev, 2228c20d332aSBharata B Rao DeviceState *dev, Error **errp) 2229c20d332aSBharata B Rao { 2230c20d332aSBharata B Rao sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(qdev_get_machine()); 2231c20d332aSBharata B Rao 2232c20d332aSBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { 2233b556854bSBharata B Rao int node; 2234c20d332aSBharata B Rao 2235c20d332aSBharata B Rao if (!smc->dr_lmb_enabled) { 2236c20d332aSBharata B Rao error_setg(errp, "Memory hotplug not supported for this machine"); 2237c20d332aSBharata B Rao return; 2238c20d332aSBharata B Rao } 2239c20d332aSBharata B Rao node = object_property_get_int(OBJECT(dev), PC_DIMM_NODE_PROP, errp); 2240c20d332aSBharata B Rao if (*errp) { 2241c20d332aSBharata B Rao return; 2242c20d332aSBharata B Rao } 2243c20d332aSBharata B Rao 2244b556854bSBharata B Rao /* 2245b556854bSBharata B Rao * Currently PowerPC kernel doesn't allow hot-adding memory to 2246b556854bSBharata B Rao * memory-less node, but instead will silently add the memory 2247b556854bSBharata B Rao * to the first node that has some memory. This causes two 2248b556854bSBharata B Rao * unexpected behaviours for the user. 2249b556854bSBharata B Rao * 2250b556854bSBharata B Rao * - Memory gets hotplugged to a different node than what the user 2251b556854bSBharata B Rao * specified. 2252b556854bSBharata B Rao * - Since pc-dimm subsystem in QEMU still thinks that memory belongs 2253b556854bSBharata B Rao * to memory-less node, a reboot will set things accordingly 2254b556854bSBharata B Rao * and the previously hotplugged memory now ends in the right node. 2255b556854bSBharata B Rao * This appears as if some memory moved from one node to another. 2256b556854bSBharata B Rao * 2257b556854bSBharata B Rao * So until kernel starts supporting memory hotplug to memory-less 2258b556854bSBharata B Rao * nodes, just prevent such attempts upfront in QEMU. 2259b556854bSBharata B Rao */ 2260b556854bSBharata B Rao if (nb_numa_nodes && !numa_info[node].node_mem) { 2261b556854bSBharata B Rao error_setg(errp, "Can't hotplug memory to memory-less node %d", 2262b556854bSBharata B Rao node); 2263b556854bSBharata B Rao return; 2264b556854bSBharata B Rao } 2265b556854bSBharata B Rao 2266c20d332aSBharata B Rao spapr_memory_plug(hotplug_dev, dev, node, errp); 2267c20d332aSBharata B Rao } 2268c20d332aSBharata B Rao } 2269c20d332aSBharata B Rao 2270c20d332aSBharata B Rao static void spapr_machine_device_unplug(HotplugHandler *hotplug_dev, 2271c20d332aSBharata B Rao DeviceState *dev, Error **errp) 2272c20d332aSBharata B Rao { 2273c20d332aSBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { 2274c20d332aSBharata B Rao error_setg(errp, "Memory hot unplug not supported by sPAPR"); 2275c20d332aSBharata B Rao } 2276c20d332aSBharata B Rao } 2277c20d332aSBharata B Rao 2278c20d332aSBharata B Rao static HotplugHandler *spapr_get_hotpug_handler(MachineState *machine, 2279c20d332aSBharata B Rao DeviceState *dev) 2280c20d332aSBharata B Rao { 2281c20d332aSBharata B Rao if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { 2282c20d332aSBharata B Rao return HOTPLUG_HANDLER(machine); 2283c20d332aSBharata B Rao } 2284c20d332aSBharata B Rao return NULL; 2285c20d332aSBharata B Rao } 2286c20d332aSBharata B Rao 228720bb648dSDavid Gibson static unsigned spapr_cpu_index_to_socket_id(unsigned cpu_index) 228820bb648dSDavid Gibson { 228920bb648dSDavid Gibson /* Allocate to NUMA nodes on a "socket" basis (not that concept of 229020bb648dSDavid Gibson * socket means much for the paravirtualized PAPR platform) */ 229120bb648dSDavid Gibson return cpu_index / smp_threads / smp_cores; 229220bb648dSDavid Gibson } 229320bb648dSDavid Gibson 229429ee3247SAlexey Kardashevskiy static void spapr_machine_class_init(ObjectClass *oc, void *data) 229553018216SPaolo Bonzini { 229629ee3247SAlexey Kardashevskiy MachineClass *mc = MACHINE_CLASS(oc); 2297224245bfSDavid Gibson sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(oc); 229871461b0fSAlexey Kardashevskiy FWPathProviderClass *fwc = FW_PATH_PROVIDER_CLASS(oc); 229934316482SAlexey Kardashevskiy NMIClass *nc = NMI_CLASS(oc); 2300c20d332aSBharata B Rao HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(oc); 230129ee3247SAlexey Kardashevskiy 23020eb9054cSDavid Gibson mc->desc = "pSeries Logical Partition (PAPR compliant)"; 2303fc9f38c3SDavid Gibson 2304fc9f38c3SDavid Gibson /* 2305fc9f38c3SDavid Gibson * We set up the default / latest behaviour here. The class_init 2306fc9f38c3SDavid Gibson * functions for the specific versioned machine types can override 2307fc9f38c3SDavid Gibson * these details for backwards compatibility 2308fc9f38c3SDavid Gibson */ 2309958db90cSMarcel Apfelbaum mc->init = ppc_spapr_init; 2310958db90cSMarcel Apfelbaum mc->reset = ppc_spapr_reset; 2311958db90cSMarcel Apfelbaum mc->block_default_type = IF_SCSI; 231238b02bd8SAlexey Kardashevskiy mc->max_cpus = MAX_CPUMASK_BITS; 2313958db90cSMarcel Apfelbaum mc->no_parallel = 1; 23145b2128d2SAlexander Graf mc->default_boot_order = ""; 2315a34944feSNikunj A Dadhania mc->default_ram_size = 512 * M_BYTE; 2316958db90cSMarcel Apfelbaum mc->kvm_type = spapr_kvm_type; 23179e3f9733SAlexander Graf mc->has_dynamic_sysbus = true; 2318e4024630SLaurent Vivier mc->pci_allow_0_address = true; 2319c20d332aSBharata B Rao mc->get_hotplug_handler = spapr_get_hotpug_handler; 2320c20d332aSBharata B Rao hc->plug = spapr_machine_device_plug; 2321c20d332aSBharata B Rao hc->unplug = spapr_machine_device_unplug; 232220bb648dSDavid Gibson mc->cpu_index_to_socket_id = spapr_cpu_index_to_socket_id; 232300b4fbe2SMarcel Apfelbaum 2324fc9f38c3SDavid Gibson smc->dr_lmb_enabled = true; 232571461b0fSAlexey Kardashevskiy fwc->get_dev_path = spapr_get_fw_dev_path; 232634316482SAlexey Kardashevskiy nc->nmi_monitor_handler = spapr_nmi; 232753018216SPaolo Bonzini } 232853018216SPaolo Bonzini 232929ee3247SAlexey Kardashevskiy static const TypeInfo spapr_machine_info = { 233029ee3247SAlexey Kardashevskiy .name = TYPE_SPAPR_MACHINE, 233129ee3247SAlexey Kardashevskiy .parent = TYPE_MACHINE, 23324aee7362SDavid Gibson .abstract = true, 23336ca1502eSAlexey Kardashevskiy .instance_size = sizeof(sPAPRMachineState), 233423825581SEduardo Habkost .instance_init = spapr_machine_initfn, 233587bbdd9cSDavid Gibson .instance_finalize = spapr_machine_finalizefn, 2336183930c0SDavid Gibson .class_size = sizeof(sPAPRMachineClass), 233729ee3247SAlexey Kardashevskiy .class_init = spapr_machine_class_init, 233871461b0fSAlexey Kardashevskiy .interfaces = (InterfaceInfo[]) { 233971461b0fSAlexey Kardashevskiy { TYPE_FW_PATH_PROVIDER }, 234034316482SAlexey Kardashevskiy { TYPE_NMI }, 2341c20d332aSBharata B Rao { TYPE_HOTPLUG_HANDLER }, 234271461b0fSAlexey Kardashevskiy { } 234371461b0fSAlexey Kardashevskiy }, 234429ee3247SAlexey Kardashevskiy }; 234529ee3247SAlexey Kardashevskiy 2346fccbc785SDavid Gibson #define DEFINE_SPAPR_MACHINE(suffix, verstr, latest) \ 23475013c547SDavid Gibson static void spapr_machine_##suffix##_class_init(ObjectClass *oc, \ 23485013c547SDavid Gibson void *data) \ 23495013c547SDavid Gibson { \ 23505013c547SDavid Gibson MachineClass *mc = MACHINE_CLASS(oc); \ 23515013c547SDavid Gibson spapr_machine_##suffix##_class_options(mc); \ 2352fccbc785SDavid Gibson if (latest) { \ 2353fccbc785SDavid Gibson mc->alias = "pseries"; \ 2354fccbc785SDavid Gibson mc->is_default = 1; \ 2355fccbc785SDavid Gibson } \ 23565013c547SDavid Gibson } \ 23575013c547SDavid Gibson static void spapr_machine_##suffix##_instance_init(Object *obj) \ 23585013c547SDavid Gibson { \ 23595013c547SDavid Gibson MachineState *machine = MACHINE(obj); \ 23605013c547SDavid Gibson spapr_machine_##suffix##_instance_options(machine); \ 23615013c547SDavid Gibson } \ 23625013c547SDavid Gibson static const TypeInfo spapr_machine_##suffix##_info = { \ 23635013c547SDavid Gibson .name = MACHINE_TYPE_NAME("pseries-" verstr), \ 23645013c547SDavid Gibson .parent = TYPE_SPAPR_MACHINE, \ 23655013c547SDavid Gibson .class_init = spapr_machine_##suffix##_class_init, \ 23665013c547SDavid Gibson .instance_init = spapr_machine_##suffix##_instance_init, \ 23675013c547SDavid Gibson }; \ 23685013c547SDavid Gibson static void spapr_machine_register_##suffix(void) \ 23695013c547SDavid Gibson { \ 23705013c547SDavid Gibson type_register(&spapr_machine_##suffix##_info); \ 23715013c547SDavid Gibson } \ 23725013c547SDavid Gibson machine_init(spapr_machine_register_##suffix) 23735013c547SDavid Gibson 23741c5f29bbSDavid Gibson /* 23754b23699cSDavid Gibson * pseries-2.6 23764b23699cSDavid Gibson */ 23774b23699cSDavid Gibson static void spapr_machine_2_6_instance_options(MachineState *machine) 23784b23699cSDavid Gibson { 23794b23699cSDavid Gibson } 23804b23699cSDavid Gibson 23814b23699cSDavid Gibson static void spapr_machine_2_6_class_options(MachineClass *mc) 23824b23699cSDavid Gibson { 23834b23699cSDavid Gibson /* Defaults for the latest behaviour inherited from the base class */ 23844b23699cSDavid Gibson } 23854b23699cSDavid Gibson 23864b23699cSDavid Gibson DEFINE_SPAPR_MACHINE(2_6, "2.6", true); 23874b23699cSDavid Gibson 23884b23699cSDavid Gibson /* 23891c5f29bbSDavid Gibson * pseries-2.5 23901c5f29bbSDavid Gibson */ 23914b23699cSDavid Gibson #define SPAPR_COMPAT_2_5 \ 23924b23699cSDavid Gibson HW_COMPAT_2_5 23934b23699cSDavid Gibson 23945013c547SDavid Gibson static void spapr_machine_2_5_instance_options(MachineState *machine) 23951c5f29bbSDavid Gibson { 23965013c547SDavid Gibson } 23975013c547SDavid Gibson 23985013c547SDavid Gibson static void spapr_machine_2_5_class_options(MachineClass *mc) 23995013c547SDavid Gibson { 240057040d45SThomas Huth sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); 240157040d45SThomas Huth 24024b23699cSDavid Gibson spapr_machine_2_6_class_options(mc); 240357040d45SThomas Huth smc->use_ohci_by_default = true; 24044b23699cSDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_5); 24051c5f29bbSDavid Gibson } 24061c5f29bbSDavid Gibson 24074b23699cSDavid Gibson DEFINE_SPAPR_MACHINE(2_5, "2.5", false); 24081c5f29bbSDavid Gibson 24091c5f29bbSDavid Gibson /* 24101c5f29bbSDavid Gibson * pseries-2.4 24111c5f29bbSDavid Gibson */ 241280fd50f9SCornelia Huck #define SPAPR_COMPAT_2_4 \ 241380fd50f9SCornelia Huck HW_COMPAT_2_4 241480fd50f9SCornelia Huck 24155013c547SDavid Gibson static void spapr_machine_2_4_instance_options(MachineState *machine) 24161c5f29bbSDavid Gibson { 24175013c547SDavid Gibson spapr_machine_2_5_instance_options(machine); 24185013c547SDavid Gibson } 24191c5f29bbSDavid Gibson 24205013c547SDavid Gibson static void spapr_machine_2_4_class_options(MachineClass *mc) 24215013c547SDavid Gibson { 2422fc9f38c3SDavid Gibson sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); 2423fc9f38c3SDavid Gibson 2424fc9f38c3SDavid Gibson spapr_machine_2_5_class_options(mc); 2425fc9f38c3SDavid Gibson smc->dr_lmb_enabled = false; 2426f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_4); 24271c5f29bbSDavid Gibson } 24281c5f29bbSDavid Gibson 2429fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_4, "2.4", false); 24301c5f29bbSDavid Gibson 24311c5f29bbSDavid Gibson /* 24321c5f29bbSDavid Gibson * pseries-2.3 24331c5f29bbSDavid Gibson */ 243438ff32c6SEduardo Habkost #define SPAPR_COMPAT_2_3 \ 243580fd50f9SCornelia Huck SPAPR_COMPAT_2_4 \ 24367619c7b0SMichael Roth HW_COMPAT_2_3 \ 24377619c7b0SMichael Roth {\ 24387619c7b0SMichael Roth .driver = "spapr-pci-host-bridge",\ 24397619c7b0SMichael Roth .property = "dynamic-reconfiguration",\ 24407619c7b0SMichael Roth .value = "off",\ 24417619c7b0SMichael Roth }, 244238ff32c6SEduardo Habkost 24435013c547SDavid Gibson static void spapr_machine_2_3_instance_options(MachineState *machine) 24441c5f29bbSDavid Gibson { 24455013c547SDavid Gibson spapr_machine_2_4_instance_options(machine); 24461c5f29bbSDavid Gibson savevm_skip_section_footers(); 24471c5f29bbSDavid Gibson global_state_set_optional(); 24481c5f29bbSDavid Gibson } 24491c5f29bbSDavid Gibson 24505013c547SDavid Gibson static void spapr_machine_2_3_class_options(MachineClass *mc) 24511c5f29bbSDavid Gibson { 2452fc9f38c3SDavid Gibson spapr_machine_2_4_class_options(mc); 2453f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_3); 24541c5f29bbSDavid Gibson } 2455fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_3, "2.3", false); 24561c5f29bbSDavid Gibson 24571c5f29bbSDavid Gibson /* 24581c5f29bbSDavid Gibson * pseries-2.2 24591c5f29bbSDavid Gibson */ 24601c5f29bbSDavid Gibson 2461b194df47SAlexey Kardashevskiy #define SPAPR_COMPAT_2_2 \ 246238ff32c6SEduardo Habkost SPAPR_COMPAT_2_3 \ 24634dfd8eaaSEduardo Habkost HW_COMPAT_2_2 \ 2464b194df47SAlexey Kardashevskiy {\ 2465b194df47SAlexey Kardashevskiy .driver = TYPE_SPAPR_PCI_HOST_BRIDGE,\ 2466b194df47SAlexey Kardashevskiy .property = "mem_win_size",\ 2467b194df47SAlexey Kardashevskiy .value = "0x20000000",\ 2468dd754bafSEduardo Habkost }, 2469b194df47SAlexey Kardashevskiy 24705013c547SDavid Gibson static void spapr_machine_2_2_instance_options(MachineState *machine) 2471b0e966d0SJason Wang { 24725013c547SDavid Gibson spapr_machine_2_3_instance_options(machine); 2473b0e966d0SJason Wang } 2474b0e966d0SJason Wang 24755013c547SDavid Gibson static void spapr_machine_2_2_class_options(MachineClass *mc) 2476b0e966d0SJason Wang { 2477fc9f38c3SDavid Gibson spapr_machine_2_3_class_options(mc); 2478f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_2); 24791c5f29bbSDavid Gibson } 2480fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_2, "2.2", false); 24811c5f29bbSDavid Gibson 24821c5f29bbSDavid Gibson /* 24831c5f29bbSDavid Gibson * pseries-2.1 24841c5f29bbSDavid Gibson */ 24851c5f29bbSDavid Gibson #define SPAPR_COMPAT_2_1 \ 24861c5f29bbSDavid Gibson SPAPR_COMPAT_2_2 \ 24871c5f29bbSDavid Gibson HW_COMPAT_2_1 24881c5f29bbSDavid Gibson 24895013c547SDavid Gibson static void spapr_machine_2_1_instance_options(MachineState *machine) 24901c5f29bbSDavid Gibson { 24915013c547SDavid Gibson spapr_machine_2_2_instance_options(machine); 24921c5f29bbSDavid Gibson } 24931c5f29bbSDavid Gibson 24945013c547SDavid Gibson static void spapr_machine_2_1_class_options(MachineClass *mc) 2495b0e966d0SJason Wang { 2496fc9f38c3SDavid Gibson spapr_machine_2_2_class_options(mc); 2497f949b4e5SDavid Gibson SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_1); 24986026db45SAlexey Kardashevskiy } 2499fccbc785SDavid Gibson DEFINE_SPAPR_MACHINE(2_1, "2.1", false); 25006026db45SAlexey Kardashevskiy 250129ee3247SAlexey Kardashevskiy static void spapr_machine_register_types(void) 250229ee3247SAlexey Kardashevskiy { 250329ee3247SAlexey Kardashevskiy type_register_static(&spapr_machine_info); 250429ee3247SAlexey Kardashevskiy } 250529ee3247SAlexey Kardashevskiy 250629ee3247SAlexey Kardashevskiy type_init(spapr_machine_register_types) 2507