2 * QEMU PowerPC pSeries Logical Partition (aka sPAPR) hardware System Emulator
4 * Copyright (c) 2004-2007 Fabrice Bellard
5 * Copyright (c) 2007 Jocelyn Mayer
6 * Copyright (c) 2010 David Gibson, IBM Corporation.
8 * Permission is hereby granted, free of charge, to any person obtaining a copy
9 * of this software and associated documentation files (the "Software"), to deal
10 * in the Software without restriction, including without limitation the rights
11 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
12 * copies of the Software, and to permit persons to whom the Software is
13 * furnished to do so, subject to the following conditions:
15 * The above copyright notice and this permission notice shall be included in
16 * all copies or substantial portions of the Software.
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
21 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
23 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
33 #include "hw/boards.h"
35 #include "hw/loader.h"
38 #include "hw/spapr_vio.h"
46 #define KERNEL_LOAD_ADDR 0x00000000
47 #define INITRD_LOAD_ADDR 0x02800000
48 #define FDT_MAX_SIZE 0x10000
49 #define RTAS_MAX_SIZE 0x10000
50 #define FW_MAX_SIZE 0x400000
51 #define FW_FILE_NAME "slof.bin"
53 #define MIN_RAM_SLOF 512UL
55 #define TIMEBASE_FREQ 512000000ULL
58 #define XICS_IRQS 1024
60 #define PHANDLE_XICP 0x00001111
62 sPAPREnvironment
*spapr
;
64 static void *spapr_create_fdt_skel(const char *cpu_model
,
65 target_phys_addr_t initrd_base
,
66 target_phys_addr_t initrd_size
,
67 const char *boot_device
,
68 const char *kernel_cmdline
,
73 uint64_t mem_reg_property
[] = { 0, cpu_to_be64(ram_size
) };
74 uint32_t start_prop
= cpu_to_be32(initrd_base
);
75 uint32_t end_prop
= cpu_to_be32(initrd_base
+ initrd_size
);
76 uint32_t pft_size_prop
[] = {0, cpu_to_be32(hash_shift
)};
77 char hypertas_prop
[] = "hcall-pft\0hcall-term\0hcall-dabr\0hcall-interrupt"
78 "\0hcall-tce\0hcall-vio\0hcall-splpar\0hcall-bulk";
79 uint32_t interrupt_server_ranges_prop
[] = {0, cpu_to_be32(smp_cpus
)};
87 fprintf(stderr, "qemu: error creating device tree: %s: %s\n", \
88 #exp, fdt_strerror(ret)); \
93 fdt
= g_malloc0(FDT_MAX_SIZE
);
94 _FDT((fdt_create(fdt
, FDT_MAX_SIZE
)));
96 _FDT((fdt_finish_reservemap(fdt
)));
99 _FDT((fdt_begin_node(fdt
, "")));
100 _FDT((fdt_property_string(fdt
, "device_type", "chrp")));
101 _FDT((fdt_property_string(fdt
, "model", "IBM pSeries (emulated by qemu)")));
103 _FDT((fdt_property_cell(fdt
, "#address-cells", 0x2)));
104 _FDT((fdt_property_cell(fdt
, "#size-cells", 0x2)));
107 _FDT((fdt_begin_node(fdt
, "chosen")));
109 _FDT((fdt_property_string(fdt
, "bootargs", kernel_cmdline
)));
110 _FDT((fdt_property(fdt
, "linux,initrd-start",
111 &start_prop
, sizeof(start_prop
))));
112 _FDT((fdt_property(fdt
, "linux,initrd-end",
113 &end_prop
, sizeof(end_prop
))));
114 _FDT((fdt_property_string(fdt
, "qemu,boot-device", boot_device
)));
116 _FDT((fdt_end_node(fdt
)));
119 _FDT((fdt_begin_node(fdt
, "memory@0")));
121 _FDT((fdt_property_string(fdt
, "device_type", "memory")));
122 _FDT((fdt_property(fdt
, "reg",
123 mem_reg_property
, sizeof(mem_reg_property
))));
125 _FDT((fdt_end_node(fdt
)));
128 _FDT((fdt_begin_node(fdt
, "cpus")));
130 _FDT((fdt_property_cell(fdt
, "#address-cells", 0x1)));
131 _FDT((fdt_property_cell(fdt
, "#size-cells", 0x0)));
133 modelname
= g_strdup(cpu_model
);
135 for (i
= 0; i
< strlen(modelname
); i
++) {
136 modelname
[i
] = toupper(modelname
[i
]);
139 for (env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
140 int index
= env
->cpu_index
;
141 uint32_t gserver_prop
[] = {cpu_to_be32(index
), 0}; /* HACK! */
143 uint32_t segs
[] = {cpu_to_be32(28), cpu_to_be32(40),
144 0xffffffff, 0xffffffff};
145 uint32_t tbfreq
= kvm_enabled() ? kvmppc_get_tbfreq() : TIMEBASE_FREQ
;
146 uint32_t cpufreq
= kvm_enabled() ? kvmppc_get_clockfreq() : 1000000000;
148 if (asprintf(&nodename
, "%s@%x", modelname
, index
) < 0) {
149 fprintf(stderr
, "Allocation failure\n");
153 _FDT((fdt_begin_node(fdt
, nodename
)));
157 _FDT((fdt_property_cell(fdt
, "reg", index
)));
158 _FDT((fdt_property_string(fdt
, "device_type", "cpu")));
160 _FDT((fdt_property_cell(fdt
, "cpu-version", env
->spr
[SPR_PVR
])));
161 _FDT((fdt_property_cell(fdt
, "dcache-block-size",
162 env
->dcache_line_size
)));
163 _FDT((fdt_property_cell(fdt
, "icache-block-size",
164 env
->icache_line_size
)));
165 _FDT((fdt_property_cell(fdt
, "timebase-frequency", tbfreq
)));
166 _FDT((fdt_property_cell(fdt
, "clock-frequency", cpufreq
)));
167 _FDT((fdt_property_cell(fdt
, "ibm,slb-size", env
->slb_nr
)));
168 _FDT((fdt_property(fdt
, "ibm,pft-size",
169 pft_size_prop
, sizeof(pft_size_prop
))));
170 _FDT((fdt_property_string(fdt
, "status", "okay")));
171 _FDT((fdt_property(fdt
, "64-bit", NULL
, 0)));
172 _FDT((fdt_property_cell(fdt
, "ibm,ppc-interrupt-server#s", index
)));
173 _FDT((fdt_property(fdt
, "ibm,ppc-interrupt-gserver#s",
174 gserver_prop
, sizeof(gserver_prop
))));
176 if (env
->mmu_model
& POWERPC_MMU_1TSEG
) {
177 _FDT((fdt_property(fdt
, "ibm,processor-segment-sizes",
178 segs
, sizeof(segs
))));
181 _FDT((fdt_end_node(fdt
)));
186 _FDT((fdt_end_node(fdt
)));
189 _FDT((fdt_begin_node(fdt
, "rtas")));
191 _FDT((fdt_property(fdt
, "ibm,hypertas-functions", hypertas_prop
,
192 sizeof(hypertas_prop
))));
194 _FDT((fdt_end_node(fdt
)));
196 /* interrupt controller */
197 _FDT((fdt_begin_node(fdt
, "interrupt-controller")));
199 _FDT((fdt_property_string(fdt
, "device_type",
200 "PowerPC-External-Interrupt-Presentation")));
201 _FDT((fdt_property_string(fdt
, "compatible", "IBM,ppc-xicp")));
202 _FDT((fdt_property(fdt
, "interrupt-controller", NULL
, 0)));
203 _FDT((fdt_property(fdt
, "ibm,interrupt-server-ranges",
204 interrupt_server_ranges_prop
,
205 sizeof(interrupt_server_ranges_prop
))));
206 _FDT((fdt_property_cell(fdt
, "#interrupt-cells", 2)));
207 _FDT((fdt_property_cell(fdt
, "linux,phandle", PHANDLE_XICP
)));
208 _FDT((fdt_property_cell(fdt
, "phandle", PHANDLE_XICP
)));
210 _FDT((fdt_end_node(fdt
)));
213 _FDT((fdt_begin_node(fdt
, "vdevice")));
215 _FDT((fdt_property_string(fdt
, "device_type", "vdevice")));
216 _FDT((fdt_property_string(fdt
, "compatible", "IBM,vdevice")));
217 _FDT((fdt_property_cell(fdt
, "#address-cells", 0x1)));
218 _FDT((fdt_property_cell(fdt
, "#size-cells", 0x0)));
219 _FDT((fdt_property_cell(fdt
, "#interrupt-cells", 0x2)));
220 _FDT((fdt_property(fdt
, "interrupt-controller", NULL
, 0)));
222 _FDT((fdt_end_node(fdt
)));
224 _FDT((fdt_end_node(fdt
))); /* close root node */
225 _FDT((fdt_finish(fdt
)));
230 static void spapr_finalize_fdt(sPAPREnvironment
*spapr
,
231 target_phys_addr_t fdt_addr
,
232 target_phys_addr_t rtas_addr
,
233 target_phys_addr_t rtas_size
)
238 fdt
= g_malloc(FDT_MAX_SIZE
);
240 /* open out the base tree into a temp buffer for the final tweaks */
241 _FDT((fdt_open_into(spapr
->fdt_skel
, fdt
, FDT_MAX_SIZE
)));
243 ret
= spapr_populate_vdevice(spapr
->vio_bus
, fdt
);
245 fprintf(stderr
, "couldn't setup vio devices in fdt\n");
250 ret
= spapr_rtas_device_tree_setup(fdt
, rtas_addr
, rtas_size
);
252 fprintf(stderr
, "Couldn't set up RTAS device tree properties\n");
255 _FDT((fdt_pack(fdt
)));
257 cpu_physical_memory_write(fdt_addr
, fdt
, fdt_totalsize(fdt
));
262 static uint64_t translate_kernel_address(void *opaque
, uint64_t addr
)
264 return (addr
& 0x0fffffff) + KERNEL_LOAD_ADDR
;
267 static void emulate_spapr_hypercall(CPUState
*env
)
269 env
->gpr
[3] = spapr_hypercall(env
, env
->gpr
[3], &env
->gpr
[4]);
272 static void spapr_reset(void *opaque
)
274 sPAPREnvironment
*spapr
= (sPAPREnvironment
*)opaque
;
276 fprintf(stderr
, "sPAPR reset\n");
278 /* flush out the hash table */
279 memset(spapr
->htab
, 0, spapr
->htab_size
);
282 spapr_finalize_fdt(spapr
, spapr
->fdt_addr
, spapr
->rtas_addr
,
285 /* Set up the entry state */
286 first_cpu
->gpr
[3] = spapr
->fdt_addr
;
287 first_cpu
->gpr
[5] = 0;
288 first_cpu
->halted
= 0;
289 first_cpu
->nip
= spapr
->entry_point
;
293 /* pSeries LPAR / sPAPR hardware init */
294 static void ppc_spapr_init(ram_addr_t ram_size
,
295 const char *boot_device
,
296 const char *kernel_filename
,
297 const char *kernel_cmdline
,
298 const char *initrd_filename
,
299 const char *cpu_model
)
303 ram_addr_t ram_offset
;
304 uint32_t initrd_base
;
305 long kernel_size
, initrd_size
, fw_size
;
306 long pteg_shift
= 17;
309 spapr
= g_malloc(sizeof(*spapr
));
310 cpu_ppc_hypercall
= emulate_spapr_hypercall
;
312 /* We place the device tree just below either the top of RAM, or
313 * 2GB, so that it can be processed with 32-bit code if
315 spapr
->fdt_addr
= MIN(ram_size
, 0x80000000) - FDT_MAX_SIZE
;
316 spapr
->rtas_addr
= spapr
->fdt_addr
- RTAS_MAX_SIZE
;
319 if (cpu_model
== NULL
) {
320 cpu_model
= "POWER7";
322 for (i
= 0; i
< smp_cpus
; i
++) {
323 env
= cpu_init(cpu_model
);
326 fprintf(stderr
, "Unable to find PowerPC CPU definition\n");
329 /* Set time-base frequency to 512 MHz */
330 cpu_ppc_tb_init(env
, TIMEBASE_FREQ
);
331 qemu_register_reset((QEMUResetHandler
*)&cpu_reset
, env
);
333 env
->hreset_vector
= 0x60;
334 env
->hreset_excp_prefix
= 0;
335 env
->gpr
[3] = env
->cpu_index
;
339 spapr
->ram_limit
= ram_size
;
340 ram_offset
= qemu_ram_alloc(NULL
, "ppc_spapr.ram", spapr
->ram_limit
);
341 cpu_register_physical_memory(0, ram_size
, ram_offset
);
343 /* allocate hash page table. For now we always make this 16mb,
344 * later we should probably make it scale to the size of guest
346 spapr
->htab_size
= 1ULL << (pteg_shift
+ 7);
347 spapr
->htab
= qemu_memalign(spapr
->htab_size
, spapr
->htab_size
);
349 for (env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
350 env
->external_htab
= spapr
->htab
;
352 env
->htab_mask
= spapr
->htab_size
- 1;
354 /* Tell KVM that we're in PAPR mode */
355 env
->spr
[SPR_SDR1
] = (unsigned long)spapr
->htab
|
356 ((pteg_shift
+ 7) - 18);
357 env
->spr
[SPR_HIOR
] = 0;
360 kvmppc_set_papr(env
);
364 filename
= qemu_find_file(QEMU_FILE_TYPE_BIOS
, "spapr-rtas.bin");
365 spapr
->rtas_size
= load_image_targphys(filename
, spapr
->rtas_addr
,
366 ram_size
- spapr
->rtas_addr
);
367 if (spapr
->rtas_size
< 0) {
368 hw_error("qemu: could not load LPAR rtas '%s'\n", filename
);
373 /* Set up Interrupt Controller */
374 spapr
->icp
= xics_system_init(XICS_IRQS
);
377 spapr
->vio_bus
= spapr_vio_bus_init();
379 for (i
= 0; i
< MAX_SERIAL_PORTS
; i
++) {
381 spapr_vty_create(spapr
->vio_bus
, SPAPR_VTY_BASE_ADDRESS
+ i
,
386 for (i
= 0; i
< nb_nics
; i
++) {
387 NICInfo
*nd
= &nd_table
[i
];
390 nd
->model
= g_strdup("ibmveth");
393 if (strcmp(nd
->model
, "ibmveth") == 0) {
394 spapr_vlan_create(spapr
->vio_bus
, 0x1000 + i
, nd
);
396 fprintf(stderr
, "pSeries (sPAPR) platform does not support "
397 "NIC model '%s' (only ibmveth is supported)\n",
403 for (i
= 0; i
<= drive_get_max_bus(IF_SCSI
); i
++) {
404 spapr_vscsi_create(spapr
->vio_bus
, 0x2000 + i
);
407 if (kernel_filename
) {
408 uint64_t lowaddr
= 0;
410 kernel_size
= load_elf(kernel_filename
, translate_kernel_address
, NULL
,
411 NULL
, &lowaddr
, NULL
, 1, ELF_MACHINE
, 0);
412 if (kernel_size
< 0) {
413 kernel_size
= load_image_targphys(kernel_filename
,
415 ram_size
- KERNEL_LOAD_ADDR
);
417 if (kernel_size
< 0) {
418 fprintf(stderr
, "qemu: could not load kernel '%s'\n",
424 if (initrd_filename
) {
425 initrd_base
= INITRD_LOAD_ADDR
;
426 initrd_size
= load_image_targphys(initrd_filename
, initrd_base
,
427 ram_size
- initrd_base
);
428 if (initrd_size
< 0) {
429 fprintf(stderr
, "qemu: could not load initial ram disk '%s'\n",
438 spapr
->entry_point
= KERNEL_LOAD_ADDR
;
440 if (ram_size
< (MIN_RAM_SLOF
<< 20)) {
441 fprintf(stderr
, "qemu: pSeries SLOF firmware requires >= "
442 "%ldM guest RAM\n", MIN_RAM_SLOF
);
445 filename
= qemu_find_file(QEMU_FILE_TYPE_BIOS
, FW_FILE_NAME
);
446 fw_size
= load_image_targphys(filename
, 0, FW_MAX_SIZE
);
448 hw_error("qemu: could not load LPAR rtas '%s'\n", filename
);
452 spapr
->entry_point
= 0x100;
456 /* SLOF will startup the secondary CPUs using RTAS,
457 rather than expecting a kexec() style entry */
458 for (env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
463 /* Prepare the device tree */
464 spapr
->fdt_skel
= spapr_create_fdt_skel(cpu_model
,
465 initrd_base
, initrd_size
,
466 boot_device
, kernel_cmdline
,
468 assert(spapr
->fdt_skel
!= NULL
);
470 qemu_register_reset(spapr_reset
, spapr
);
473 static QEMUMachine spapr_machine
= {
475 .desc
= "pSeries Logical Partition (PAPR compliant)",
476 .init
= ppc_spapr_init
,
477 .max_cpus
= MAX_CPUS
,
483 static void spapr_machine_init(void)
485 qemu_register_machine(&spapr_machine
);
488 machine_init(spapr_machine_init
);