2 * QEMU PowerPC e500-based platforms
4 * Copyright (C) 2009 Freescale Semiconductor, Inc. All rights reserved.
6 * Author: Yu Liu, <yu.liu@freescale.com>
8 * This file is derived from hw/ppc440_bamboo.c,
9 * the copyright for that material belongs to the original owners.
11 * This is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
18 #include "qemu-common.h"
20 #include "e500-ccsr.h"
22 #include "qemu/config-file.h"
24 #include "hw/char/serial.h"
25 #include "hw/pci/pci.h"
26 #include "hw/boards.h"
27 #include "sysemu/sysemu.h"
28 #include "sysemu/kvm.h"
30 #include "sysemu/device_tree.h"
31 #include "hw/ppc/openpic.h"
32 #include "hw/ppc/ppc.h"
33 #include "hw/loader.h"
35 #include "hw/sysbus.h"
36 #include "exec/address-spaces.h"
37 #include "qemu/host-utils.h"
38 #include "hw/pci-host/ppce500.h"
39 #include "qemu/error-report.h"
40 #include "hw/platform-bus.h"
41 #include "hw/net/fsl_etsec/etsec.h"
43 #define EPAPR_MAGIC (0x45504150)
44 #define BINARY_DEVICE_TREE_FILE "mpc8544ds.dtb"
45 #define DTC_LOAD_PAD 0x1800000
46 #define DTC_PAD_MASK 0xFFFFF
47 #define DTB_MAX_SIZE (8 * 1024 * 1024)
48 #define INITRD_LOAD_PAD 0x2000000
49 #define INITRD_PAD_MASK 0xFFFFFF
51 #define RAM_SIZES_ALIGN (64UL << 20)
53 /* TODO: parameterize */
54 #define MPC8544_CCSRBAR_BASE 0xE0000000ULL
55 #define MPC8544_CCSRBAR_SIZE 0x00100000ULL
56 #define MPC8544_MPIC_REGS_OFFSET 0x40000ULL
57 #define MPC8544_MSI_REGS_OFFSET 0x41600ULL
58 #define MPC8544_SERIAL0_REGS_OFFSET 0x4500ULL
59 #define MPC8544_SERIAL1_REGS_OFFSET 0x4600ULL
60 #define MPC8544_PCI_REGS_OFFSET 0x8000ULL
61 #define MPC8544_PCI_REGS_BASE (MPC8544_CCSRBAR_BASE + \
62 MPC8544_PCI_REGS_OFFSET)
63 #define MPC8544_PCI_REGS_SIZE 0x1000ULL
64 #define MPC8544_PCI_IO 0xE1000000ULL
65 #define MPC8544_UTIL_OFFSET 0xe0000ULL
66 #define MPC8544_SPIN_BASE 0xEF000000ULL
67 #define MPC8XXX_GPIO_OFFSET 0x000FF000ULL
68 #define MPC8XXX_GPIO_IRQ 43
77 static uint32_t *pci_map_create(void *fdt
, uint32_t mpic
, int first_slot
,
78 int nr_slots
, int *len
)
84 int last_slot
= first_slot
+ nr_slots
;
87 *len
= nr_slots
* 4 * 7 * sizeof(uint32_t);
88 pci_map
= g_malloc(*len
);
90 for (slot
= first_slot
; slot
< last_slot
; slot
++) {
91 for (pci_irq
= 0; pci_irq
< 4; pci_irq
++) {
92 pci_map
[i
++] = cpu_to_be32(slot
<< 11);
93 pci_map
[i
++] = cpu_to_be32(0x0);
94 pci_map
[i
++] = cpu_to_be32(0x0);
95 pci_map
[i
++] = cpu_to_be32(pci_irq
+ 1);
96 pci_map
[i
++] = cpu_to_be32(mpic
);
97 host_irq
= ppce500_pci_map_irq_slot(slot
, pci_irq
);
98 pci_map
[i
++] = cpu_to_be32(host_irq
+ 1);
99 pci_map
[i
++] = cpu_to_be32(0x1);
103 assert((i
* sizeof(uint32_t)) == *len
);
108 static void dt_serial_create(void *fdt
, unsigned long long offset
,
109 const char *soc
, const char *mpic
,
110 const char *alias
, int idx
, bool defcon
)
114 snprintf(ser
, sizeof(ser
), "%s/serial@%llx", soc
, offset
);
115 qemu_fdt_add_subnode(fdt
, ser
);
116 qemu_fdt_setprop_string(fdt
, ser
, "device_type", "serial");
117 qemu_fdt_setprop_string(fdt
, ser
, "compatible", "ns16550");
118 qemu_fdt_setprop_cells(fdt
, ser
, "reg", offset
, 0x100);
119 qemu_fdt_setprop_cell(fdt
, ser
, "cell-index", idx
);
120 qemu_fdt_setprop_cell(fdt
, ser
, "clock-frequency", 0);
121 qemu_fdt_setprop_cells(fdt
, ser
, "interrupts", 42, 2);
122 qemu_fdt_setprop_phandle(fdt
, ser
, "interrupt-parent", mpic
);
123 qemu_fdt_setprop_string(fdt
, "/aliases", alias
, ser
);
126 qemu_fdt_setprop_string(fdt
, "/chosen", "linux,stdout-path", ser
);
130 static void create_dt_mpc8xxx_gpio(void *fdt
, const char *soc
, const char *mpic
)
132 hwaddr mmio0
= MPC8XXX_GPIO_OFFSET
;
133 int irq0
= MPC8XXX_GPIO_IRQ
;
134 gchar
*node
= g_strdup_printf("%s/gpio@%"PRIx64
, soc
, mmio0
);
135 gchar
*poweroff
= g_strdup_printf("%s/power-off", soc
);
138 qemu_fdt_add_subnode(fdt
, node
);
139 qemu_fdt_setprop_string(fdt
, node
, "compatible", "fsl,qoriq-gpio");
140 qemu_fdt_setprop_cells(fdt
, node
, "reg", mmio0
, 0x1000);
141 qemu_fdt_setprop_cells(fdt
, node
, "interrupts", irq0
, 0x2);
142 qemu_fdt_setprop_phandle(fdt
, node
, "interrupt-parent", mpic
);
143 qemu_fdt_setprop_cells(fdt
, node
, "#gpio-cells", 2);
144 qemu_fdt_setprop(fdt
, node
, "gpio-controller", NULL
, 0);
145 gpio_ph
= qemu_fdt_alloc_phandle(fdt
);
146 qemu_fdt_setprop_cell(fdt
, node
, "phandle", gpio_ph
);
147 qemu_fdt_setprop_cell(fdt
, node
, "linux,phandle", gpio_ph
);
150 qemu_fdt_add_subnode(fdt
, poweroff
);
151 qemu_fdt_setprop_string(fdt
, poweroff
, "compatible", "gpio-poweroff");
152 qemu_fdt_setprop_cells(fdt
, poweroff
, "gpios", gpio_ph
, 0, 0);
158 typedef struct PlatformDevtreeData
{
163 PlatformBusDevice
*pbus
;
164 } PlatformDevtreeData
;
166 static int create_devtree_etsec(SysBusDevice
*sbdev
, PlatformDevtreeData
*data
)
168 eTSEC
*etsec
= ETSEC_COMMON(sbdev
);
169 PlatformBusDevice
*pbus
= data
->pbus
;
170 hwaddr mmio0
= platform_bus_get_mmio_addr(pbus
, sbdev
, 0);
171 int irq0
= platform_bus_get_irqn(pbus
, sbdev
, 0);
172 int irq1
= platform_bus_get_irqn(pbus
, sbdev
, 1);
173 int irq2
= platform_bus_get_irqn(pbus
, sbdev
, 2);
174 gchar
*node
= g_strdup_printf("/platform/ethernet@%"PRIx64
, mmio0
);
175 gchar
*group
= g_strdup_printf("%s/queue-group", node
);
176 void *fdt
= data
->fdt
;
178 assert((int64_t)mmio0
>= 0);
183 qemu_fdt_add_subnode(fdt
, node
);
184 qemu_fdt_setprop_string(fdt
, node
, "device_type", "network");
185 qemu_fdt_setprop_string(fdt
, node
, "compatible", "fsl,etsec2");
186 qemu_fdt_setprop_string(fdt
, node
, "model", "eTSEC");
187 qemu_fdt_setprop(fdt
, node
, "local-mac-address", etsec
->conf
.macaddr
.a
, 6);
188 qemu_fdt_setprop_cells(fdt
, node
, "fixed-link", 0, 1, 1000, 0, 0);
190 qemu_fdt_add_subnode(fdt
, group
);
191 qemu_fdt_setprop_cells(fdt
, group
, "reg", mmio0
, 0x1000);
192 qemu_fdt_setprop_cells(fdt
, group
, "interrupts",
193 data
->irq_start
+ irq0
, 0x2,
194 data
->irq_start
+ irq1
, 0x2,
195 data
->irq_start
+ irq2
, 0x2);
203 static int sysbus_device_create_devtree(SysBusDevice
*sbdev
, void *opaque
)
205 PlatformDevtreeData
*data
= opaque
;
206 bool matched
= false;
208 if (object_dynamic_cast(OBJECT(sbdev
), TYPE_ETSEC_COMMON
)) {
209 create_devtree_etsec(sbdev
, data
);
214 error_report("Device %s is not supported by this machine yet.",
215 qdev_fw_name(DEVICE(sbdev
)));
222 static void platform_bus_create_devtree(PPCE500Params
*params
, void *fdt
,
225 gchar
*node
= g_strdup_printf("/platform@%"PRIx64
, params
->platform_bus_base
);
226 const char platcomp
[] = "qemu,platform\0simple-bus";
227 uint64_t addr
= params
->platform_bus_base
;
228 uint64_t size
= params
->platform_bus_size
;
229 int irq_start
= params
->platform_bus_first_irq
;
230 PlatformBusDevice
*pbus
;
233 /* Create a /platform node that we can put all devices into */
235 qemu_fdt_add_subnode(fdt
, node
);
236 qemu_fdt_setprop(fdt
, node
, "compatible", platcomp
, sizeof(platcomp
));
238 /* Our platform bus region is less than 32bit big, so 1 cell is enough for
240 qemu_fdt_setprop_cells(fdt
, node
, "#size-cells", 1);
241 qemu_fdt_setprop_cells(fdt
, node
, "#address-cells", 1);
242 qemu_fdt_setprop_cells(fdt
, node
, "ranges", 0, addr
>> 32, addr
, size
);
244 qemu_fdt_setprop_phandle(fdt
, node
, "interrupt-parent", mpic
);
246 dev
= qdev_find_recursive(sysbus_get_default(), TYPE_PLATFORM_BUS_DEVICE
);
247 pbus
= PLATFORM_BUS_DEVICE(dev
);
249 /* We can only create dt nodes for dynamic devices when they're ready */
250 if (pbus
->done_gathering
) {
251 PlatformDevtreeData data
= {
254 .irq_start
= irq_start
,
259 /* Loop through all dynamic sysbus devices and create nodes for them */
260 foreach_dynamic_sysbus_device(sysbus_device_create_devtree
, &data
);
266 static int ppce500_load_device_tree(MachineState
*machine
,
267 PPCE500Params
*params
,
275 CPUPPCState
*env
= first_cpu
->env_ptr
;
277 uint64_t mem_reg_property
[] = { 0, cpu_to_be64(machine
->ram_size
) };
280 uint8_t hypercall
[16];
281 uint32_t clock_freq
= 400000000;
282 uint32_t tb_freq
= 400000000;
284 char compatible_sb
[] = "fsl,mpc8544-immr\0simple-bus";
292 uint32_t *pci_map
= NULL
;
294 uint32_t pci_ranges
[14] =
296 0x2000000, 0x0, 0xc0000000,
304 QemuOpts
*machine_opts
= qemu_get_machine_opts();
305 const char *dtb_file
= qemu_opt_get(machine_opts
, "dtb");
306 const char *toplevel_compat
= qemu_opt_get(machine_opts
, "dt_compatible");
310 filename
= qemu_find_file(QEMU_FILE_TYPE_BIOS
, dtb_file
);
315 fdt
= load_device_tree(filename
, &fdt_size
);
322 fdt
= create_device_tree(&fdt_size
);
327 /* Manipulate device tree in memory. */
328 qemu_fdt_setprop_cell(fdt
, "/", "#address-cells", 2);
329 qemu_fdt_setprop_cell(fdt
, "/", "#size-cells", 2);
331 qemu_fdt_add_subnode(fdt
, "/memory");
332 qemu_fdt_setprop_string(fdt
, "/memory", "device_type", "memory");
333 qemu_fdt_setprop(fdt
, "/memory", "reg", mem_reg_property
,
334 sizeof(mem_reg_property
));
336 qemu_fdt_add_subnode(fdt
, "/chosen");
338 ret
= qemu_fdt_setprop_cell(fdt
, "/chosen", "linux,initrd-start",
341 fprintf(stderr
, "couldn't set /chosen/linux,initrd-start\n");
344 ret
= qemu_fdt_setprop_cell(fdt
, "/chosen", "linux,initrd-end",
345 (initrd_base
+ initrd_size
));
347 fprintf(stderr
, "couldn't set /chosen/linux,initrd-end\n");
352 if (kernel_base
!= -1ULL) {
353 qemu_fdt_setprop_cells(fdt
, "/chosen", "qemu,boot-kernel",
354 kernel_base
>> 32, kernel_base
,
355 kernel_size
>> 32, kernel_size
);
358 ret
= qemu_fdt_setprop_string(fdt
, "/chosen", "bootargs",
359 machine
->kernel_cmdline
);
361 fprintf(stderr
, "couldn't set /chosen/bootargs\n");
364 /* Read out host's frequencies */
365 clock_freq
= kvmppc_get_clockfreq();
366 tb_freq
= kvmppc_get_tbfreq();
368 /* indicate KVM hypercall interface */
369 qemu_fdt_add_subnode(fdt
, "/hypervisor");
370 qemu_fdt_setprop_string(fdt
, "/hypervisor", "compatible",
372 kvmppc_get_hypercall(env
, hypercall
, sizeof(hypercall
));
373 qemu_fdt_setprop(fdt
, "/hypervisor", "hcall-instructions",
374 hypercall
, sizeof(hypercall
));
375 /* if KVM supports the idle hcall, set property indicating this */
376 if (kvmppc_get_hasidle(env
)) {
377 qemu_fdt_setprop(fdt
, "/hypervisor", "has-idle", NULL
, 0);
381 /* Create CPU nodes */
382 qemu_fdt_add_subnode(fdt
, "/cpus");
383 qemu_fdt_setprop_cell(fdt
, "/cpus", "#address-cells", 1);
384 qemu_fdt_setprop_cell(fdt
, "/cpus", "#size-cells", 0);
386 /* We need to generate the cpu nodes in reverse order, so Linux can pick
387 the first node as boot node and be happy */
388 for (i
= smp_cpus
- 1; i
>= 0; i
--) {
392 uint64_t cpu_release_addr
= MPC8544_SPIN_BASE
+ (i
* 0x20);
394 cpu
= qemu_get_cpu(i
);
399 pcpu
= POWERPC_CPU(cpu
);
401 snprintf(cpu_name
, sizeof(cpu_name
), "/cpus/PowerPC,8544@%x",
402 ppc_get_vcpu_dt_id(pcpu
));
403 qemu_fdt_add_subnode(fdt
, cpu_name
);
404 qemu_fdt_setprop_cell(fdt
, cpu_name
, "clock-frequency", clock_freq
);
405 qemu_fdt_setprop_cell(fdt
, cpu_name
, "timebase-frequency", tb_freq
);
406 qemu_fdt_setprop_string(fdt
, cpu_name
, "device_type", "cpu");
407 qemu_fdt_setprop_cell(fdt
, cpu_name
, "reg",
408 ppc_get_vcpu_dt_id(pcpu
));
409 qemu_fdt_setprop_cell(fdt
, cpu_name
, "d-cache-line-size",
410 env
->dcache_line_size
);
411 qemu_fdt_setprop_cell(fdt
, cpu_name
, "i-cache-line-size",
412 env
->icache_line_size
);
413 qemu_fdt_setprop_cell(fdt
, cpu_name
, "d-cache-size", 0x8000);
414 qemu_fdt_setprop_cell(fdt
, cpu_name
, "i-cache-size", 0x8000);
415 qemu_fdt_setprop_cell(fdt
, cpu_name
, "bus-frequency", 0);
416 if (cpu
->cpu_index
) {
417 qemu_fdt_setprop_string(fdt
, cpu_name
, "status", "disabled");
418 qemu_fdt_setprop_string(fdt
, cpu_name
, "enable-method",
420 qemu_fdt_setprop_u64(fdt
, cpu_name
, "cpu-release-addr",
423 qemu_fdt_setprop_string(fdt
, cpu_name
, "status", "okay");
427 qemu_fdt_add_subnode(fdt
, "/aliases");
428 /* XXX These should go into their respective devices' code */
429 snprintf(soc
, sizeof(soc
), "/soc@%llx", MPC8544_CCSRBAR_BASE
);
430 qemu_fdt_add_subnode(fdt
, soc
);
431 qemu_fdt_setprop_string(fdt
, soc
, "device_type", "soc");
432 qemu_fdt_setprop(fdt
, soc
, "compatible", compatible_sb
,
433 sizeof(compatible_sb
));
434 qemu_fdt_setprop_cell(fdt
, soc
, "#address-cells", 1);
435 qemu_fdt_setprop_cell(fdt
, soc
, "#size-cells", 1);
436 qemu_fdt_setprop_cells(fdt
, soc
, "ranges", 0x0,
437 MPC8544_CCSRBAR_BASE
>> 32, MPC8544_CCSRBAR_BASE
,
438 MPC8544_CCSRBAR_SIZE
);
439 /* XXX should contain a reasonable value */
440 qemu_fdt_setprop_cell(fdt
, soc
, "bus-frequency", 0);
442 snprintf(mpic
, sizeof(mpic
), "%s/pic@%llx", soc
, MPC8544_MPIC_REGS_OFFSET
);
443 qemu_fdt_add_subnode(fdt
, mpic
);
444 qemu_fdt_setprop_string(fdt
, mpic
, "device_type", "open-pic");
445 qemu_fdt_setprop_string(fdt
, mpic
, "compatible", "fsl,mpic");
446 qemu_fdt_setprop_cells(fdt
, mpic
, "reg", MPC8544_MPIC_REGS_OFFSET
,
448 qemu_fdt_setprop_cell(fdt
, mpic
, "#address-cells", 0);
449 qemu_fdt_setprop_cell(fdt
, mpic
, "#interrupt-cells", 2);
450 mpic_ph
= qemu_fdt_alloc_phandle(fdt
);
451 qemu_fdt_setprop_cell(fdt
, mpic
, "phandle", mpic_ph
);
452 qemu_fdt_setprop_cell(fdt
, mpic
, "linux,phandle", mpic_ph
);
453 qemu_fdt_setprop(fdt
, mpic
, "interrupt-controller", NULL
, 0);
456 * We have to generate ser1 first, because Linux takes the first
457 * device it finds in the dt as serial output device. And we generate
458 * devices in reverse order to the dt.
461 dt_serial_create(fdt
, MPC8544_SERIAL1_REGS_OFFSET
,
462 soc
, mpic
, "serial1", 1, false);
466 dt_serial_create(fdt
, MPC8544_SERIAL0_REGS_OFFSET
,
467 soc
, mpic
, "serial0", 0, true);
470 snprintf(gutil
, sizeof(gutil
), "%s/global-utilities@%llx", soc
,
471 MPC8544_UTIL_OFFSET
);
472 qemu_fdt_add_subnode(fdt
, gutil
);
473 qemu_fdt_setprop_string(fdt
, gutil
, "compatible", "fsl,mpc8544-guts");
474 qemu_fdt_setprop_cells(fdt
, gutil
, "reg", MPC8544_UTIL_OFFSET
, 0x1000);
475 qemu_fdt_setprop(fdt
, gutil
, "fsl,has-rstcr", NULL
, 0);
477 snprintf(msi
, sizeof(msi
), "/%s/msi@%llx", soc
, MPC8544_MSI_REGS_OFFSET
);
478 qemu_fdt_add_subnode(fdt
, msi
);
479 qemu_fdt_setprop_string(fdt
, msi
, "compatible", "fsl,mpic-msi");
480 qemu_fdt_setprop_cells(fdt
, msi
, "reg", MPC8544_MSI_REGS_OFFSET
, 0x200);
481 msi_ph
= qemu_fdt_alloc_phandle(fdt
);
482 qemu_fdt_setprop_cells(fdt
, msi
, "msi-available-ranges", 0x0, 0x100);
483 qemu_fdt_setprop_phandle(fdt
, msi
, "interrupt-parent", mpic
);
484 qemu_fdt_setprop_cells(fdt
, msi
, "interrupts",
493 qemu_fdt_setprop_cell(fdt
, msi
, "phandle", msi_ph
);
494 qemu_fdt_setprop_cell(fdt
, msi
, "linux,phandle", msi_ph
);
496 snprintf(pci
, sizeof(pci
), "/pci@%llx", MPC8544_PCI_REGS_BASE
);
497 qemu_fdt_add_subnode(fdt
, pci
);
498 qemu_fdt_setprop_cell(fdt
, pci
, "cell-index", 0);
499 qemu_fdt_setprop_string(fdt
, pci
, "compatible", "fsl,mpc8540-pci");
500 qemu_fdt_setprop_string(fdt
, pci
, "device_type", "pci");
501 qemu_fdt_setprop_cells(fdt
, pci
, "interrupt-map-mask", 0xf800, 0x0,
503 pci_map
= pci_map_create(fdt
, qemu_fdt_get_phandle(fdt
, mpic
),
504 params
->pci_first_slot
, params
->pci_nr_slots
,
506 qemu_fdt_setprop(fdt
, pci
, "interrupt-map", pci_map
, len
);
507 qemu_fdt_setprop_phandle(fdt
, pci
, "interrupt-parent", mpic
);
508 qemu_fdt_setprop_cells(fdt
, pci
, "interrupts", 24, 2);
509 qemu_fdt_setprop_cells(fdt
, pci
, "bus-range", 0, 255);
510 for (i
= 0; i
< 14; i
++) {
511 pci_ranges
[i
] = cpu_to_be32(pci_ranges
[i
]);
513 qemu_fdt_setprop_cell(fdt
, pci
, "fsl,msi", msi_ph
);
514 qemu_fdt_setprop(fdt
, pci
, "ranges", pci_ranges
, sizeof(pci_ranges
));
515 qemu_fdt_setprop_cells(fdt
, pci
, "reg", MPC8544_PCI_REGS_BASE
>> 32,
516 MPC8544_PCI_REGS_BASE
, 0, 0x1000);
517 qemu_fdt_setprop_cell(fdt
, pci
, "clock-frequency", 66666666);
518 qemu_fdt_setprop_cell(fdt
, pci
, "#interrupt-cells", 1);
519 qemu_fdt_setprop_cell(fdt
, pci
, "#size-cells", 2);
520 qemu_fdt_setprop_cell(fdt
, pci
, "#address-cells", 3);
521 qemu_fdt_setprop_string(fdt
, "/aliases", "pci0", pci
);
523 if (params
->has_mpc8xxx_gpio
) {
524 create_dt_mpc8xxx_gpio(fdt
, soc
, mpic
);
527 if (params
->has_platform_bus
) {
528 platform_bus_create_devtree(params
, fdt
, mpic
);
531 params
->fixup_devtree(params
, fdt
);
533 if (toplevel_compat
) {
534 qemu_fdt_setprop(fdt
, "/", "compatible", toplevel_compat
,
535 strlen(toplevel_compat
) + 1);
540 qemu_fdt_dumpdtb(fdt
, fdt_size
);
541 cpu_physical_memory_write(addr
, fdt
, fdt_size
);
551 typedef struct DeviceTreeParams
{
552 MachineState
*machine
;
553 PPCE500Params params
;
562 static void ppce500_reset_device_tree(void *opaque
)
564 DeviceTreeParams
*p
= opaque
;
565 ppce500_load_device_tree(p
->machine
, &p
->params
, p
->addr
, p
->initrd_base
,
566 p
->initrd_size
, p
->kernel_base
, p
->kernel_size
,
570 static void ppce500_init_notify(Notifier
*notifier
, void *data
)
572 DeviceTreeParams
*p
= container_of(notifier
, DeviceTreeParams
, notifier
);
573 ppce500_reset_device_tree(p
);
576 static int ppce500_prep_device_tree(MachineState
*machine
,
577 PPCE500Params
*params
,
584 DeviceTreeParams
*p
= g_new(DeviceTreeParams
, 1);
585 p
->machine
= machine
;
588 p
->initrd_base
= initrd_base
;
589 p
->initrd_size
= initrd_size
;
590 p
->kernel_base
= kernel_base
;
591 p
->kernel_size
= kernel_size
;
593 qemu_register_reset(ppce500_reset_device_tree
, p
);
594 p
->notifier
.notify
= ppce500_init_notify
;
595 qemu_add_machine_init_done_notifier(&p
->notifier
);
597 /* Issue the device tree loader once, so that we get the size of the blob */
598 return ppce500_load_device_tree(machine
, params
, addr
, initrd_base
,
599 initrd_size
, kernel_base
, kernel_size
,
603 /* Create -kernel TLB entries for BookE. */
604 static inline hwaddr
booke206_page_size_to_tlb(uint64_t size
)
606 return 63 - clz64(size
>> 10);
609 static int booke206_initial_map_tsize(CPUPPCState
*env
)
611 struct boot_info
*bi
= env
->load_info
;
615 /* Our initial TLB entry needs to cover everything from 0 to
616 the device tree top */
617 dt_end
= bi
->dt_base
+ bi
->dt_size
;
618 ps
= booke206_page_size_to_tlb(dt_end
) + 1;
620 /* e500v2 can only do even TLB size bits */
626 static uint64_t mmubooke_initial_mapsize(CPUPPCState
*env
)
630 tsize
= booke206_initial_map_tsize(env
);
631 return (1ULL << 10 << tsize
);
634 static void mmubooke_create_initial_mapping(CPUPPCState
*env
)
636 ppcmas_tlb_t
*tlb
= booke206_get_tlbm(env
, 1, 0, 0);
640 ps
= booke206_initial_map_tsize(env
);
641 size
= (ps
<< MAS1_TSIZE_SHIFT
);
642 tlb
->mas1
= MAS1_VALID
| size
;
645 tlb
->mas7_3
|= MAS3_UR
| MAS3_UW
| MAS3_UX
| MAS3_SR
| MAS3_SW
| MAS3_SX
;
647 env
->tlb_dirty
= true;
650 static void ppce500_cpu_reset_sec(void *opaque
)
652 PowerPCCPU
*cpu
= opaque
;
653 CPUState
*cs
= CPU(cpu
);
657 /* Secondary CPU starts in halted state for now. Needs to change when
658 implementing non-kernel boot. */
660 cs
->exception_index
= EXCP_HLT
;
663 static void ppce500_cpu_reset(void *opaque
)
665 PowerPCCPU
*cpu
= opaque
;
666 CPUState
*cs
= CPU(cpu
);
667 CPUPPCState
*env
= &cpu
->env
;
668 struct boot_info
*bi
= env
->load_info
;
672 /* Set initial guest state. */
674 env
->gpr
[1] = (16<<20) - 8;
675 env
->gpr
[3] = bi
->dt_base
;
678 env
->gpr
[6] = EPAPR_MAGIC
;
679 env
->gpr
[7] = mmubooke_initial_mapsize(env
);
682 env
->nip
= bi
->entry
;
683 mmubooke_create_initial_mapping(env
);
686 static DeviceState
*ppce500_init_mpic_qemu(PPCE500Params
*params
,
693 dev
= qdev_create(NULL
, TYPE_OPENPIC
);
694 qdev_prop_set_uint32(dev
, "model", params
->mpic_version
);
695 qdev_prop_set_uint32(dev
, "nb_cpus", smp_cpus
);
697 qdev_init_nofail(dev
);
698 s
= SYS_BUS_DEVICE(dev
);
701 for (i
= 0; i
< smp_cpus
; i
++) {
702 for (j
= 0; j
< OPENPIC_OUTPUT_NB
; j
++) {
703 sysbus_connect_irq(s
, k
++, irqs
[i
][j
]);
710 static DeviceState
*ppce500_init_mpic_kvm(PPCE500Params
*params
,
717 dev
= qdev_create(NULL
, TYPE_KVM_OPENPIC
);
718 qdev_prop_set_uint32(dev
, "model", params
->mpic_version
);
726 if (kvm_openpic_connect_vcpu(dev
, cs
)) {
727 fprintf(stderr
, "%s: failed to connect vcpu to irqchip\n",
736 static qemu_irq
*ppce500_init_mpic(PPCE500Params
*params
, MemoryRegion
*ccsr
,
740 DeviceState
*dev
= NULL
;
744 mpic
= g_new0(qemu_irq
, 256);
747 QemuOpts
*machine_opts
= qemu_get_machine_opts();
748 bool irqchip_allowed
= qemu_opt_get_bool(machine_opts
,
749 "kernel_irqchip", true);
750 bool irqchip_required
= qemu_opt_get_bool(machine_opts
,
751 "kernel_irqchip", false);
753 if (irqchip_allowed
) {
754 dev
= ppce500_init_mpic_kvm(params
, irqs
);
757 if (irqchip_required
&& !dev
) {
758 fprintf(stderr
, "%s: irqchip requested but unavailable\n",
765 dev
= ppce500_init_mpic_qemu(params
, irqs
);
768 for (i
= 0; i
< 256; i
++) {
769 mpic
[i
] = qdev_get_gpio_in(dev
, i
);
772 s
= SYS_BUS_DEVICE(dev
);
773 memory_region_add_subregion(ccsr
, MPC8544_MPIC_REGS_OFFSET
,
779 static void ppce500_power_off(void *opaque
, int line
, int on
)
782 qemu_system_shutdown_request();
786 void ppce500_init(MachineState
*machine
, PPCE500Params
*params
)
788 MemoryRegion
*address_space_mem
= get_system_memory();
789 MemoryRegion
*ram
= g_new(MemoryRegion
, 1);
791 CPUPPCState
*env
= NULL
;
793 hwaddr kernel_base
= -1LL;
796 hwaddr initrd_base
= 0;
800 hwaddr bios_entry
= 0;
801 target_long bios_size
;
802 struct boot_info
*boot_info
;
805 /* irq num for pin INTA, INTB, INTC and INTD is 1, 2, 3 and
807 unsigned int pci_irq_nrs
[PCI_NUM_PINS
] = {1, 2, 3, 4};
808 qemu_irq
**irqs
, *mpic
;
810 CPUPPCState
*firstenv
= NULL
;
811 MemoryRegion
*ccsr_addr_space
;
813 PPCE500CCSRState
*ccsr
;
816 if (machine
->cpu_model
== NULL
) {
817 machine
->cpu_model
= "e500v2_v30";
820 irqs
= g_malloc0(smp_cpus
* sizeof(qemu_irq
*));
821 irqs
[0] = g_malloc0(smp_cpus
* sizeof(qemu_irq
) * OPENPIC_OUTPUT_NB
);
822 for (i
= 0; i
< smp_cpus
; i
++) {
827 cpu
= cpu_ppc_init(machine
->cpu_model
);
829 fprintf(stderr
, "Unable to initialize CPU!\n");
839 irqs
[i
] = irqs
[0] + (i
* OPENPIC_OUTPUT_NB
);
840 input
= (qemu_irq
*)env
->irq_inputs
;
841 irqs
[i
][OPENPIC_OUTPUT_INT
] = input
[PPCE500_INPUT_INT
];
842 irqs
[i
][OPENPIC_OUTPUT_CINT
] = input
[PPCE500_INPUT_CINT
];
843 env
->spr_cb
[SPR_BOOKE_PIR
].default_value
= cs
->cpu_index
= i
;
844 env
->mpic_iack
= MPC8544_CCSRBAR_BASE
+
845 MPC8544_MPIC_REGS_OFFSET
+ 0xa0;
847 ppc_booke_timers_init(cpu
, 400000000, PPC_TIMER_E500
);
849 /* Register reset handler */
852 struct boot_info
*boot_info
;
853 boot_info
= g_malloc0(sizeof(struct boot_info
));
854 qemu_register_reset(ppce500_cpu_reset
, cpu
);
855 env
->load_info
= boot_info
;
858 qemu_register_reset(ppce500_cpu_reset_sec
, cpu
);
864 /* Fixup Memory size on a alignment boundary */
865 ram_size
&= ~(RAM_SIZES_ALIGN
- 1);
866 machine
->ram_size
= ram_size
;
868 /* Register Memory */
869 memory_region_allocate_system_memory(ram
, NULL
, "mpc8544ds.ram", ram_size
);
870 memory_region_add_subregion(address_space_mem
, 0, ram
);
872 dev
= qdev_create(NULL
, "e500-ccsr");
873 object_property_add_child(qdev_get_machine(), "e500-ccsr",
875 qdev_init_nofail(dev
);
877 ccsr_addr_space
= &ccsr
->ccsr_space
;
878 memory_region_add_subregion(address_space_mem
, MPC8544_CCSRBAR_BASE
,
881 mpic
= ppce500_init_mpic(params
, ccsr_addr_space
, irqs
);
885 serial_mm_init(ccsr_addr_space
, MPC8544_SERIAL0_REGS_OFFSET
,
887 serial_hds
[0], DEVICE_BIG_ENDIAN
);
891 serial_mm_init(ccsr_addr_space
, MPC8544_SERIAL1_REGS_OFFSET
,
893 serial_hds
[1], DEVICE_BIG_ENDIAN
);
896 /* General Utility device */
897 dev
= qdev_create(NULL
, "mpc8544-guts");
898 qdev_init_nofail(dev
);
899 s
= SYS_BUS_DEVICE(dev
);
900 memory_region_add_subregion(ccsr_addr_space
, MPC8544_UTIL_OFFSET
,
901 sysbus_mmio_get_region(s
, 0));
904 dev
= qdev_create(NULL
, "e500-pcihost");
905 qdev_prop_set_uint32(dev
, "first_slot", params
->pci_first_slot
);
906 qdev_prop_set_uint32(dev
, "first_pin_irq", pci_irq_nrs
[0]);
907 qdev_init_nofail(dev
);
908 s
= SYS_BUS_DEVICE(dev
);
909 for (i
= 0; i
< PCI_NUM_PINS
; i
++) {
910 sysbus_connect_irq(s
, i
, mpic
[pci_irq_nrs
[i
]]);
913 memory_region_add_subregion(ccsr_addr_space
, MPC8544_PCI_REGS_OFFSET
,
914 sysbus_mmio_get_region(s
, 0));
916 pci_bus
= (PCIBus
*)qdev_get_child_bus(dev
, "pci.0");
918 printf("couldn't create PCI controller!\n");
920 sysbus_mmio_map(SYS_BUS_DEVICE(dev
), 1, MPC8544_PCI_IO
);
923 /* Register network interfaces. */
924 for (i
= 0; i
< nb_nics
; i
++) {
925 pci_nic_init_nofail(&nd_table
[i
], pci_bus
, "virtio", NULL
);
929 /* Register spinning region */
930 sysbus_create_simple("e500-spin", MPC8544_SPIN_BASE
, NULL
);
932 if (cur_base
< (32 * 1024 * 1024)) {
933 /* u-boot occupies memory up to 32MB, so load blobs above */
934 cur_base
= (32 * 1024 * 1024);
937 if (params
->has_mpc8xxx_gpio
) {
938 qemu_irq poweroff_irq
;
940 dev
= qdev_create(NULL
, "mpc8xxx_gpio");
941 s
= SYS_BUS_DEVICE(dev
);
942 qdev_init_nofail(dev
);
943 sysbus_connect_irq(s
, 0, mpic
[MPC8XXX_GPIO_IRQ
]);
944 memory_region_add_subregion(ccsr_addr_space
, MPC8XXX_GPIO_OFFSET
,
945 sysbus_mmio_get_region(s
, 0));
947 /* Power Off GPIO at Pin 0 */
948 poweroff_irq
= qemu_allocate_irq(ppce500_power_off
, NULL
, 0);
949 qdev_connect_gpio_out(dev
, 0, poweroff_irq
);
952 /* Platform Bus Device */
953 if (params
->has_platform_bus
) {
954 dev
= qdev_create(NULL
, TYPE_PLATFORM_BUS_DEVICE
);
955 dev
->id
= TYPE_PLATFORM_BUS_DEVICE
;
956 qdev_prop_set_uint32(dev
, "num_irqs", params
->platform_bus_num_irqs
);
957 qdev_prop_set_uint32(dev
, "mmio_size", params
->platform_bus_size
);
958 qdev_init_nofail(dev
);
959 s
= SYS_BUS_DEVICE(dev
);
961 for (i
= 0; i
< params
->platform_bus_num_irqs
; i
++) {
962 int irqn
= params
->platform_bus_first_irq
+ i
;
963 sysbus_connect_irq(s
, i
, mpic
[irqn
]);
966 memory_region_add_subregion(address_space_mem
,
967 params
->platform_bus_base
,
968 sysbus_mmio_get_region(s
, 0));
972 if (machine
->kernel_filename
) {
973 kernel_base
= cur_base
;
974 kernel_size
= load_image_targphys(machine
->kernel_filename
,
976 ram_size
- cur_base
);
977 if (kernel_size
< 0) {
978 fprintf(stderr
, "qemu: could not load kernel '%s'\n",
979 machine
->kernel_filename
);
983 cur_base
+= kernel_size
;
987 if (machine
->initrd_filename
) {
988 initrd_base
= (cur_base
+ INITRD_LOAD_PAD
) & ~INITRD_PAD_MASK
;
989 initrd_size
= load_image_targphys(machine
->initrd_filename
, initrd_base
,
990 ram_size
- initrd_base
);
992 if (initrd_size
< 0) {
993 fprintf(stderr
, "qemu: could not load initial ram disk '%s'\n",
994 machine
->initrd_filename
);
998 cur_base
= initrd_base
+ initrd_size
;
1002 * Smart firmware defaults ahead!
1004 * We follow the following table to select which payload we execute.
1006 * -kernel | -bios | payload
1007 * ---------+-------+---------
1013 * This ensures backwards compatibility with how we used to expose
1014 * -kernel to users but allows them to run through u-boot as well.
1016 if (bios_name
== NULL
) {
1017 if (machine
->kernel_filename
) {
1018 bios_name
= machine
->kernel_filename
;
1020 bios_name
= "u-boot.e500";
1023 filename
= qemu_find_file(QEMU_FILE_TYPE_BIOS
, bios_name
);
1025 bios_size
= load_elf(filename
, NULL
, NULL
, &bios_entry
, &loadaddr
, NULL
,
1027 if (bios_size
< 0) {
1029 * Hrm. No ELF image? Try a uImage, maybe someone is giving us an
1030 * ePAPR compliant kernel
1032 kernel_size
= load_uimage(filename
, &bios_entry
, &loadaddr
, NULL
,
1034 if (kernel_size
< 0) {
1035 fprintf(stderr
, "qemu: could not load firmware '%s'\n", filename
);
1040 /* Reserve space for dtb */
1041 dt_base
= (loadaddr
+ bios_size
+ DTC_LOAD_PAD
) & ~DTC_PAD_MASK
;
1043 dt_size
= ppce500_prep_device_tree(machine
, params
, dt_base
,
1044 initrd_base
, initrd_size
,
1045 kernel_base
, kernel_size
);
1047 fprintf(stderr
, "couldn't load device tree\n");
1050 assert(dt_size
< DTB_MAX_SIZE
);
1052 boot_info
= env
->load_info
;
1053 boot_info
->entry
= bios_entry
;
1054 boot_info
->dt_base
= dt_base
;
1055 boot_info
->dt_size
= dt_size
;
1057 if (kvm_enabled()) {
1062 static int e500_ccsr_initfn(SysBusDevice
*dev
)
1064 PPCE500CCSRState
*ccsr
;
1067 memory_region_init(&ccsr
->ccsr_space
, OBJECT(ccsr
), "e500-ccsr",
1068 MPC8544_CCSRBAR_SIZE
);
1072 static void e500_ccsr_class_init(ObjectClass
*klass
, void *data
)
1074 SysBusDeviceClass
*k
= SYS_BUS_DEVICE_CLASS(klass
);
1075 k
->init
= e500_ccsr_initfn
;
1078 static const TypeInfo e500_ccsr_info
= {
1080 .parent
= TYPE_SYS_BUS_DEVICE
,
1081 .instance_size
= sizeof(PPCE500CCSRState
),
1082 .class_init
= e500_ccsr_class_init
,
1085 static void e500_register_types(void)
1087 type_register_static(&e500_ccsr_info
);
1090 type_init(e500_register_types
)