2 * QEMU PowerPC MPC8544DS board emulation
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"
27 #include "device_tree.h"
33 #include "exec-memory.h"
34 #include "host-utils.h"
36 #define BINARY_DEVICE_TREE_FILE "mpc8544ds.dtb"
37 #define UIMAGE_LOAD_BASE 0
38 #define DTC_LOAD_PAD 0x500000
39 #define DTC_PAD_MASK 0xFFFFF
40 #define INITRD_LOAD_PAD 0x2000000
41 #define INITRD_PAD_MASK 0xFFFFFF
43 #define RAM_SIZES_ALIGN (64UL << 20)
45 #define MPC8544_CCSRBAR_BASE 0xE0000000ULL
46 #define MPC8544_CCSRBAR_SIZE 0x00100000ULL
47 #define MPC8544_MPIC_REGS_BASE (MPC8544_CCSRBAR_BASE + 0x40000ULL)
48 #define MPC8544_SERIAL0_REGS_BASE (MPC8544_CCSRBAR_BASE + 0x4500ULL)
49 #define MPC8544_SERIAL1_REGS_BASE (MPC8544_CCSRBAR_BASE + 0x4600ULL)
50 #define MPC8544_PCI_REGS_BASE (MPC8544_CCSRBAR_BASE + 0x8000ULL)
51 #define MPC8544_PCI_REGS_SIZE 0x1000ULL
52 #define MPC8544_PCI_IO 0xE1000000ULL
53 #define MPC8544_PCI_IOLEN 0x10000ULL
54 #define MPC8544_UTIL_BASE (MPC8544_CCSRBAR_BASE + 0xe0000ULL)
55 #define MPC8544_SPIN_BASE 0xEF000000ULL
64 static void pci_map_create(void *fdt
, uint32_t *pci_map
, uint32_t mpic
)
67 const uint32_t tmp
[] = {
68 /* IDSEL 0x11 J17 Slot 1 */
69 0x8800, 0x0, 0x0, 0x1, mpic
, 0x2, 0x1, 0x0, 0x0,
70 0x8800, 0x0, 0x0, 0x2, mpic
, 0x3, 0x1, 0x0, 0x0,
71 0x8800, 0x0, 0x0, 0x3, mpic
, 0x4, 0x1, 0x0, 0x0,
72 0x8800, 0x0, 0x0, 0x4, mpic
, 0x1, 0x1, 0x0, 0x0,
74 /* IDSEL 0x12 J16 Slot 2 */
75 0x9000, 0x0, 0x0, 0x1, mpic
, 0x3, 0x1, 0x0, 0x0,
76 0x9000, 0x0, 0x0, 0x2, mpic
, 0x4, 0x1, 0x0, 0x0,
77 0x9000, 0x0, 0x0, 0x3, mpic
, 0x2, 0x1, 0x0, 0x0,
78 0x9000, 0x0, 0x0, 0x4, mpic
, 0x1, 0x1, 0x0, 0x0,
80 for (i
= 0; i
< ARRAY_SIZE(tmp
); i
++) {
81 pci_map
[i
] = cpu_to_be32(tmp
[i
]);
85 static int mpc8544_load_device_tree(CPUPPCState
*env
,
86 target_phys_addr_t addr
,
87 target_phys_addr_t ramsize
,
88 target_phys_addr_t initrd_base
,
89 target_phys_addr_t initrd_size
,
90 const char *kernel_cmdline
)
93 uint64_t mem_reg_property
[] = { 0, cpu_to_be64(ramsize
) };
96 uint8_t hypercall
[16];
97 uint32_t clock_freq
= 400000000;
98 uint32_t tb_freq
= 400000000;
100 char compatible
[] = "MPC8544DS\0MPC85xxDS";
101 char compatible_sb
[] = "fsl,mpc8544-immr\0simple-bus";
102 char model
[] = "MPC8544DS";
110 uint32_t pci_map
[9 * 8];
111 uint32_t pci_ranges
[14] =
113 0x2000000, 0x0, 0xc0000000,
121 QemuOpts
*machine_opts
;
122 const char *dumpdtb
= NULL
;
123 const char *dtb_file
= NULL
;
125 machine_opts
= qemu_opts_find(qemu_find_opts("machine"), 0);
127 dumpdtb
= qemu_opt_get(machine_opts
, "dumpdtb");
128 dtb_file
= qemu_opt_get(machine_opts
, "dtb");
133 filename
= qemu_find_file(QEMU_FILE_TYPE_BIOS
, dtb_file
);
138 fdt
= load_device_tree(filename
, &fdt_size
);
145 fdt
= create_device_tree(&fdt_size
);
150 /* Manipulate device tree in memory. */
151 qemu_devtree_setprop_string(fdt
, "/", "model", model
);
152 qemu_devtree_setprop(fdt
, "/", "compatible", compatible
,
154 qemu_devtree_setprop_cell(fdt
, "/", "#address-cells", 2);
155 qemu_devtree_setprop_cell(fdt
, "/", "#size-cells", 2);
157 qemu_devtree_add_subnode(fdt
, "/memory");
158 qemu_devtree_setprop_string(fdt
, "/memory", "device_type", "memory");
159 qemu_devtree_setprop(fdt
, "/memory", "reg", mem_reg_property
,
160 sizeof(mem_reg_property
));
162 qemu_devtree_add_subnode(fdt
, "/chosen");
164 ret
= qemu_devtree_setprop_cell(fdt
, "/chosen", "linux,initrd-start",
167 fprintf(stderr
, "couldn't set /chosen/linux,initrd-start\n");
170 ret
= qemu_devtree_setprop_cell(fdt
, "/chosen", "linux,initrd-end",
171 (initrd_base
+ initrd_size
));
173 fprintf(stderr
, "couldn't set /chosen/linux,initrd-end\n");
177 ret
= qemu_devtree_setprop_string(fdt
, "/chosen", "bootargs",
180 fprintf(stderr
, "couldn't set /chosen/bootargs\n");
183 /* Read out host's frequencies */
184 clock_freq
= kvmppc_get_clockfreq();
185 tb_freq
= kvmppc_get_tbfreq();
187 /* indicate KVM hypercall interface */
188 qemu_devtree_add_subnode(fdt
, "/hypervisor");
189 qemu_devtree_setprop_string(fdt
, "/hypervisor", "compatible",
191 kvmppc_get_hypercall(env
, hypercall
, sizeof(hypercall
));
192 qemu_devtree_setprop(fdt
, "/hypervisor", "hcall-instructions",
193 hypercall
, sizeof(hypercall
));
196 /* Create CPU nodes */
197 qemu_devtree_add_subnode(fdt
, "/cpus");
198 qemu_devtree_setprop_cell(fdt
, "/cpus", "#address-cells", 1);
199 qemu_devtree_setprop_cell(fdt
, "/cpus", "#size-cells", 0);
201 /* We need to generate the cpu nodes in reverse order, so Linux can pick
202 the first node as boot node and be happy */
203 for (i
= smp_cpus
- 1; i
>= 0; i
--) {
205 uint64_t cpu_release_addr
= MPC8544_SPIN_BASE
+ (i
* 0x20);
207 for (env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
208 if (env
->cpu_index
== i
) {
217 snprintf(cpu_name
, sizeof(cpu_name
), "/cpus/PowerPC,8544@%x", env
->cpu_index
);
218 qemu_devtree_add_subnode(fdt
, cpu_name
);
219 qemu_devtree_setprop_cell(fdt
, cpu_name
, "clock-frequency", clock_freq
);
220 qemu_devtree_setprop_cell(fdt
, cpu_name
, "timebase-frequency", tb_freq
);
221 qemu_devtree_setprop_string(fdt
, cpu_name
, "device_type", "cpu");
222 qemu_devtree_setprop_cell(fdt
, cpu_name
, "reg", env
->cpu_index
);
223 qemu_devtree_setprop_cell(fdt
, cpu_name
, "d-cache-line-size",
224 env
->dcache_line_size
);
225 qemu_devtree_setprop_cell(fdt
, cpu_name
, "i-cache-line-size",
226 env
->icache_line_size
);
227 qemu_devtree_setprop_cell(fdt
, cpu_name
, "d-cache-size", 0x8000);
228 qemu_devtree_setprop_cell(fdt
, cpu_name
, "i-cache-size", 0x8000);
229 qemu_devtree_setprop_cell(fdt
, cpu_name
, "bus-frequency", 0);
230 if (env
->cpu_index
) {
231 qemu_devtree_setprop_string(fdt
, cpu_name
, "status", "disabled");
232 qemu_devtree_setprop_string(fdt
, cpu_name
, "enable-method", "spin-table");
233 qemu_devtree_setprop_u64(fdt
, cpu_name
, "cpu-release-addr",
236 qemu_devtree_setprop_string(fdt
, cpu_name
, "status", "okay");
240 qemu_devtree_add_subnode(fdt
, "/aliases");
241 /* XXX These should go into their respective devices' code */
242 snprintf(soc
, sizeof(soc
), "/soc@%llx", MPC8544_CCSRBAR_BASE
);
243 qemu_devtree_add_subnode(fdt
, soc
);
244 qemu_devtree_setprop_string(fdt
, soc
, "device_type", "soc");
245 qemu_devtree_setprop(fdt
, soc
, "compatible", compatible_sb
,
246 sizeof(compatible_sb
));
247 qemu_devtree_setprop_cell(fdt
, soc
, "#address-cells", 1);
248 qemu_devtree_setprop_cell(fdt
, soc
, "#size-cells", 1);
249 qemu_devtree_setprop_cells(fdt
, soc
, "ranges", 0x0,
250 MPC8544_CCSRBAR_BASE
>> 32, MPC8544_CCSRBAR_BASE
,
251 MPC8544_CCSRBAR_SIZE
);
252 /* XXX should contain a reasonable value */
253 qemu_devtree_setprop_cell(fdt
, soc
, "bus-frequency", 0);
255 snprintf(mpic
, sizeof(mpic
), "%s/pic@%llx", soc
,
256 MPC8544_MPIC_REGS_BASE
- MPC8544_CCSRBAR_BASE
);
257 qemu_devtree_add_subnode(fdt
, mpic
);
258 qemu_devtree_setprop_string(fdt
, mpic
, "device_type", "open-pic");
259 qemu_devtree_setprop_string(fdt
, mpic
, "compatible", "fsl,mpic");
260 qemu_devtree_setprop_cells(fdt
, mpic
, "reg", MPC8544_MPIC_REGS_BASE
-
261 MPC8544_CCSRBAR_BASE
, 0x40000);
262 qemu_devtree_setprop_cell(fdt
, mpic
, "#address-cells", 0);
263 qemu_devtree_setprop_cell(fdt
, mpic
, "#interrupt-cells", 4);
264 mpic_ph
= qemu_devtree_alloc_phandle(fdt
);
265 qemu_devtree_setprop_cell(fdt
, mpic
, "phandle", mpic_ph
);
266 qemu_devtree_setprop_cell(fdt
, mpic
, "linux,phandle", mpic_ph
);
267 qemu_devtree_setprop(fdt
, mpic
, "interrupt-controller", NULL
, 0);
268 qemu_devtree_setprop(fdt
, mpic
, "big-endian", NULL
, 0);
269 qemu_devtree_setprop(fdt
, mpic
, "single-cpu-affinity", NULL
, 0);
270 qemu_devtree_setprop_cell(fdt
, mpic
, "last-interrupt-source", 255);
273 * We have to generate ser1 first, because Linux takes the first
274 * device it finds in the dt as serial output device. And we generate
275 * devices in reverse order to the dt.
277 snprintf(ser1
, sizeof(ser1
), "%s/serial@%llx", soc
,
278 MPC8544_SERIAL1_REGS_BASE
- MPC8544_CCSRBAR_BASE
);
279 qemu_devtree_add_subnode(fdt
, ser1
);
280 qemu_devtree_setprop_string(fdt
, ser1
, "device_type", "serial");
281 qemu_devtree_setprop_string(fdt
, ser1
, "compatible", "ns16550");
282 qemu_devtree_setprop_cells(fdt
, ser1
, "reg", MPC8544_SERIAL1_REGS_BASE
-
283 MPC8544_CCSRBAR_BASE
, 0x100);
284 qemu_devtree_setprop_cell(fdt
, ser1
, "cell-index", 1);
285 qemu_devtree_setprop_cell(fdt
, ser1
, "clock-frequency", 0);
286 qemu_devtree_setprop_cells(fdt
, ser1
, "interrupts", 42, 2, 0, 0);
287 qemu_devtree_setprop_phandle(fdt
, ser1
, "interrupt-parent", mpic
);
288 qemu_devtree_setprop_string(fdt
, "/aliases", "serial1", ser1
);
290 snprintf(ser0
, sizeof(ser0
), "%s/serial@%llx", soc
,
291 MPC8544_SERIAL0_REGS_BASE
- MPC8544_CCSRBAR_BASE
);
292 qemu_devtree_add_subnode(fdt
, ser0
);
293 qemu_devtree_setprop_string(fdt
, ser0
, "device_type", "serial");
294 qemu_devtree_setprop_string(fdt
, ser0
, "compatible", "ns16550");
295 qemu_devtree_setprop_cells(fdt
, ser0
, "reg", MPC8544_SERIAL0_REGS_BASE
-
296 MPC8544_CCSRBAR_BASE
, 0x100);
297 qemu_devtree_setprop_cell(fdt
, ser0
, "cell-index", 0);
298 qemu_devtree_setprop_cell(fdt
, ser0
, "clock-frequency", 0);
299 qemu_devtree_setprop_cells(fdt
, ser0
, "interrupts", 42, 2, 0, 0);
300 qemu_devtree_setprop_phandle(fdt
, ser0
, "interrupt-parent", mpic
);
301 qemu_devtree_setprop_string(fdt
, "/aliases", "serial0", ser0
);
302 qemu_devtree_setprop_string(fdt
, "/chosen", "linux,stdout-path", ser0
);
304 snprintf(gutil
, sizeof(gutil
), "%s/global-utilities@%llx", soc
,
305 MPC8544_UTIL_BASE
- MPC8544_CCSRBAR_BASE
);
306 qemu_devtree_add_subnode(fdt
, gutil
);
307 qemu_devtree_setprop_string(fdt
, gutil
, "compatible", "fsl,mpc8544-guts");
308 qemu_devtree_setprop_cells(fdt
, gutil
, "reg", MPC8544_UTIL_BASE
-
309 MPC8544_CCSRBAR_BASE
, 0x1000);
310 qemu_devtree_setprop(fdt
, gutil
, "fsl,has-rstcr", NULL
, 0);
312 snprintf(pci
, sizeof(pci
), "/pci@%llx", MPC8544_PCI_REGS_BASE
);
313 qemu_devtree_add_subnode(fdt
, pci
);
314 qemu_devtree_setprop_cell(fdt
, pci
, "cell-index", 0);
315 qemu_devtree_setprop_string(fdt
, pci
, "compatible", "fsl,mpc8540-pci");
316 qemu_devtree_setprop_string(fdt
, pci
, "device_type", "pci");
317 qemu_devtree_setprop_cells(fdt
, pci
, "interrupt-map-mask", 0xf800, 0x0,
319 pci_map_create(fdt
, pci_map
, qemu_devtree_get_phandle(fdt
, mpic
));
320 qemu_devtree_setprop(fdt
, pci
, "interrupt-map", pci_map
, sizeof(pci_map
));
321 qemu_devtree_setprop_phandle(fdt
, pci
, "interrupt-parent", mpic
);
322 qemu_devtree_setprop_cells(fdt
, pci
, "interrupts", 24, 2, 0, 0);
323 qemu_devtree_setprop_cells(fdt
, pci
, "bus-range", 0, 255);
324 for (i
= 0; i
< 14; i
++) {
325 pci_ranges
[i
] = cpu_to_be32(pci_ranges
[i
]);
327 qemu_devtree_setprop(fdt
, pci
, "ranges", pci_ranges
, sizeof(pci_ranges
));
328 qemu_devtree_setprop_cells(fdt
, pci
, "reg", MPC8544_PCI_REGS_BASE
>> 32,
329 MPC8544_PCI_REGS_BASE
, 0, 0x1000);
330 qemu_devtree_setprop_cell(fdt
, pci
, "clock-frequency", 66666666);
331 qemu_devtree_setprop_cell(fdt
, pci
, "#interrupt-cells", 1);
332 qemu_devtree_setprop_cell(fdt
, pci
, "#size-cells", 2);
333 qemu_devtree_setprop_cell(fdt
, pci
, "#address-cells", 3);
334 qemu_devtree_setprop_string(fdt
, "/aliases", "pci0", pci
);
338 /* Dump the dtb to a file and quit */
339 FILE *f
= fopen(dumpdtb
, "wb");
341 len
= fwrite(fdt
, fdt_size
, 1, f
);
343 if (len
!= fdt_size
) {
349 ret
= rom_add_blob_fixed(BINARY_DEVICE_TREE_FILE
, fdt
, fdt_size
, addr
);
361 /* Create -kernel TLB entries for BookE. */
362 static inline target_phys_addr_t
booke206_page_size_to_tlb(uint64_t size
)
364 return 63 - clz64(size
>> 10);
367 static void mmubooke_create_initial_mapping(CPUPPCState
*env
)
369 struct boot_info
*bi
= env
->load_info
;
370 ppcmas_tlb_t
*tlb
= booke206_get_tlbm(env
, 1, 0, 0);
371 target_phys_addr_t size
, dt_end
;
374 /* Our initial TLB entry needs to cover everything from 0 to
375 the device tree top */
376 dt_end
= bi
->dt_base
+ bi
->dt_size
;
377 ps
= booke206_page_size_to_tlb(dt_end
) + 1;
378 size
= (ps
<< MAS1_TSIZE_SHIFT
);
379 tlb
->mas1
= MAS1_VALID
| size
;
382 tlb
->mas7_3
|= MAS3_UR
| MAS3_UW
| MAS3_UX
| MAS3_SR
| MAS3_SW
| MAS3_SX
;
384 env
->tlb_dirty
= true;
387 static void mpc8544ds_cpu_reset_sec(void *opaque
)
389 PowerPCCPU
*cpu
= opaque
;
390 CPUPPCState
*env
= &cpu
->env
;
394 /* Secondary CPU starts in halted state for now. Needs to change when
395 implementing non-kernel boot. */
397 env
->exception_index
= EXCP_HLT
;
400 static void mpc8544ds_cpu_reset(void *opaque
)
402 PowerPCCPU
*cpu
= opaque
;
403 CPUPPCState
*env
= &cpu
->env
;
404 struct boot_info
*bi
= env
->load_info
;
408 /* Set initial guest state. */
410 env
->gpr
[1] = (16<<20) - 8;
411 env
->gpr
[3] = bi
->dt_base
;
412 env
->nip
= bi
->entry
;
413 mmubooke_create_initial_mapping(env
);
416 static void mpc8544ds_init(ram_addr_t ram_size
,
417 const char *boot_device
,
418 const char *kernel_filename
,
419 const char *kernel_cmdline
,
420 const char *initrd_filename
,
421 const char *cpu_model
)
423 MemoryRegion
*address_space_mem
= get_system_memory();
424 MemoryRegion
*ram
= g_new(MemoryRegion
, 1);
426 CPUPPCState
*env
= NULL
;
428 uint64_t elf_lowaddr
;
429 target_phys_addr_t entry
=0;
430 target_phys_addr_t loadaddr
=UIMAGE_LOAD_BASE
;
431 target_long kernel_size
=0;
432 target_ulong dt_base
= 0;
433 target_ulong initrd_base
= 0;
434 target_long initrd_size
=0;
436 unsigned int pci_irq_nrs
[4] = {1, 2, 3, 4};
437 qemu_irq
**irqs
, *mpic
;
439 CPUPPCState
*firstenv
= NULL
;
442 if (cpu_model
== NULL
) {
443 cpu_model
= "e500v2_v30";
446 irqs
= g_malloc0(smp_cpus
* sizeof(qemu_irq
*));
447 irqs
[0] = g_malloc0(smp_cpus
* sizeof(qemu_irq
) * OPENPIC_OUTPUT_NB
);
448 for (i
= 0; i
< smp_cpus
; i
++) {
452 cpu
= cpu_ppc_init(cpu_model
);
454 fprintf(stderr
, "Unable to initialize CPU!\n");
463 irqs
[i
] = irqs
[0] + (i
* OPENPIC_OUTPUT_NB
);
464 input
= (qemu_irq
*)env
->irq_inputs
;
465 irqs
[i
][OPENPIC_OUTPUT_INT
] = input
[PPCE500_INPUT_INT
];
466 irqs
[i
][OPENPIC_OUTPUT_CINT
] = input
[PPCE500_INPUT_CINT
];
467 env
->spr
[SPR_BOOKE_PIR
] = env
->cpu_index
= i
;
469 ppc_booke_timers_init(env
, 400000000, PPC_TIMER_E500
);
471 /* Register reset handler */
474 struct boot_info
*boot_info
;
475 boot_info
= g_malloc0(sizeof(struct boot_info
));
476 qemu_register_reset(mpc8544ds_cpu_reset
, cpu
);
477 env
->load_info
= boot_info
;
480 qemu_register_reset(mpc8544ds_cpu_reset_sec
, cpu
);
486 /* Fixup Memory size on a alignment boundary */
487 ram_size
&= ~(RAM_SIZES_ALIGN
- 1);
489 /* Register Memory */
490 memory_region_init_ram(ram
, "mpc8544ds.ram", ram_size
);
491 vmstate_register_ram_global(ram
);
492 memory_region_add_subregion(address_space_mem
, 0, ram
);
495 mpic
= mpic_init(address_space_mem
, MPC8544_MPIC_REGS_BASE
,
496 smp_cpus
, irqs
, NULL
);
499 cpu_abort(env
, "MPIC failed to initialize\n");
504 serial_mm_init(address_space_mem
, MPC8544_SERIAL0_REGS_BASE
,
505 0, mpic
[12+26], 399193,
506 serial_hds
[0], DEVICE_BIG_ENDIAN
);
510 serial_mm_init(address_space_mem
, MPC8544_SERIAL1_REGS_BASE
,
511 0, mpic
[12+26], 399193,
512 serial_hds
[0], DEVICE_BIG_ENDIAN
);
515 /* General Utility device */
516 sysbus_create_simple("mpc8544-guts", MPC8544_UTIL_BASE
, NULL
);
519 dev
= sysbus_create_varargs("e500-pcihost", MPC8544_PCI_REGS_BASE
,
520 mpic
[pci_irq_nrs
[0]], mpic
[pci_irq_nrs
[1]],
521 mpic
[pci_irq_nrs
[2]], mpic
[pci_irq_nrs
[3]],
523 pci_bus
= (PCIBus
*)qdev_get_child_bus(dev
, "pci.0");
525 printf("couldn't create PCI controller!\n");
527 isa_mmio_init(MPC8544_PCI_IO
, MPC8544_PCI_IOLEN
);
530 /* Register network interfaces. */
531 for (i
= 0; i
< nb_nics
; i
++) {
532 pci_nic_init_nofail(&nd_table
[i
], "virtio", NULL
);
536 /* Register spinning region */
537 sysbus_create_simple("e500-spin", MPC8544_SPIN_BASE
, NULL
);
540 if (kernel_filename
) {
541 kernel_size
= load_uimage(kernel_filename
, &entry
, &loadaddr
, NULL
);
542 if (kernel_size
< 0) {
543 kernel_size
= load_elf(kernel_filename
, NULL
, NULL
, &elf_entry
,
544 &elf_lowaddr
, NULL
, 1, ELF_MACHINE
, 0);
546 loadaddr
= elf_lowaddr
;
548 /* XXX try again as binary */
549 if (kernel_size
< 0) {
550 fprintf(stderr
, "qemu: could not load kernel '%s'\n",
557 if (initrd_filename
) {
558 initrd_base
= (kernel_size
+ INITRD_LOAD_PAD
) & ~INITRD_PAD_MASK
;
559 initrd_size
= load_image_targphys(initrd_filename
, initrd_base
,
560 ram_size
- initrd_base
);
562 if (initrd_size
< 0) {
563 fprintf(stderr
, "qemu: could not load initial ram disk '%s'\n",
569 /* If we're loading a kernel directly, we must load the device tree too. */
570 if (kernel_filename
) {
571 struct boot_info
*boot_info
;
574 dt_base
= (loadaddr
+ kernel_size
+ DTC_LOAD_PAD
) & ~DTC_PAD_MASK
;
575 dt_size
= mpc8544_load_device_tree(env
, dt_base
, ram_size
, initrd_base
,
576 initrd_size
, kernel_cmdline
);
578 fprintf(stderr
, "couldn't load device tree\n");
582 boot_info
= env
->load_info
;
583 boot_info
->entry
= entry
;
584 boot_info
->dt_base
= dt_base
;
585 boot_info
->dt_size
= dt_size
;
593 static QEMUMachine mpc8544ds_machine
= {
596 .init
= mpc8544ds_init
,
600 static void mpc8544ds_machine_init(void)
602 qemu_register_machine(&mpc8544ds_machine
);
605 machine_init(mpc8544ds_machine_init
);