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/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/openpic.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/ppce500_pci.h"
40 #define BINARY_DEVICE_TREE_FILE "mpc8544ds.dtb"
41 #define UIMAGE_LOAD_BASE 0
42 #define DTC_LOAD_PAD 0x1800000
43 #define DTC_PAD_MASK 0xFFFFF
44 #define INITRD_LOAD_PAD 0x2000000
45 #define INITRD_PAD_MASK 0xFFFFFF
47 #define RAM_SIZES_ALIGN (64UL << 20)
49 /* TODO: parameterize */
50 #define MPC8544_CCSRBAR_BASE 0xE0000000ULL
51 #define MPC8544_CCSRBAR_SIZE 0x00100000ULL
52 #define MPC8544_MPIC_REGS_OFFSET 0x40000ULL
53 #define MPC8544_MSI_REGS_OFFSET 0x41600ULL
54 #define MPC8544_SERIAL0_REGS_OFFSET 0x4500ULL
55 #define MPC8544_SERIAL1_REGS_OFFSET 0x4600ULL
56 #define MPC8544_PCI_REGS_OFFSET 0x8000ULL
57 #define MPC8544_PCI_REGS_BASE (MPC8544_CCSRBAR_BASE + \
58 MPC8544_PCI_REGS_OFFSET)
59 #define MPC8544_PCI_REGS_SIZE 0x1000ULL
60 #define MPC8544_PCI_IO 0xE1000000ULL
61 #define MPC8544_UTIL_OFFSET 0xe0000ULL
62 #define MPC8544_SPIN_BASE 0xEF000000ULL
71 static uint32_t *pci_map_create(void *fdt
, uint32_t mpic
, int first_slot
,
72 int nr_slots
, int *len
)
78 int last_slot
= first_slot
+ nr_slots
;
81 *len
= nr_slots
* 4 * 7 * sizeof(uint32_t);
82 pci_map
= g_malloc(*len
);
84 for (slot
= first_slot
; slot
< last_slot
; slot
++) {
85 for (pci_irq
= 0; pci_irq
< 4; pci_irq
++) {
86 pci_map
[i
++] = cpu_to_be32(slot
<< 11);
87 pci_map
[i
++] = cpu_to_be32(0x0);
88 pci_map
[i
++] = cpu_to_be32(0x0);
89 pci_map
[i
++] = cpu_to_be32(pci_irq
+ 1);
90 pci_map
[i
++] = cpu_to_be32(mpic
);
91 host_irq
= ppce500_pci_map_irq_slot(slot
, pci_irq
);
92 pci_map
[i
++] = cpu_to_be32(host_irq
+ 1);
93 pci_map
[i
++] = cpu_to_be32(0x1);
97 assert((i
* sizeof(uint32_t)) == *len
);
102 static void dt_serial_create(void *fdt
, unsigned long long offset
,
103 const char *soc
, const char *mpic
,
104 const char *alias
, int idx
, bool defcon
)
108 snprintf(ser
, sizeof(ser
), "%s/serial@%llx", soc
, offset
);
109 qemu_devtree_add_subnode(fdt
, ser
);
110 qemu_devtree_setprop_string(fdt
, ser
, "device_type", "serial");
111 qemu_devtree_setprop_string(fdt
, ser
, "compatible", "ns16550");
112 qemu_devtree_setprop_cells(fdt
, ser
, "reg", offset
, 0x100);
113 qemu_devtree_setprop_cell(fdt
, ser
, "cell-index", idx
);
114 qemu_devtree_setprop_cell(fdt
, ser
, "clock-frequency", 0);
115 qemu_devtree_setprop_cells(fdt
, ser
, "interrupts", 42, 2);
116 qemu_devtree_setprop_phandle(fdt
, ser
, "interrupt-parent", mpic
);
117 qemu_devtree_setprop_string(fdt
, "/aliases", alias
, ser
);
120 qemu_devtree_setprop_string(fdt
, "/chosen", "linux,stdout-path", ser
);
124 static int ppce500_load_device_tree(CPUPPCState
*env
,
125 PPCE500Params
*params
,
131 uint64_t mem_reg_property
[] = { 0, cpu_to_be64(params
->ram_size
) };
134 uint8_t hypercall
[16];
135 uint32_t clock_freq
= 400000000;
136 uint32_t tb_freq
= 400000000;
138 const char *toplevel_compat
= NULL
; /* user override */
139 char compatible_sb
[] = "fsl,mpc8544-immr\0simple-bus";
147 uint32_t *pci_map
= NULL
;
149 uint32_t pci_ranges
[14] =
151 0x2000000, 0x0, 0xc0000000,
159 QemuOpts
*machine_opts
;
160 const char *dtb_file
= NULL
;
162 machine_opts
= qemu_opts_find(qemu_find_opts("machine"), 0);
164 dtb_file
= qemu_opt_get(machine_opts
, "dtb");
165 toplevel_compat
= qemu_opt_get(machine_opts
, "dt_compatible");
170 filename
= qemu_find_file(QEMU_FILE_TYPE_BIOS
, dtb_file
);
175 fdt
= load_device_tree(filename
, &fdt_size
);
182 fdt
= create_device_tree(&fdt_size
);
187 /* Manipulate device tree in memory. */
188 qemu_devtree_setprop_cell(fdt
, "/", "#address-cells", 2);
189 qemu_devtree_setprop_cell(fdt
, "/", "#size-cells", 2);
191 qemu_devtree_add_subnode(fdt
, "/memory");
192 qemu_devtree_setprop_string(fdt
, "/memory", "device_type", "memory");
193 qemu_devtree_setprop(fdt
, "/memory", "reg", mem_reg_property
,
194 sizeof(mem_reg_property
));
196 qemu_devtree_add_subnode(fdt
, "/chosen");
198 ret
= qemu_devtree_setprop_cell(fdt
, "/chosen", "linux,initrd-start",
201 fprintf(stderr
, "couldn't set /chosen/linux,initrd-start\n");
204 ret
= qemu_devtree_setprop_cell(fdt
, "/chosen", "linux,initrd-end",
205 (initrd_base
+ initrd_size
));
207 fprintf(stderr
, "couldn't set /chosen/linux,initrd-end\n");
211 ret
= qemu_devtree_setprop_string(fdt
, "/chosen", "bootargs",
212 params
->kernel_cmdline
);
214 fprintf(stderr
, "couldn't set /chosen/bootargs\n");
217 /* Read out host's frequencies */
218 clock_freq
= kvmppc_get_clockfreq();
219 tb_freq
= kvmppc_get_tbfreq();
221 /* indicate KVM hypercall interface */
222 qemu_devtree_add_subnode(fdt
, "/hypervisor");
223 qemu_devtree_setprop_string(fdt
, "/hypervisor", "compatible",
225 kvmppc_get_hypercall(env
, hypercall
, sizeof(hypercall
));
226 qemu_devtree_setprop(fdt
, "/hypervisor", "hcall-instructions",
227 hypercall
, sizeof(hypercall
));
228 /* if KVM supports the idle hcall, set property indicating this */
229 if (kvmppc_get_hasidle(env
)) {
230 qemu_devtree_setprop(fdt
, "/hypervisor", "has-idle", NULL
, 0);
234 /* Create CPU nodes */
235 qemu_devtree_add_subnode(fdt
, "/cpus");
236 qemu_devtree_setprop_cell(fdt
, "/cpus", "#address-cells", 1);
237 qemu_devtree_setprop_cell(fdt
, "/cpus", "#size-cells", 0);
239 /* We need to generate the cpu nodes in reverse order, so Linux can pick
240 the first node as boot node and be happy */
241 for (i
= smp_cpus
- 1; i
>= 0; i
--) {
242 CPUState
*cpu
= NULL
;
244 uint64_t cpu_release_addr
= MPC8544_SPIN_BASE
+ (i
* 0x20);
246 for (env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
247 cpu
= ENV_GET_CPU(env
);
248 if (cpu
->cpu_index
== i
) {
257 snprintf(cpu_name
, sizeof(cpu_name
), "/cpus/PowerPC,8544@%x",
259 qemu_devtree_add_subnode(fdt
, cpu_name
);
260 qemu_devtree_setprop_cell(fdt
, cpu_name
, "clock-frequency", clock_freq
);
261 qemu_devtree_setprop_cell(fdt
, cpu_name
, "timebase-frequency", tb_freq
);
262 qemu_devtree_setprop_string(fdt
, cpu_name
, "device_type", "cpu");
263 qemu_devtree_setprop_cell(fdt
, cpu_name
, "reg", cpu
->cpu_index
);
264 qemu_devtree_setprop_cell(fdt
, cpu_name
, "d-cache-line-size",
265 env
->dcache_line_size
);
266 qemu_devtree_setprop_cell(fdt
, cpu_name
, "i-cache-line-size",
267 env
->icache_line_size
);
268 qemu_devtree_setprop_cell(fdt
, cpu_name
, "d-cache-size", 0x8000);
269 qemu_devtree_setprop_cell(fdt
, cpu_name
, "i-cache-size", 0x8000);
270 qemu_devtree_setprop_cell(fdt
, cpu_name
, "bus-frequency", 0);
271 if (cpu
->cpu_index
) {
272 qemu_devtree_setprop_string(fdt
, cpu_name
, "status", "disabled");
273 qemu_devtree_setprop_string(fdt
, cpu_name
, "enable-method", "spin-table");
274 qemu_devtree_setprop_u64(fdt
, cpu_name
, "cpu-release-addr",
277 qemu_devtree_setprop_string(fdt
, cpu_name
, "status", "okay");
281 qemu_devtree_add_subnode(fdt
, "/aliases");
282 /* XXX These should go into their respective devices' code */
283 snprintf(soc
, sizeof(soc
), "/soc@%llx", MPC8544_CCSRBAR_BASE
);
284 qemu_devtree_add_subnode(fdt
, soc
);
285 qemu_devtree_setprop_string(fdt
, soc
, "device_type", "soc");
286 qemu_devtree_setprop(fdt
, soc
, "compatible", compatible_sb
,
287 sizeof(compatible_sb
));
288 qemu_devtree_setprop_cell(fdt
, soc
, "#address-cells", 1);
289 qemu_devtree_setprop_cell(fdt
, soc
, "#size-cells", 1);
290 qemu_devtree_setprop_cells(fdt
, soc
, "ranges", 0x0,
291 MPC8544_CCSRBAR_BASE
>> 32, MPC8544_CCSRBAR_BASE
,
292 MPC8544_CCSRBAR_SIZE
);
293 /* XXX should contain a reasonable value */
294 qemu_devtree_setprop_cell(fdt
, soc
, "bus-frequency", 0);
296 snprintf(mpic
, sizeof(mpic
), "%s/pic@%llx", soc
, MPC8544_MPIC_REGS_OFFSET
);
297 qemu_devtree_add_subnode(fdt
, mpic
);
298 qemu_devtree_setprop_string(fdt
, mpic
, "device_type", "open-pic");
299 qemu_devtree_setprop_string(fdt
, mpic
, "compatible", "chrp,open-pic");
300 qemu_devtree_setprop_cells(fdt
, mpic
, "reg", MPC8544_MPIC_REGS_OFFSET
,
302 qemu_devtree_setprop_cell(fdt
, mpic
, "#address-cells", 0);
303 qemu_devtree_setprop_cell(fdt
, mpic
, "#interrupt-cells", 2);
304 mpic_ph
= qemu_devtree_alloc_phandle(fdt
);
305 qemu_devtree_setprop_cell(fdt
, mpic
, "phandle", mpic_ph
);
306 qemu_devtree_setprop_cell(fdt
, mpic
, "linux,phandle", mpic_ph
);
307 qemu_devtree_setprop(fdt
, mpic
, "interrupt-controller", NULL
, 0);
310 * We have to generate ser1 first, because Linux takes the first
311 * device it finds in the dt as serial output device. And we generate
312 * devices in reverse order to the dt.
314 dt_serial_create(fdt
, MPC8544_SERIAL1_REGS_OFFSET
,
315 soc
, mpic
, "serial1", 1, false);
316 dt_serial_create(fdt
, MPC8544_SERIAL0_REGS_OFFSET
,
317 soc
, mpic
, "serial0", 0, true);
319 snprintf(gutil
, sizeof(gutil
), "%s/global-utilities@%llx", soc
,
320 MPC8544_UTIL_OFFSET
);
321 qemu_devtree_add_subnode(fdt
, gutil
);
322 qemu_devtree_setprop_string(fdt
, gutil
, "compatible", "fsl,mpc8544-guts");
323 qemu_devtree_setprop_cells(fdt
, gutil
, "reg", MPC8544_UTIL_OFFSET
, 0x1000);
324 qemu_devtree_setprop(fdt
, gutil
, "fsl,has-rstcr", NULL
, 0);
326 snprintf(msi
, sizeof(msi
), "/%s/msi@%llx", soc
, MPC8544_MSI_REGS_OFFSET
);
327 qemu_devtree_add_subnode(fdt
, msi
);
328 qemu_devtree_setprop_string(fdt
, msi
, "compatible", "fsl,mpic-msi");
329 qemu_devtree_setprop_cells(fdt
, msi
, "reg", MPC8544_MSI_REGS_OFFSET
, 0x200);
330 msi_ph
= qemu_devtree_alloc_phandle(fdt
);
331 qemu_devtree_setprop_cells(fdt
, msi
, "msi-available-ranges", 0x0, 0x100);
332 qemu_devtree_setprop_phandle(fdt
, msi
, "interrupt-parent", mpic
);
333 qemu_devtree_setprop_cells(fdt
, msi
, "interrupts",
342 qemu_devtree_setprop_cell(fdt
, msi
, "phandle", msi_ph
);
343 qemu_devtree_setprop_cell(fdt
, msi
, "linux,phandle", msi_ph
);
345 snprintf(pci
, sizeof(pci
), "/pci@%llx", MPC8544_PCI_REGS_BASE
);
346 qemu_devtree_add_subnode(fdt
, pci
);
347 qemu_devtree_setprop_cell(fdt
, pci
, "cell-index", 0);
348 qemu_devtree_setprop_string(fdt
, pci
, "compatible", "fsl,mpc8540-pci");
349 qemu_devtree_setprop_string(fdt
, pci
, "device_type", "pci");
350 qemu_devtree_setprop_cells(fdt
, pci
, "interrupt-map-mask", 0xf800, 0x0,
352 pci_map
= pci_map_create(fdt
, qemu_devtree_get_phandle(fdt
, mpic
),
353 params
->pci_first_slot
, params
->pci_nr_slots
,
355 qemu_devtree_setprop(fdt
, pci
, "interrupt-map", pci_map
, len
);
356 qemu_devtree_setprop_phandle(fdt
, pci
, "interrupt-parent", mpic
);
357 qemu_devtree_setprop_cells(fdt
, pci
, "interrupts", 24, 2);
358 qemu_devtree_setprop_cells(fdt
, pci
, "bus-range", 0, 255);
359 for (i
= 0; i
< 14; i
++) {
360 pci_ranges
[i
] = cpu_to_be32(pci_ranges
[i
]);
362 qemu_devtree_setprop_cell(fdt
, pci
, "fsl,msi", msi_ph
);
363 qemu_devtree_setprop(fdt
, pci
, "ranges", pci_ranges
, sizeof(pci_ranges
));
364 qemu_devtree_setprop_cells(fdt
, pci
, "reg", MPC8544_PCI_REGS_BASE
>> 32,
365 MPC8544_PCI_REGS_BASE
, 0, 0x1000);
366 qemu_devtree_setprop_cell(fdt
, pci
, "clock-frequency", 66666666);
367 qemu_devtree_setprop_cell(fdt
, pci
, "#interrupt-cells", 1);
368 qemu_devtree_setprop_cell(fdt
, pci
, "#size-cells", 2);
369 qemu_devtree_setprop_cell(fdt
, pci
, "#address-cells", 3);
370 qemu_devtree_setprop_string(fdt
, "/aliases", "pci0", pci
);
372 params
->fixup_devtree(params
, fdt
);
374 if (toplevel_compat
) {
375 qemu_devtree_setprop(fdt
, "/", "compatible", toplevel_compat
,
376 strlen(toplevel_compat
) + 1);
380 qemu_devtree_dumpdtb(fdt
, fdt_size
);
381 ret
= rom_add_blob_fixed(BINARY_DEVICE_TREE_FILE
, fdt
, fdt_size
, addr
);
394 /* Create -kernel TLB entries for BookE. */
395 static inline hwaddr
booke206_page_size_to_tlb(uint64_t size
)
397 return 63 - clz64(size
>> 10);
400 static void mmubooke_create_initial_mapping(CPUPPCState
*env
)
402 struct boot_info
*bi
= env
->load_info
;
403 ppcmas_tlb_t
*tlb
= booke206_get_tlbm(env
, 1, 0, 0);
407 /* Our initial TLB entry needs to cover everything from 0 to
408 the device tree top */
409 dt_end
= bi
->dt_base
+ bi
->dt_size
;
410 ps
= booke206_page_size_to_tlb(dt_end
) + 1;
412 /* e500v2 can only do even TLB size bits */
415 size
= (ps
<< MAS1_TSIZE_SHIFT
);
416 tlb
->mas1
= MAS1_VALID
| size
;
419 tlb
->mas7_3
|= MAS3_UR
| MAS3_UW
| MAS3_UX
| MAS3_SR
| MAS3_SW
| MAS3_SX
;
421 env
->tlb_dirty
= true;
424 static void ppce500_cpu_reset_sec(void *opaque
)
426 PowerPCCPU
*cpu
= opaque
;
427 CPUPPCState
*env
= &cpu
->env
;
431 /* Secondary CPU starts in halted state for now. Needs to change when
432 implementing non-kernel boot. */
434 env
->exception_index
= EXCP_HLT
;
437 static void ppce500_cpu_reset(void *opaque
)
439 PowerPCCPU
*cpu
= opaque
;
440 CPUPPCState
*env
= &cpu
->env
;
441 struct boot_info
*bi
= env
->load_info
;
445 /* Set initial guest state. */
447 env
->gpr
[1] = (16<<20) - 8;
448 env
->gpr
[3] = bi
->dt_base
;
449 env
->nip
= bi
->entry
;
450 mmubooke_create_initial_mapping(env
);
453 void ppce500_init(PPCE500Params
*params
)
455 MemoryRegion
*address_space_mem
= get_system_memory();
456 MemoryRegion
*ram
= g_new(MemoryRegion
, 1);
458 CPUPPCState
*env
= NULL
;
460 uint64_t elf_lowaddr
;
462 hwaddr loadaddr
=UIMAGE_LOAD_BASE
;
463 target_long kernel_size
=0;
464 target_ulong dt_base
= 0;
465 target_ulong initrd_base
= 0;
466 target_long initrd_size
=0;
468 unsigned int pci_irq_nrs
[4] = {1, 2, 3, 4};
469 qemu_irq
**irqs
, *mpic
;
471 CPUPPCState
*firstenv
= NULL
;
472 MemoryRegion
*ccsr_addr_space
;
474 PPCE500CCSRState
*ccsr
;
477 if (params
->cpu_model
== NULL
) {
478 params
->cpu_model
= "e500v2_v30";
481 irqs
= g_malloc0(smp_cpus
* sizeof(qemu_irq
*));
482 irqs
[0] = g_malloc0(smp_cpus
* sizeof(qemu_irq
) * OPENPIC_OUTPUT_NB
);
483 for (i
= 0; i
< smp_cpus
; i
++) {
488 cpu
= cpu_ppc_init(params
->cpu_model
);
490 fprintf(stderr
, "Unable to initialize CPU!\n");
500 irqs
[i
] = irqs
[0] + (i
* OPENPIC_OUTPUT_NB
);
501 input
= (qemu_irq
*)env
->irq_inputs
;
502 irqs
[i
][OPENPIC_OUTPUT_INT
] = input
[PPCE500_INPUT_INT
];
503 irqs
[i
][OPENPIC_OUTPUT_CINT
] = input
[PPCE500_INPUT_CINT
];
504 env
->spr
[SPR_BOOKE_PIR
] = cs
->cpu_index
= i
;
505 env
->mpic_iack
= MPC8544_CCSRBAR_BASE
+
506 MPC8544_MPIC_REGS_OFFSET
+ 0x200A0;
508 ppc_booke_timers_init(cpu
, 400000000, PPC_TIMER_E500
);
510 /* Register reset handler */
513 struct boot_info
*boot_info
;
514 boot_info
= g_malloc0(sizeof(struct boot_info
));
515 qemu_register_reset(ppce500_cpu_reset
, cpu
);
516 env
->load_info
= boot_info
;
519 qemu_register_reset(ppce500_cpu_reset_sec
, cpu
);
525 /* Fixup Memory size on a alignment boundary */
526 ram_size
&= ~(RAM_SIZES_ALIGN
- 1);
528 /* Register Memory */
529 memory_region_init_ram(ram
, "mpc8544ds.ram", ram_size
);
530 vmstate_register_ram_global(ram
);
531 memory_region_add_subregion(address_space_mem
, 0, ram
);
533 dev
= qdev_create(NULL
, "e500-ccsr");
534 object_property_add_child(qdev_get_machine(), "e500-ccsr",
536 qdev_init_nofail(dev
);
538 ccsr_addr_space
= &ccsr
->ccsr_space
;
539 memory_region_add_subregion(address_space_mem
, MPC8544_CCSRBAR_BASE
,
543 mpic
= g_new(qemu_irq
, 256);
544 dev
= qdev_create(NULL
, "openpic");
545 qdev_prop_set_uint32(dev
, "nb_cpus", smp_cpus
);
546 qdev_prop_set_uint32(dev
, "model", OPENPIC_MODEL_FSL_MPIC_20
);
547 qdev_init_nofail(dev
);
548 s
= sysbus_from_qdev(dev
);
551 for (i
= 0; i
< smp_cpus
; i
++) {
552 for (j
= 0; j
< OPENPIC_OUTPUT_NB
; j
++) {
553 sysbus_connect_irq(s
, k
++, irqs
[i
][j
]);
557 for (i
= 0; i
< 256; i
++) {
558 mpic
[i
] = qdev_get_gpio_in(dev
, i
);
561 memory_region_add_subregion(ccsr_addr_space
, MPC8544_MPIC_REGS_OFFSET
,
566 serial_mm_init(ccsr_addr_space
, MPC8544_SERIAL0_REGS_OFFSET
,
568 serial_hds
[0], DEVICE_BIG_ENDIAN
);
572 serial_mm_init(ccsr_addr_space
, MPC8544_SERIAL1_REGS_OFFSET
,
574 serial_hds
[1], DEVICE_BIG_ENDIAN
);
577 /* General Utility device */
578 dev
= qdev_create(NULL
, "mpc8544-guts");
579 qdev_init_nofail(dev
);
580 s
= SYS_BUS_DEVICE(dev
);
581 memory_region_add_subregion(ccsr_addr_space
, MPC8544_UTIL_OFFSET
,
582 sysbus_mmio_get_region(s
, 0));
585 dev
= qdev_create(NULL
, "e500-pcihost");
586 qdev_prop_set_uint32(dev
, "first_slot", params
->pci_first_slot
);
587 qdev_init_nofail(dev
);
588 s
= SYS_BUS_DEVICE(dev
);
589 sysbus_connect_irq(s
, 0, mpic
[pci_irq_nrs
[0]]);
590 sysbus_connect_irq(s
, 1, mpic
[pci_irq_nrs
[1]]);
591 sysbus_connect_irq(s
, 2, mpic
[pci_irq_nrs
[2]]);
592 sysbus_connect_irq(s
, 3, mpic
[pci_irq_nrs
[3]]);
593 memory_region_add_subregion(ccsr_addr_space
, MPC8544_PCI_REGS_OFFSET
,
594 sysbus_mmio_get_region(s
, 0));
596 pci_bus
= (PCIBus
*)qdev_get_child_bus(dev
, "pci.0");
598 printf("couldn't create PCI controller!\n");
600 sysbus_mmio_map(sysbus_from_qdev(dev
), 1, MPC8544_PCI_IO
);
603 /* Register network interfaces. */
604 for (i
= 0; i
< nb_nics
; i
++) {
605 pci_nic_init_nofail(&nd_table
[i
], "virtio", NULL
);
609 /* Register spinning region */
610 sysbus_create_simple("e500-spin", MPC8544_SPIN_BASE
, NULL
);
613 if (params
->kernel_filename
) {
614 kernel_size
= load_uimage(params
->kernel_filename
, &entry
,
616 if (kernel_size
< 0) {
617 kernel_size
= load_elf(params
->kernel_filename
, NULL
, NULL
,
618 &elf_entry
, &elf_lowaddr
, NULL
, 1,
621 loadaddr
= elf_lowaddr
;
623 /* XXX try again as binary */
624 if (kernel_size
< 0) {
625 fprintf(stderr
, "qemu: could not load kernel '%s'\n",
626 params
->kernel_filename
);
632 if (params
->initrd_filename
) {
633 initrd_base
= (loadaddr
+ kernel_size
+ INITRD_LOAD_PAD
) &
635 initrd_size
= load_image_targphys(params
->initrd_filename
, initrd_base
,
636 ram_size
- initrd_base
);
638 if (initrd_size
< 0) {
639 fprintf(stderr
, "qemu: could not load initial ram disk '%s'\n",
640 params
->initrd_filename
);
645 /* If we're loading a kernel directly, we must load the device tree too. */
646 if (params
->kernel_filename
) {
647 struct boot_info
*boot_info
;
650 dt_base
= (loadaddr
+ kernel_size
+ DTC_LOAD_PAD
) & ~DTC_PAD_MASK
;
651 dt_size
= ppce500_load_device_tree(env
, params
, dt_base
, initrd_base
,
654 fprintf(stderr
, "couldn't load device tree\n");
658 boot_info
= env
->load_info
;
659 boot_info
->entry
= entry
;
660 boot_info
->dt_base
= dt_base
;
661 boot_info
->dt_size
= dt_size
;
669 static int e500_ccsr_initfn(SysBusDevice
*dev
)
671 PPCE500CCSRState
*ccsr
;
674 memory_region_init(&ccsr
->ccsr_space
, "e500-ccsr",
675 MPC8544_CCSRBAR_SIZE
);
679 static void e500_ccsr_class_init(ObjectClass
*klass
, void *data
)
681 SysBusDeviceClass
*k
= SYS_BUS_DEVICE_CLASS(klass
);
682 k
->init
= e500_ccsr_initfn
;
685 static const TypeInfo e500_ccsr_info
= {
687 .parent
= TYPE_SYS_BUS_DEVICE
,
688 .instance_size
= sizeof(PPCE500CCSRState
),
689 .class_init
= e500_ccsr_class_init
,
692 static void e500_register_types(void)
694 type_register_static(&e500_ccsr_info
);
697 type_init(e500_register_types
)