]>
git.proxmox.com Git - mirror_qemu.git/blob - hw/arm/boot.c
4 * Copyright (c) 2006-2007 CodeSourcery.
5 * Written by Paul Brook
7 * This code is licensed under the GPL.
12 #include "hw/arm/arm.h"
13 #include "sysemu/sysemu.h"
14 #include "hw/boards.h"
15 #include "hw/loader.h"
17 #include "sysemu/device_tree.h"
18 #include "qemu/config-file.h"
20 #define KERNEL_ARGS_ADDR 0x100
21 #define KERNEL_LOAD_ADDR 0x00010000
23 /* The worlds second smallest bootloader. Set r0-r2, then jump to kernel. */
24 static uint32_t bootloader
[] = {
25 0xe3a00000, /* mov r0, #0 */
26 0xe59f1004, /* ldr r1, [pc, #4] */
27 0xe59f2004, /* ldr r2, [pc, #4] */
28 0xe59ff004, /* ldr pc, [pc, #4] */
30 0, /* Address of kernel args. Set by integratorcp_init. */
31 0 /* Kernel entry point. Set by integratorcp_init. */
34 /* Handling for secondary CPU boot in a multicore system.
35 * Unlike the uniprocessor/primary CPU boot, this is platform
36 * dependent. The default code here is based on the secondary
37 * CPU boot protocol used on realview/vexpress boards, with
38 * some parameterisation to increase its flexibility.
39 * QEMU platform models for which this code is not appropriate
40 * should override write_secondary_boot and secondary_cpu_reset_hook
43 * This code enables the interrupt controllers for the secondary
44 * CPUs and then puts all the secondary CPUs into a loop waiting
45 * for an interprocessor interrupt and polling a configurable
46 * location for the kernel secondary CPU entry point.
48 #define DSB_INSN 0xf57ff04f
49 #define CP15_DSB_INSN 0xee070f9a /* mcr cp15, 0, r0, c7, c10, 4 */
51 static uint32_t smpboot
[] = {
52 0xe59f2028, /* ldr r2, gic_cpu_if */
53 0xe59f0028, /* ldr r0, startaddr */
54 0xe3a01001, /* mov r1, #1 */
55 0xe5821000, /* str r1, [r2] - set GICC_CTLR.Enable */
56 0xe3a010ff, /* mov r1, #0xff */
57 0xe5821004, /* str r1, [r2, 4] - set GIC_PMR.Priority to 0xff */
60 0xe5901000, /* ldr r1, [r0] */
61 0xe1110001, /* tst r1, r1 */
62 0x0afffffb, /* beq <wfi> */
63 0xe12fff11, /* bx r1 */
64 0, /* gic_cpu_if: base address of GIC CPU interface */
65 0 /* bootreg: Boot register address is held here */
68 static void default_write_secondary(ARMCPU
*cpu
,
69 const struct arm_boot_info
*info
)
72 smpboot
[ARRAY_SIZE(smpboot
) - 1] = info
->smp_bootreg_addr
;
73 smpboot
[ARRAY_SIZE(smpboot
) - 2] = info
->gic_cpu_if_addr
;
74 for (n
= 0; n
< ARRAY_SIZE(smpboot
); n
++) {
75 /* Replace DSB with the pre-v7 DSB if necessary. */
76 if (!arm_feature(&cpu
->env
, ARM_FEATURE_V7
) &&
77 smpboot
[n
] == DSB_INSN
) {
78 smpboot
[n
] = CP15_DSB_INSN
;
80 smpboot
[n
] = tswap32(smpboot
[n
]);
82 rom_add_blob_fixed("smpboot", smpboot
, sizeof(smpboot
),
83 info
->smp_loader_start
);
86 static void default_reset_secondary(ARMCPU
*cpu
,
87 const struct arm_boot_info
*info
)
89 CPUARMState
*env
= &cpu
->env
;
91 stl_phys_notdirty(info
->smp_bootreg_addr
, 0);
92 env
->regs
[15] = info
->smp_loader_start
;
95 #define WRITE_WORD(p, value) do { \
96 stl_phys_notdirty(p, value); \
100 static void set_kernel_args(const struct arm_boot_info
*info
)
102 int initrd_size
= info
->initrd_size
;
103 hwaddr base
= info
->loader_start
;
106 p
= base
+ KERNEL_ARGS_ADDR
;
109 WRITE_WORD(p
, 0x54410001);
111 WRITE_WORD(p
, 0x1000);
114 /* TODO: handle multiple chips on one ATAG list */
116 WRITE_WORD(p
, 0x54410002);
117 WRITE_WORD(p
, info
->ram_size
);
118 WRITE_WORD(p
, info
->loader_start
);
122 WRITE_WORD(p
, 0x54420005);
123 WRITE_WORD(p
, info
->initrd_start
);
124 WRITE_WORD(p
, initrd_size
);
126 if (info
->kernel_cmdline
&& *info
->kernel_cmdline
) {
130 cmdline_size
= strlen(info
->kernel_cmdline
);
131 cpu_physical_memory_write(p
+ 8, info
->kernel_cmdline
,
133 cmdline_size
= (cmdline_size
>> 2) + 1;
134 WRITE_WORD(p
, cmdline_size
+ 2);
135 WRITE_WORD(p
, 0x54410009);
136 p
+= cmdline_size
* 4;
138 if (info
->atag_board
) {
141 uint8_t atag_board_buf
[0x1000];
143 atag_board_len
= (info
->atag_board(info
, atag_board_buf
) + 3) & ~3;
144 WRITE_WORD(p
, (atag_board_len
+ 8) >> 2);
145 WRITE_WORD(p
, 0x414f4d50);
146 cpu_physical_memory_write(p
, atag_board_buf
, atag_board_len
);
154 static void set_kernel_args_old(const struct arm_boot_info
*info
)
158 int initrd_size
= info
->initrd_size
;
159 hwaddr base
= info
->loader_start
;
161 /* see linux/include/asm-arm/setup.h */
162 p
= base
+ KERNEL_ARGS_ADDR
;
166 WRITE_WORD(p
, info
->ram_size
/ 4096);
169 #define FLAG_READONLY 1
170 #define FLAG_RDLOAD 4
171 #define FLAG_RDPROMPT 8
173 WRITE_WORD(p
, FLAG_READONLY
| FLAG_RDLOAD
| FLAG_RDPROMPT
);
175 WRITE_WORD(p
, (31 << 8) | 0); /* /dev/mtdblock0 */
184 /* memc_control_reg */
186 /* unsigned char sounddefault */
187 /* unsigned char adfsdrives */
188 /* unsigned char bytes_per_char_h */
189 /* unsigned char bytes_per_char_v */
191 /* pages_in_bank[4] */
200 WRITE_WORD(p
, info
->initrd_start
);
205 WRITE_WORD(p
, initrd_size
);
210 /* system_serial_low */
212 /* system_serial_high */
216 /* zero unused fields */
217 while (p
< base
+ KERNEL_ARGS_ADDR
+ 256 + 1024) {
220 s
= info
->kernel_cmdline
;
222 cpu_physical_memory_write(p
, s
, strlen(s
) + 1);
228 static int load_dtb(hwaddr addr
, const struct arm_boot_info
*binfo
)
232 uint32_t acells
, scells
;
234 if (binfo
->dtb_filename
) {
236 filename
= qemu_find_file(QEMU_FILE_TYPE_BIOS
, binfo
->dtb_filename
);
238 fprintf(stderr
, "Couldn't open dtb file %s\n", binfo
->dtb_filename
);
242 fdt
= load_device_tree(filename
, &size
);
244 fprintf(stderr
, "Couldn't open dtb file %s\n", filename
);
249 } else if (binfo
->get_dtb
) {
250 fdt
= binfo
->get_dtb(binfo
, &size
);
252 fprintf(stderr
, "Board was unable to create a dtb blob\n");
257 acells
= qemu_devtree_getprop_cell(fdt
, "/", "#address-cells");
258 scells
= qemu_devtree_getprop_cell(fdt
, "/", "#size-cells");
259 if (acells
== 0 || scells
== 0) {
260 fprintf(stderr
, "dtb file invalid (#address-cells or #size-cells 0)\n");
264 if (scells
< 2 && binfo
->ram_size
>= (1ULL << 32)) {
265 /* This is user error so deserves a friendlier error message
266 * than the failure of setprop_sized_cells would provide
268 fprintf(stderr
, "qemu: dtb file not compatible with "
273 rc
= qemu_devtree_setprop_sized_cells(fdt
, "/memory", "reg",
274 acells
, binfo
->loader_start
,
275 scells
, binfo
->ram_size
);
277 fprintf(stderr
, "couldn't set /memory/reg\n");
281 if (binfo
->kernel_cmdline
&& *binfo
->kernel_cmdline
) {
282 rc
= qemu_devtree_setprop_string(fdt
, "/chosen", "bootargs",
283 binfo
->kernel_cmdline
);
285 fprintf(stderr
, "couldn't set /chosen/bootargs\n");
290 if (binfo
->initrd_size
) {
291 rc
= qemu_devtree_setprop_cell(fdt
, "/chosen", "linux,initrd-start",
292 binfo
->initrd_start
);
294 fprintf(stderr
, "couldn't set /chosen/linux,initrd-start\n");
298 rc
= qemu_devtree_setprop_cell(fdt
, "/chosen", "linux,initrd-end",
299 binfo
->initrd_start
+ binfo
->initrd_size
);
301 fprintf(stderr
, "couldn't set /chosen/linux,initrd-end\n");
306 if (binfo
->modify_dtb
) {
307 binfo
->modify_dtb(binfo
, fdt
);
310 qemu_devtree_dumpdtb(fdt
, size
);
312 cpu_physical_memory_write(addr
, fdt
, size
);
323 static void do_cpu_reset(void *opaque
)
325 ARMCPU
*cpu
= opaque
;
326 CPUARMState
*env
= &cpu
->env
;
327 const struct arm_boot_info
*info
= env
->boot_info
;
331 if (!info
->is_linux
) {
332 /* Jump to the entry point. */
333 env
->regs
[15] = info
->entry
& 0xfffffffe;
334 env
->thumb
= info
->entry
& 1;
336 if (CPU(cpu
) == first_cpu
) {
337 env
->regs
[15] = info
->loader_start
;
338 if (!info
->dtb_filename
) {
340 set_kernel_args_old(info
);
342 set_kernel_args(info
);
346 info
->secondary_cpu_reset_hook(cpu
, info
);
352 void arm_load_kernel(ARMCPU
*cpu
, struct arm_boot_info
*info
)
354 CPUState
*cs
= CPU(cpu
);
363 /* Load the kernel. */
364 if (!info
->kernel_filename
) {
365 /* If no kernel specified, do nothing; we will start from address 0
366 * (typically a boot ROM image) in the same way as hardware.
371 info
->dtb_filename
= qemu_opt_get(qemu_get_machine_opts(), "dtb");
373 if (!info
->secondary_cpu_reset_hook
) {
374 info
->secondary_cpu_reset_hook
= default_reset_secondary
;
376 if (!info
->write_secondary_boot
) {
377 info
->write_secondary_boot
= default_write_secondary
;
380 if (info
->nb_cpus
== 0)
383 #ifdef TARGET_WORDS_BIGENDIAN
389 /* We want to put the initrd far enough into RAM that when the
390 * kernel is uncompressed it will not clobber the initrd. However
391 * on boards without much RAM we must ensure that we still leave
392 * enough room for a decent sized initrd, and on boards with large
393 * amounts of RAM we must avoid the initrd being so far up in RAM
394 * that it is outside lowmem and inaccessible to the kernel.
395 * So for boards with less than 256MB of RAM we put the initrd
396 * halfway into RAM, and for boards with 256MB of RAM or more we put
397 * the initrd at 128MB.
399 info
->initrd_start
= info
->loader_start
+
400 MIN(info
->ram_size
/ 2, 128 * 1024 * 1024);
402 /* Assume that raw images are linux kernels, and ELF images are not. */
403 kernel_size
= load_elf(info
->kernel_filename
, NULL
, NULL
, &elf_entry
,
404 NULL
, NULL
, big_endian
, ELF_MACHINE
, 1);
406 if (kernel_size
< 0) {
407 kernel_size
= load_uimage(info
->kernel_filename
, &entry
, NULL
,
410 if (kernel_size
< 0) {
411 entry
= info
->loader_start
+ KERNEL_LOAD_ADDR
;
412 kernel_size
= load_image_targphys(info
->kernel_filename
, entry
,
413 info
->ram_size
- KERNEL_LOAD_ADDR
);
416 if (kernel_size
< 0) {
417 fprintf(stderr
, "qemu: could not load kernel '%s'\n",
418 info
->kernel_filename
);
423 if (info
->initrd_filename
) {
424 initrd_size
= load_ramdisk(info
->initrd_filename
,
428 if (initrd_size
< 0) {
429 initrd_size
= load_image_targphys(info
->initrd_filename
,
434 if (initrd_size
< 0) {
435 fprintf(stderr
, "qemu: could not load initrd '%s'\n",
436 info
->initrd_filename
);
442 info
->initrd_size
= initrd_size
;
444 bootloader
[4] = info
->board_id
;
446 /* for device tree boot, we pass the DTB directly in r2. Otherwise
447 * we point to the kernel args.
449 if (info
->dtb_filename
|| info
->get_dtb
) {
450 /* Place the DTB after the initrd in memory. Note that some
451 * kernels will trash anything in the 4K page the initrd
452 * ends in, so make sure the DTB isn't caught up in that.
454 hwaddr dtb_start
= QEMU_ALIGN_UP(info
->initrd_start
+ initrd_size
,
456 if (load_dtb(dtb_start
, info
)) {
459 bootloader
[5] = dtb_start
;
461 bootloader
[5] = info
->loader_start
+ KERNEL_ARGS_ADDR
;
462 if (info
->ram_size
>= (1ULL << 32)) {
463 fprintf(stderr
, "qemu: RAM size must be less than 4GB to boot"
464 " Linux kernel using ATAGS (try passing a device tree"
469 bootloader
[6] = entry
;
470 for (n
= 0; n
< sizeof(bootloader
) / 4; n
++) {
471 bootloader
[n
] = tswap32(bootloader
[n
]);
473 rom_add_blob_fixed("bootloader", bootloader
, sizeof(bootloader
),
475 if (info
->nb_cpus
> 1) {
476 info
->write_secondary_boot(cpu
, info
);
479 info
->is_linux
= is_linux
;
481 for (; cs
; cs
= CPU_NEXT(cs
)) {
483 cpu
->env
.boot_info
= info
;
484 qemu_register_reset(do_cpu_reset
, cpu
);