2 * (C) Copyright 2000-2009
3 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
5 * SPDX-License-Identifier: GPL-2.0+
17 #include <u-boot/zlib.h>
19 #include <environment.h>
21 #include <linux/ctype.h>
22 #include <asm/byteorder.h>
24 #include <linux/compiler.h>
26 #if defined(CONFIG_CMD_USB)
30 #ifdef CONFIG_SYS_HUSH_PARSER
34 #if defined(CONFIG_OF_LIBFDT)
36 #include <fdt_support.h>
40 #include <lzma/LzmaTypes.h>
41 #include <lzma/LzmaDec.h>
42 #include <lzma/LzmaTools.h>
43 #endif /* CONFIG_LZMA */
46 #include <linux/lzo.h>
47 #endif /* CONFIG_LZO */
49 DECLARE_GLOBAL_DATA_PTR
;
51 #ifndef CONFIG_SYS_BOOTM_LEN
52 #define CONFIG_SYS_BOOTM_LEN 0x800000 /* use 8MByte as default max gunzip size */
56 extern void bz_internal_error(int);
59 #if defined(CONFIG_CMD_IMI)
60 static int image_info(unsigned long addr
);
63 #if defined(CONFIG_CMD_IMLS)
65 #include <mtd/cfi_flash.h>
66 extern flash_info_t flash_info
[]; /* info for FLASH chips */
69 #if defined(CONFIG_CMD_IMLS) || defined(CONFIG_CMD_IMLS_NAND)
70 static int do_imls(cmd_tbl_t
*cmdtp
, int flag
, int argc
, char * const argv
[]);
73 #include <linux/err.h>
76 #if defined(CONFIG_SILENT_CONSOLE) && !defined(CONFIG_SILENT_U_BOOT_ONLY)
77 static void fixup_silent_linux(void);
80 static const void *boot_get_kernel(cmd_tbl_t
*cmdtp
, int flag
, int argc
,
81 char * const argv
[], bootm_headers_t
*images
,
82 ulong
*os_data
, ulong
*os_len
);
85 * Continue booting an OS image; caller already has:
86 * - copied image header to global variable `header'
87 * - checked header magic number, checksums (both header & image),
88 * - verified image architecture (PPC) and type (KERNEL or MULTI),
89 * - loaded (first part of) image to header load address,
90 * - disabled interrupts.
92 * @flag: Flags indicating what to do (BOOTM_STATE_...)
93 * @argc: Number of arguments. Note that the arguments are shifted down
94 * so that 0 is the first argument not processed by U-Boot, and
95 * argc is adjusted accordingly. This avoids confusion as to how
96 * many arguments are available for the OS.
97 * @images: Pointers to os/initrd/fdt
98 * @return 1 on error. On success the OS boots so this function does
101 typedef int boot_os_fn(int flag
, int argc
, char * const argv
[],
102 bootm_headers_t
*images
);
104 #ifdef CONFIG_BOOTM_LINUX
105 extern boot_os_fn do_bootm_linux
;
107 #ifdef CONFIG_BOOTM_NETBSD
108 static boot_os_fn do_bootm_netbsd
;
110 #if defined(CONFIG_LYNXKDI)
111 static boot_os_fn do_bootm_lynxkdi
;
112 extern void lynxkdi_boot(image_header_t
*);
114 #ifdef CONFIG_BOOTM_RTEMS
115 static boot_os_fn do_bootm_rtems
;
117 #if defined(CONFIG_BOOTM_OSE)
118 static boot_os_fn do_bootm_ose
;
120 #if defined(CONFIG_BOOTM_PLAN9)
121 static boot_os_fn do_bootm_plan9
;
123 #if defined(CONFIG_CMD_ELF)
124 static boot_os_fn do_bootm_vxworks
;
125 static boot_os_fn do_bootm_qnxelf
;
126 int do_bootvx(cmd_tbl_t
*cmdtp
, int flag
, int argc
, char * const argv
[]);
127 int do_bootelf(cmd_tbl_t
*cmdtp
, int flag
, int argc
, char * const argv
[]);
129 #if defined(CONFIG_INTEGRITY)
130 static boot_os_fn do_bootm_integrity
;
133 static boot_os_fn
*boot_os
[] = {
134 #ifdef CONFIG_BOOTM_LINUX
135 [IH_OS_LINUX
] = do_bootm_linux
,
137 #ifdef CONFIG_BOOTM_NETBSD
138 [IH_OS_NETBSD
] = do_bootm_netbsd
,
140 #ifdef CONFIG_LYNXKDI
141 [IH_OS_LYNXOS
] = do_bootm_lynxkdi
,
143 #ifdef CONFIG_BOOTM_RTEMS
144 [IH_OS_RTEMS
] = do_bootm_rtems
,
146 #if defined(CONFIG_BOOTM_OSE)
147 [IH_OS_OSE
] = do_bootm_ose
,
149 #if defined(CONFIG_BOOTM_PLAN9)
150 [IH_OS_PLAN9
] = do_bootm_plan9
,
152 #if defined(CONFIG_CMD_ELF)
153 [IH_OS_VXWORKS
] = do_bootm_vxworks
,
154 [IH_OS_QNX
] = do_bootm_qnxelf
,
156 #ifdef CONFIG_INTEGRITY
157 [IH_OS_INTEGRITY
] = do_bootm_integrity
,
161 bootm_headers_t images
; /* pointers to os/initrd/fdt images */
163 /* Allow for arch specific config before we boot */
164 static void __arch_preboot_os(void)
166 /* please define platform specific arch_preboot_os() */
168 void arch_preboot_os(void) __attribute__((weak
, alias("__arch_preboot_os")));
170 #define IH_INITRD_ARCH IH_ARCH_DEFAULT
173 static void boot_start_lmb(bootm_headers_t
*images
)
176 phys_size_t mem_size
;
178 lmb_init(&images
->lmb
);
180 mem_start
= getenv_bootm_low();
181 mem_size
= getenv_bootm_size();
183 lmb_add(&images
->lmb
, (phys_addr_t
)mem_start
, mem_size
);
185 arch_lmb_reserve(&images
->lmb
);
186 board_lmb_reserve(&images
->lmb
);
189 #define lmb_reserve(lmb, base, size)
190 static inline void boot_start_lmb(bootm_headers_t
*images
) { }
193 static int bootm_start(cmd_tbl_t
*cmdtp
, int flag
, int argc
, char * const argv
[])
195 memset((void *)&images
, 0, sizeof(images
));
196 images
.verify
= getenv_yesno("verify");
198 boot_start_lmb(&images
);
200 bootstage_mark_name(BOOTSTAGE_ID_BOOTM_START
, "bootm_start");
201 images
.state
= BOOTM_STATE_START
;
206 static int bootm_find_os(cmd_tbl_t
*cmdtp
, int flag
, int argc
,
211 /* get kernel image header, start address and length */
212 os_hdr
= boot_get_kernel(cmdtp
, flag
, argc
, argv
,
213 &images
, &images
.os
.image_start
, &images
.os
.image_len
);
214 if (images
.os
.image_len
== 0) {
215 puts("ERROR: can't get kernel image!\n");
219 /* get image parameters */
220 switch (genimg_get_format(os_hdr
)) {
221 case IMAGE_FORMAT_LEGACY
:
222 images
.os
.type
= image_get_type(os_hdr
);
223 images
.os
.comp
= image_get_comp(os_hdr
);
224 images
.os
.os
= image_get_os(os_hdr
);
226 images
.os
.end
= image_get_image_end(os_hdr
);
227 images
.os
.load
= image_get_load(os_hdr
);
229 #if defined(CONFIG_FIT)
230 case IMAGE_FORMAT_FIT
:
231 if (fit_image_get_type(images
.fit_hdr_os
,
232 images
.fit_noffset_os
, &images
.os
.type
)) {
233 puts("Can't get image type!\n");
234 bootstage_error(BOOTSTAGE_ID_FIT_TYPE
);
238 if (fit_image_get_comp(images
.fit_hdr_os
,
239 images
.fit_noffset_os
, &images
.os
.comp
)) {
240 puts("Can't get image compression!\n");
241 bootstage_error(BOOTSTAGE_ID_FIT_COMPRESSION
);
245 if (fit_image_get_os(images
.fit_hdr_os
,
246 images
.fit_noffset_os
, &images
.os
.os
)) {
247 puts("Can't get image OS!\n");
248 bootstage_error(BOOTSTAGE_ID_FIT_OS
);
252 images
.os
.end
= fit_get_end(images
.fit_hdr_os
);
254 if (fit_image_get_load(images
.fit_hdr_os
, images
.fit_noffset_os
,
256 puts("Can't get image load address!\n");
257 bootstage_error(BOOTSTAGE_ID_FIT_LOADADDR
);
263 puts("ERROR: unknown image format type!\n");
267 /* find kernel entry point */
268 if (images
.legacy_hdr_valid
) {
269 images
.ep
= image_get_ep(&images
.legacy_hdr_os_copy
);
270 #if defined(CONFIG_FIT)
271 } else if (images
.fit_uname_os
) {
274 ret
= fit_image_get_entry(images
.fit_hdr_os
,
275 images
.fit_noffset_os
, &images
.ep
);
277 puts("Can't get entry point property!\n");
282 puts("Could not find kernel entry point!\n");
286 if (images
.os
.type
== IH_TYPE_KERNEL_NOLOAD
) {
287 images
.os
.load
= images
.os
.image_start
;
288 images
.ep
+= images
.os
.load
;
291 images
.os
.start
= (ulong
)os_hdr
;
296 static int bootm_find_ramdisk(int flag
, int argc
, char * const argv
[])
301 ret
= boot_get_ramdisk(argc
, argv
, &images
, IH_INITRD_ARCH
,
302 &images
.rd_start
, &images
.rd_end
);
304 puts("Ramdisk image is corrupt or invalid\n");
311 #if defined(CONFIG_OF_LIBFDT)
312 static int bootm_find_fdt(int flag
, int argc
, char * const argv
[])
316 /* find flattened device tree */
317 ret
= boot_get_fdt(flag
, argc
, argv
, IH_ARCH_DEFAULT
, &images
,
318 &images
.ft_addr
, &images
.ft_len
);
320 puts("Could not find a valid device tree\n");
324 set_working_fdt_addr(images
.ft_addr
);
330 static int bootm_find_other(cmd_tbl_t
*cmdtp
, int flag
, int argc
,
333 if (((images
.os
.type
== IH_TYPE_KERNEL
) ||
334 (images
.os
.type
== IH_TYPE_KERNEL_NOLOAD
) ||
335 (images
.os
.type
== IH_TYPE_MULTI
)) &&
336 (images
.os
.os
== IH_OS_LINUX
)) {
337 if (bootm_find_ramdisk(flag
, argc
, argv
))
340 #if defined(CONFIG_OF_LIBFDT)
341 if (bootm_find_fdt(flag
, argc
, argv
))
349 #define BOOTM_ERR_RESET -1
350 #define BOOTM_ERR_OVERLAP -2
351 #define BOOTM_ERR_UNIMPLEMENTED -3
352 static int bootm_load_os(bootm_headers_t
*images
, unsigned long *load_end
,
355 image_info_t os
= images
->os
;
356 uint8_t comp
= os
.comp
;
357 ulong load
= os
.load
;
358 ulong blob_start
= os
.start
;
359 ulong blob_end
= os
.end
;
360 ulong image_start
= os
.image_start
;
361 ulong image_len
= os
.image_len
;
362 __maybe_unused uint unc_len
= CONFIG_SYS_BOOTM_LEN
;
364 void *load_buf
, *image_buf
;
365 #if defined(CONFIG_LZMA) || defined(CONFIG_LZO)
367 #endif /* defined(CONFIG_LZMA) || defined(CONFIG_LZO) */
369 const char *type_name
= genimg_get_type_name(os
.type
);
371 load_buf
= map_sysmem(load
, unc_len
);
372 image_buf
= map_sysmem(image_start
, image_len
);
375 if (load
== blob_start
|| load
== image_start
) {
376 printf(" XIP %s ... ", type_name
);
379 printf(" Loading %s ... ", type_name
);
380 memmove_wd(load_buf
, image_buf
, image_len
, CHUNKSZ
);
382 *load_end
= load
+ image_len
;
386 printf(" Uncompressing %s ... ", type_name
);
387 if (gunzip(load_buf
, unc_len
, image_buf
, &image_len
) != 0) {
388 puts("GUNZIP: uncompress, out-of-mem or overwrite "
389 "error - must RESET board to recover\n");
391 bootstage_error(BOOTSTAGE_ID_DECOMP_IMAGE
);
392 return BOOTM_ERR_RESET
;
395 *load_end
= load
+ image_len
;
397 #endif /* CONFIG_GZIP */
400 printf(" Uncompressing %s ... ", type_name
);
402 * If we've got less than 4 MB of malloc() space,
403 * use slower decompression algorithm which requires
404 * at most 2300 KB of memory.
406 int i
= BZ2_bzBuffToBuffDecompress(load_buf
, &unc_len
,
407 image_buf
, image_len
,
408 CONFIG_SYS_MALLOC_LEN
< (4096 * 1024), 0);
410 printf("BUNZIP2: uncompress or overwrite error %d "
411 "- must RESET board to recover\n", i
);
413 bootstage_error(BOOTSTAGE_ID_DECOMP_IMAGE
);
414 return BOOTM_ERR_RESET
;
417 *load_end
= load
+ unc_len
;
419 #endif /* CONFIG_BZIP2 */
422 SizeT lzma_len
= unc_len
;
423 printf(" Uncompressing %s ... ", type_name
);
425 ret
= lzmaBuffToBuffDecompress(load_buf
, &lzma_len
,
426 image_buf
, image_len
);
429 printf("LZMA: uncompress or overwrite error %d "
430 "- must RESET board to recover\n", ret
);
431 bootstage_error(BOOTSTAGE_ID_DECOMP_IMAGE
);
432 return BOOTM_ERR_RESET
;
434 *load_end
= load
+ unc_len
;
437 #endif /* CONFIG_LZMA */
442 printf(" Uncompressing %s ... ", type_name
);
444 ret
= lzop_decompress(image_buf
, image_len
, load_buf
, &size
);
445 if (ret
!= LZO_E_OK
) {
446 printf("LZO: uncompress or overwrite error %d "
447 "- must RESET board to recover\n", ret
);
449 bootstage_error(BOOTSTAGE_ID_DECOMP_IMAGE
);
450 return BOOTM_ERR_RESET
;
453 *load_end
= load
+ size
;
456 #endif /* CONFIG_LZO */
458 printf("Unimplemented compression type %d\n", comp
);
459 return BOOTM_ERR_UNIMPLEMENTED
;
462 flush_cache(load
, (*load_end
- load
) * sizeof(ulong
));
465 debug(" kernel loaded at 0x%08lx, end = 0x%08lx\n", load
, *load_end
);
466 bootstage_mark(BOOTSTAGE_ID_KERNEL_LOADED
);
468 if (!no_overlap
&& (load
< blob_end
) && (*load_end
> blob_start
)) {
469 debug("images.os.start = 0x%lX, images.os.end = 0x%lx\n",
470 blob_start
, blob_end
);
471 debug("images.os.load = 0x%lx, load_end = 0x%lx\n", load
,
474 /* Check what type of image this is. */
475 if (images
->legacy_hdr_valid
) {
476 if (image_get_type(&images
->legacy_hdr_os_copy
)
478 puts("WARNING: legacy format multi component image overwritten\n");
479 return BOOTM_ERR_OVERLAP
;
481 puts("ERROR: new format image overwritten - must RESET the board to recover\n");
482 bootstage_error(BOOTSTAGE_ID_OVERWRITTEN
);
483 return BOOTM_ERR_RESET
;
490 static int bootm_start_standalone(int argc
, char * const argv
[])
493 int (*appl
)(int, char * const []);
495 /* Don't start if "autostart" is set to "no" */
496 if (((s
= getenv("autostart")) != NULL
) && (strcmp(s
, "no") == 0)) {
497 setenv_hex("filesize", images
.os
.image_len
);
500 appl
= (int (*)(int, char * const []))(ulong
)ntohl(images
.ep
);
505 /* we overload the cmd field with our state machine info instead of a
506 * function pointer */
507 static cmd_tbl_t cmd_bootm_sub
[] = {
508 U_BOOT_CMD_MKENT(start
, 0, 1, (void *)BOOTM_STATE_START
, "", ""),
509 U_BOOT_CMD_MKENT(loados
, 0, 1, (void *)BOOTM_STATE_LOADOS
, "", ""),
510 #ifdef CONFIG_SYS_BOOT_RAMDISK_HIGH
511 U_BOOT_CMD_MKENT(ramdisk
, 0, 1, (void *)BOOTM_STATE_RAMDISK
, "", ""),
513 #ifdef CONFIG_OF_LIBFDT
514 U_BOOT_CMD_MKENT(fdt
, 0, 1, (void *)BOOTM_STATE_FDT
, "", ""),
516 U_BOOT_CMD_MKENT(cmdline
, 0, 1, (void *)BOOTM_STATE_OS_CMDLINE
, "", ""),
517 U_BOOT_CMD_MKENT(bdt
, 0, 1, (void *)BOOTM_STATE_OS_BD_T
, "", ""),
518 U_BOOT_CMD_MKENT(prep
, 0, 1, (void *)BOOTM_STATE_OS_PREP
, "", ""),
519 U_BOOT_CMD_MKENT(fake
, 0, 1, (void *)BOOTM_STATE_OS_FAKE_GO
, "", ""),
520 U_BOOT_CMD_MKENT(go
, 0, 1, (void *)BOOTM_STATE_OS_GO
, "", ""),
523 static int boot_selected_os(int argc
, char * const argv
[], int state
,
524 bootm_headers_t
*images
, boot_os_fn
*boot_fn
)
526 if (images
->os
.type
== IH_TYPE_STANDALONE
) {
527 /* This may return when 'autostart' is 'no' */
528 bootm_start_standalone(argc
, argv
);
532 boot_fn(state
, argc
, argv
, images
);
533 if (state
== BOOTM_STATE_OS_FAKE_GO
) /* We expect to return */
535 bootstage_error(BOOTSTAGE_ID_BOOT_OS_RETURNED
);
537 puts("\n## Control returned to monitor - resetting...\n");
539 return BOOTM_ERR_RESET
;
543 * bootm_disable_interrupts() - Disable interrupts in preparation for load/boot
545 * @return interrupt flag (0 if interrupts were disabled, non-zero if they were
548 static ulong
bootm_disable_interrupts(void)
553 * We have reached the point of no return: we are going to
554 * overwrite all exception vector code, so we cannot easily
555 * recover from any failures any more...
557 iflag
= disable_interrupts();
558 #ifdef CONFIG_NETCONSOLE
559 /* Stop the ethernet stack if NetConsole could have left it up */
561 eth_unregister(eth_get_dev());
564 #if defined(CONFIG_CMD_USB)
566 * turn off USB to prevent the host controller from writing to the
567 * SDRAM while Linux is booting. This could happen (at least for OHCI
568 * controller), because the HCCA (Host Controller Communication Area)
569 * lies within the SDRAM and the host controller writes continously to
570 * this area (as busmaster!). The HccaFrameNumber is for example
571 * updated every 1 ms within the HCCA structure in SDRAM! For more
572 * details see the OpenHCI specification.
580 * Execute selected states of the bootm command.
582 * Note the arguments to this state must be the first argument, Any 'bootm'
583 * or sub-command arguments must have already been taken.
585 * Note that if states contains more than one flag it MUST contain
586 * BOOTM_STATE_START, since this handles and consumes the command line args.
588 * Also note that aside from boot_os_fn functions and bootm_load_os no other
589 * functions we store the return value of in 'ret' may use a negative return
590 * value, without special handling.
592 * @param cmdtp Pointer to bootm command table entry
593 * @param flag Command flags (CMD_FLAG_...)
594 * @param argc Number of subcommand arguments (0 = no arguments)
595 * @param argv Arguments
596 * @param states Mask containing states to run (BOOTM_STATE_...)
597 * @param images Image header information
598 * @param boot_progress 1 to show boot progress, 0 to not do this
599 * @return 0 if ok, something else on error. Some errors will cause this
600 * function to perform a reboot! If states contains BOOTM_STATE_OS_GO
601 * then the intent is to boot an OS, so this function will not return
602 * unless the image type is standalone.
604 static int do_bootm_states(cmd_tbl_t
*cmdtp
, int flag
, int argc
,
605 char * const argv
[], int states
, bootm_headers_t
*images
,
610 int ret
= 0, need_boot_fn
;
612 images
->state
|= states
;
615 * Work through the states and see how far we get. We stop on
618 if (states
& BOOTM_STATE_START
)
619 ret
= bootm_start(cmdtp
, flag
, argc
, argv
);
621 if (!ret
&& (states
& BOOTM_STATE_FINDOS
))
622 ret
= bootm_find_os(cmdtp
, flag
, argc
, argv
);
624 if (!ret
&& (states
& BOOTM_STATE_FINDOTHER
)) {
625 ret
= bootm_find_other(cmdtp
, flag
, argc
, argv
);
626 argc
= 0; /* consume the args */
630 if (!ret
&& (states
& BOOTM_STATE_LOADOS
)) {
633 iflag
= bootm_disable_interrupts();
634 ret
= bootm_load_os(images
, &load_end
, 0);
636 lmb_reserve(&images
->lmb
, images
->os
.load
,
637 (load_end
- images
->os
.load
));
638 else if (ret
&& ret
!= BOOTM_ERR_OVERLAP
)
640 else if (ret
== BOOTM_ERR_OVERLAP
)
642 #if defined(CONFIG_SILENT_CONSOLE) && !defined(CONFIG_SILENT_U_BOOT_ONLY)
643 if (images
->os
.os
== IH_OS_LINUX
)
644 fixup_silent_linux();
648 /* Relocate the ramdisk */
649 #ifdef CONFIG_SYS_BOOT_RAMDISK_HIGH
650 if (!ret
&& (states
& BOOTM_STATE_RAMDISK
)) {
651 ulong rd_len
= images
->rd_end
- images
->rd_start
;
653 ret
= boot_ramdisk_high(&images
->lmb
, images
->rd_start
,
654 rd_len
, &images
->initrd_start
, &images
->initrd_end
);
656 setenv_hex("initrd_start", images
->initrd_start
);
657 setenv_hex("initrd_end", images
->initrd_end
);
661 #if defined(CONFIG_OF_LIBFDT) && defined(CONFIG_LMB)
662 if (!ret
&& (states
& BOOTM_STATE_FDT
)) {
663 boot_fdt_add_mem_rsv_regions(&images
->lmb
, images
->ft_addr
);
664 ret
= boot_relocate_fdt(&images
->lmb
, &images
->ft_addr
,
669 /* From now on, we need the OS boot function */
672 boot_fn
= boot_os
[images
->os
.os
];
673 need_boot_fn
= states
& (BOOTM_STATE_OS_CMDLINE
|
674 BOOTM_STATE_OS_BD_T
| BOOTM_STATE_OS_PREP
|
675 BOOTM_STATE_OS_FAKE_GO
| BOOTM_STATE_OS_GO
);
676 if (boot_fn
== NULL
&& need_boot_fn
) {
679 printf("ERROR: booting os '%s' (%d) is not supported\n",
680 genimg_get_os_name(images
->os
.os
), images
->os
.os
);
681 bootstage_error(BOOTSTAGE_ID_CHECK_BOOT_OS
);
685 /* Call various other states that are not generally used */
686 if (!ret
&& (states
& BOOTM_STATE_OS_CMDLINE
))
687 ret
= boot_fn(BOOTM_STATE_OS_CMDLINE
, argc
, argv
, images
);
688 if (!ret
&& (states
& BOOTM_STATE_OS_BD_T
))
689 ret
= boot_fn(BOOTM_STATE_OS_BD_T
, argc
, argv
, images
);
690 if (!ret
&& (states
& BOOTM_STATE_OS_PREP
))
691 ret
= boot_fn(BOOTM_STATE_OS_PREP
, argc
, argv
, images
);
694 /* Pretend to run the OS, then run a user command */
695 if (!ret
&& (states
& BOOTM_STATE_OS_FAKE_GO
)) {
696 char *cmd_list
= getenv("fakegocmd");
698 ret
= boot_selected_os(argc
, argv
, BOOTM_STATE_OS_FAKE_GO
,
700 if (!ret
&& cmd_list
)
701 ret
= run_command_list(cmd_list
, -1, flag
);
705 /* Check for unsupported subcommand. */
707 puts("subcommand not supported\n");
711 /* Now run the OS! We hope this doesn't return */
712 if (!ret
&& (states
& BOOTM_STATE_OS_GO
))
713 ret
= boot_selected_os(argc
, argv
, BOOTM_STATE_OS_GO
,
716 /* Deal with any fallout */
721 if (ret
== BOOTM_ERR_UNIMPLEMENTED
)
722 bootstage_error(BOOTSTAGE_ID_DECOMP_UNIMPL
);
723 else if (ret
== BOOTM_ERR_RESET
)
724 do_reset(cmdtp
, flag
, argc
, argv
);
729 static int do_bootm_subcommand(cmd_tbl_t
*cmdtp
, int flag
, int argc
,
736 c
= find_cmd_tbl(argv
[0], &cmd_bootm_sub
[0], ARRAY_SIZE(cmd_bootm_sub
));
740 state
= (long)c
->cmd
;
741 if (state
== BOOTM_STATE_START
)
742 state
|= BOOTM_STATE_FINDOS
| BOOTM_STATE_FINDOTHER
;
744 /* Unrecognized command */
745 return CMD_RET_USAGE
;
748 if (state
!= BOOTM_STATE_START
&& images
.state
>= state
) {
749 printf("Trying to execute a command out of order\n");
750 return CMD_RET_USAGE
;
753 ret
= do_bootm_states(cmdtp
, flag
, argc
, argv
, state
, &images
, 0);
758 /*******************************************************************/
759 /* bootm - boot application image from image in memory */
760 /*******************************************************************/
762 int do_bootm(cmd_tbl_t
*cmdtp
, int flag
, int argc
, char * const argv
[])
764 #ifdef CONFIG_NEEDS_MANUAL_RELOC
765 static int relocated
= 0;
770 /* relocate boot function table */
771 for (i
= 0; i
< ARRAY_SIZE(boot_os
); i
++)
772 if (boot_os
[i
] != NULL
)
773 boot_os
[i
] += gd
->reloc_off
;
775 /* relocate names of sub-command table */
776 for (i
= 0; i
< ARRAY_SIZE(cmd_bootm_sub
); i
++)
777 cmd_bootm_sub
[i
].name
+= gd
->reloc_off
;
783 /* determine if we have a sub command */
788 simple_strtoul(argv
[0], &endp
, 16);
789 /* endp pointing to NULL means that argv[0] was just a
790 * valid number, pass it along to the normal bootm processing
792 * If endp is ':' or '#' assume a FIT identifier so pass
793 * along for normal processing.
795 * Right now we assume the first arg should never be '-'
797 if ((*endp
!= 0) && (*endp
!= ':') && (*endp
!= '#'))
798 return do_bootm_subcommand(cmdtp
, flag
, argc
, argv
);
801 return do_bootm_states(cmdtp
, flag
, argc
, argv
, BOOTM_STATE_START
|
802 BOOTM_STATE_FINDOS
| BOOTM_STATE_FINDOTHER
|
804 #if defined(CONFIG_PPC) || defined(CONFIG_MIPS)
805 BOOTM_STATE_OS_CMDLINE
|
807 BOOTM_STATE_OS_PREP
| BOOTM_STATE_OS_FAKE_GO
|
808 BOOTM_STATE_OS_GO
, &images
, 1);
811 int bootm_maybe_autostart(cmd_tbl_t
*cmdtp
, const char *cmd
)
813 const char *ep
= getenv("autostart");
815 if (ep
&& !strcmp(ep
, "yes")) {
817 local_args
[0] = (char *)cmd
;
818 local_args
[1] = NULL
;
819 printf("Automatic boot of image at addr 0x%08lX ...\n", load_addr
);
820 return do_bootm(cmdtp
, 0, 1, local_args
);
827 * image_get_kernel - verify legacy format kernel image
828 * @img_addr: in RAM address of the legacy format image to be verified
829 * @verify: data CRC verification flag
831 * image_get_kernel() verifies legacy image integrity and returns pointer to
832 * legacy image header if image verification was completed successfully.
835 * pointer to a legacy image header if valid image was found
836 * otherwise return NULL
838 static image_header_t
*image_get_kernel(ulong img_addr
, int verify
)
840 image_header_t
*hdr
= (image_header_t
*)img_addr
;
842 if (!image_check_magic(hdr
)) {
843 puts("Bad Magic Number\n");
844 bootstage_error(BOOTSTAGE_ID_CHECK_MAGIC
);
847 bootstage_mark(BOOTSTAGE_ID_CHECK_HEADER
);
849 if (!image_check_hcrc(hdr
)) {
850 puts("Bad Header Checksum\n");
851 bootstage_error(BOOTSTAGE_ID_CHECK_HEADER
);
855 bootstage_mark(BOOTSTAGE_ID_CHECK_CHECKSUM
);
856 image_print_contents(hdr
);
859 puts(" Verifying Checksum ... ");
860 if (!image_check_dcrc(hdr
)) {
861 printf("Bad Data CRC\n");
862 bootstage_error(BOOTSTAGE_ID_CHECK_CHECKSUM
);
867 bootstage_mark(BOOTSTAGE_ID_CHECK_ARCH
);
869 if (!image_check_target_arch(hdr
)) {
870 printf("Unsupported Architecture 0x%x\n", image_get_arch(hdr
));
871 bootstage_error(BOOTSTAGE_ID_CHECK_ARCH
);
878 * boot_get_kernel - find kernel image
879 * @os_data: pointer to a ulong variable, will hold os data start address
880 * @os_len: pointer to a ulong variable, will hold os data length
882 * boot_get_kernel() tries to find a kernel image, verifies its integrity
883 * and locates kernel data.
886 * pointer to image header if valid image was found, plus kernel start
887 * address and length, otherwise NULL
889 static const void *boot_get_kernel(cmd_tbl_t
*cmdtp
, int flag
, int argc
,
890 char * const argv
[], bootm_headers_t
*images
, ulong
*os_data
,
896 #if defined(CONFIG_FIT)
897 const char *fit_uname_config
= NULL
;
898 const char *fit_uname_kernel
= NULL
;
902 /* find out kernel image address */
904 img_addr
= load_addr
;
905 debug("* kernel: default image load address = 0x%08lx\n",
907 #if defined(CONFIG_FIT)
908 } else if (fit_parse_conf(argv
[0], load_addr
, &img_addr
,
909 &fit_uname_config
)) {
910 debug("* kernel: config '%s' from image at 0x%08lx\n",
911 fit_uname_config
, img_addr
);
912 } else if (fit_parse_subimage(argv
[0], load_addr
, &img_addr
,
913 &fit_uname_kernel
)) {
914 debug("* kernel: subimage '%s' from image at 0x%08lx\n",
915 fit_uname_kernel
, img_addr
);
918 img_addr
= simple_strtoul(argv
[0], NULL
, 16);
919 debug("* kernel: cmdline image address = 0x%08lx\n", img_addr
);
922 bootstage_mark(BOOTSTAGE_ID_CHECK_MAGIC
);
924 /* copy from dataflash if needed */
925 img_addr
= genimg_get_image(img_addr
);
927 /* check image type, for FIT images get FIT kernel node */
928 *os_data
= *os_len
= 0;
929 buf
= map_sysmem(img_addr
, 0);
930 switch (genimg_get_format(buf
)) {
931 case IMAGE_FORMAT_LEGACY
:
932 printf("## Booting kernel from Legacy Image at %08lx ...\n",
934 hdr
= image_get_kernel(img_addr
, images
->verify
);
937 bootstage_mark(BOOTSTAGE_ID_CHECK_IMAGETYPE
);
939 /* get os_data and os_len */
940 switch (image_get_type(hdr
)) {
942 case IH_TYPE_KERNEL_NOLOAD
:
943 *os_data
= image_get_data(hdr
);
944 *os_len
= image_get_data_size(hdr
);
947 image_multi_getimg(hdr
, 0, os_data
, os_len
);
949 case IH_TYPE_STANDALONE
:
950 *os_data
= image_get_data(hdr
);
951 *os_len
= image_get_data_size(hdr
);
954 printf("Wrong Image Type for %s command\n",
956 bootstage_error(BOOTSTAGE_ID_CHECK_IMAGETYPE
);
961 * copy image header to allow for image overwrites during
962 * kernel decompression.
964 memmove(&images
->legacy_hdr_os_copy
, hdr
,
965 sizeof(image_header_t
));
967 /* save pointer to image header */
968 images
->legacy_hdr_os
= hdr
;
970 images
->legacy_hdr_valid
= 1;
971 bootstage_mark(BOOTSTAGE_ID_DECOMP_IMAGE
);
973 #if defined(CONFIG_FIT)
974 case IMAGE_FORMAT_FIT
:
975 os_noffset
= fit_image_load(images
, FIT_KERNEL_PROP
,
977 &fit_uname_kernel
, &fit_uname_config
,
978 IH_ARCH_DEFAULT
, IH_TYPE_KERNEL
,
979 BOOTSTAGE_ID_FIT_KERNEL_START
,
980 FIT_LOAD_IGNORED
, os_data
, os_len
);
984 images
->fit_hdr_os
= map_sysmem(img_addr
, 0);
985 images
->fit_uname_os
= fit_uname_kernel
;
986 images
->fit_uname_cfg
= fit_uname_config
;
987 images
->fit_noffset_os
= os_noffset
;
991 printf("Wrong Image Format for %s command\n", cmdtp
->name
);
992 bootstage_error(BOOTSTAGE_ID_FIT_KERNEL_INFO
);
996 debug(" kernel data at 0x%08lx, len = 0x%08lx (%ld)\n",
997 *os_data
, *os_len
, *os_len
);
1002 #ifdef CONFIG_SYS_LONGHELP
1003 static char bootm_help_text
[] =
1004 "[addr [arg ...]]\n - boot application image stored in memory\n"
1005 "\tpassing arguments 'arg ...'; when booting a Linux kernel,\n"
1006 "\t'arg' can be the address of an initrd image\n"
1007 #if defined(CONFIG_OF_LIBFDT)
1008 "\tWhen booting a Linux kernel which requires a flat device-tree\n"
1009 "\ta third argument is required which is the address of the\n"
1010 "\tdevice-tree blob. To boot that kernel without an initrd image,\n"
1011 "\tuse a '-' for the second argument. If you do not pass a third\n"
1012 "\ta bd_info struct will be passed instead\n"
1014 #if defined(CONFIG_FIT)
1015 "\t\nFor the new multi component uImage format (FIT) addresses\n"
1016 "\tmust be extened to include component or configuration unit name:\n"
1017 "\taddr:<subimg_uname> - direct component image specification\n"
1018 "\taddr#<conf_uname> - configuration specification\n"
1019 "\tUse iminfo command to get the list of existing component\n"
1020 "\timages and configurations.\n"
1022 "\nSub-commands to do part of the bootm sequence. The sub-commands "
1024 "issued in the order below (it's ok to not issue all sub-commands):\n"
1025 "\tstart [addr [arg ...]]\n"
1026 "\tloados - load OS image\n"
1027 #if defined(CONFIG_SYS_BOOT_RAMDISK_HIGH)
1028 "\tramdisk - relocate initrd, set env initrd_start/initrd_end\n"
1030 #if defined(CONFIG_OF_LIBFDT)
1031 "\tfdt - relocate flat device tree\n"
1033 "\tcmdline - OS specific command line processing/setup\n"
1034 "\tbdt - OS specific bd_t processing\n"
1035 "\tprep - OS specific prep before relocation or go\n"
1040 bootm
, CONFIG_SYS_MAXARGS
, 1, do_bootm
,
1041 "boot application image from memory", bootm_help_text
1044 /*******************************************************************/
1045 /* bootd - boot default image */
1046 /*******************************************************************/
1047 #if defined(CONFIG_CMD_BOOTD)
1048 int do_bootd(cmd_tbl_t
*cmdtp
, int flag
, int argc
, char * const argv
[])
1052 if (run_command(getenv("bootcmd"), flag
) < 0)
1058 boot
, 1, 1, do_bootd
,
1059 "boot default, i.e., run 'bootcmd'",
1063 /* keep old command name "bootd" for backward compatibility */
1065 bootd
, 1, 1, do_bootd
,
1066 "boot default, i.e., run 'bootcmd'",
1073 /*******************************************************************/
1074 /* iminfo - print header info for a requested image */
1075 /*******************************************************************/
1076 #if defined(CONFIG_CMD_IMI)
1077 static int do_iminfo(cmd_tbl_t
*cmdtp
, int flag
, int argc
, char * const argv
[])
1084 return image_info(load_addr
);
1087 for (arg
= 1; arg
< argc
; ++arg
) {
1088 addr
= simple_strtoul(argv
[arg
], NULL
, 16);
1089 if (image_info(addr
) != 0)
1095 static int image_info(ulong addr
)
1097 void *hdr
= (void *)addr
;
1099 printf("\n## Checking Image at %08lx ...\n", addr
);
1101 switch (genimg_get_format(hdr
)) {
1102 case IMAGE_FORMAT_LEGACY
:
1103 puts(" Legacy image found\n");
1104 if (!image_check_magic(hdr
)) {
1105 puts(" Bad Magic Number\n");
1109 if (!image_check_hcrc(hdr
)) {
1110 puts(" Bad Header Checksum\n");
1114 image_print_contents(hdr
);
1116 puts(" Verifying Checksum ... ");
1117 if (!image_check_dcrc(hdr
)) {
1118 puts(" Bad Data CRC\n");
1123 #if defined(CONFIG_FIT)
1124 case IMAGE_FORMAT_FIT
:
1125 puts(" FIT image found\n");
1127 if (!fit_check_format(hdr
)) {
1128 puts("Bad FIT image format!\n");
1132 fit_print_contents(hdr
);
1134 if (!fit_all_image_verify(hdr
)) {
1135 puts("Bad hash in FIT image!\n");
1142 puts("Unknown image format!\n");
1150 iminfo
, CONFIG_SYS_MAXARGS
, 1, do_iminfo
,
1151 "print header information for application image",
1153 " - print header information for application image starting at\n"
1154 " address 'addr' in memory; this includes verification of the\n"
1155 " image contents (magic number, header and payload checksums)"
1160 /*******************************************************************/
1161 /* imls - list all images found in flash */
1162 /*******************************************************************/
1163 #if defined(CONFIG_CMD_IMLS)
1164 static int do_imls_nor(void)
1170 for (i
= 0, info
= &flash_info
[0];
1171 i
< CONFIG_SYS_MAX_FLASH_BANKS
; ++i
, ++info
) {
1173 if (info
->flash_id
== FLASH_UNKNOWN
)
1175 for (j
= 0; j
< info
->sector_count
; ++j
) {
1177 hdr
= (void *)info
->start
[j
];
1181 switch (genimg_get_format(hdr
)) {
1182 case IMAGE_FORMAT_LEGACY
:
1183 if (!image_check_hcrc(hdr
))
1186 printf("Legacy Image at %08lX:\n", (ulong
)hdr
);
1187 image_print_contents(hdr
);
1189 puts(" Verifying Checksum ... ");
1190 if (!image_check_dcrc(hdr
)) {
1191 puts("Bad Data CRC\n");
1196 #if defined(CONFIG_FIT)
1197 case IMAGE_FORMAT_FIT
:
1198 if (!fit_check_format(hdr
))
1201 printf("FIT Image at %08lX:\n", (ulong
)hdr
);
1202 fit_print_contents(hdr
);
1217 #if defined(CONFIG_CMD_IMLS_NAND)
1218 static int nand_imls_legacyimage(nand_info_t
*nand
, int nand_dev
, loff_t off
,
1224 imgdata
= malloc(len
);
1226 printf("May be a Legacy Image at NAND device %d offset %08llX:\n",
1228 printf(" Low memory(cannot allocate memory for image)\n");
1232 ret
= nand_read_skip_bad(nand
, off
, &len
,
1234 if (ret
< 0 && ret
!= -EUCLEAN
) {
1239 if (!image_check_hcrc(imgdata
)) {
1244 printf("Legacy Image at NAND device %d offset %08llX:\n",
1246 image_print_contents(imgdata
);
1248 puts(" Verifying Checksum ... ");
1249 if (!image_check_dcrc(imgdata
))
1250 puts("Bad Data CRC\n");
1259 static int nand_imls_fitimage(nand_info_t
*nand
, int nand_dev
, loff_t off
,
1265 imgdata
= malloc(len
);
1267 printf("May be a FIT Image at NAND device %d offset %08llX:\n",
1269 printf(" Low memory(cannot allocate memory for image)\n");
1273 ret
= nand_read_skip_bad(nand
, off
, &len
,
1275 if (ret
< 0 && ret
!= -EUCLEAN
) {
1280 if (!fit_check_format(imgdata
)) {
1285 printf("FIT Image at NAND device %d offset %08llX:\n", nand_dev
, off
);
1287 fit_print_contents(imgdata
);
1293 static int do_imls_nand(void)
1296 int nand_dev
= nand_curr_device
;
1301 if (nand_dev
< 0 || nand_dev
>= CONFIG_SYS_MAX_NAND_DEVICE
) {
1302 puts("\nNo NAND devices available\n");
1308 for (nand_dev
= 0; nand_dev
< CONFIG_SYS_MAX_NAND_DEVICE
; nand_dev
++) {
1309 nand
= &nand_info
[nand_dev
];
1310 if (!nand
->name
|| !nand
->size
)
1313 for (off
= 0; off
< nand
->size
; off
+= nand
->erasesize
) {
1314 const image_header_t
*header
;
1317 if (nand_block_isbad(nand
, off
))
1320 len
= sizeof(buffer
);
1322 ret
= nand_read(nand
, off
, &len
, (u8
*)buffer
);
1323 if (ret
< 0 && ret
!= -EUCLEAN
) {
1324 printf("NAND read error %d at offset %08llX\n",
1329 switch (genimg_get_format(buffer
)) {
1330 case IMAGE_FORMAT_LEGACY
:
1331 header
= (const image_header_t
*)buffer
;
1333 len
= image_get_image_size(header
);
1334 nand_imls_legacyimage(nand
, nand_dev
, off
, len
);
1336 #if defined(CONFIG_FIT)
1337 case IMAGE_FORMAT_FIT
:
1338 len
= fit_get_size(buffer
);
1339 nand_imls_fitimage(nand
, nand_dev
, off
, len
);
1350 #if defined(CONFIG_CMD_IMLS) || defined(CONFIG_CMD_IMLS_NAND)
1351 static int do_imls(cmd_tbl_t
*cmdtp
, int flag
, int argc
, char * const argv
[])
1353 int ret_nor
= 0, ret_nand
= 0;
1355 #if defined(CONFIG_CMD_IMLS)
1356 ret_nor
= do_imls_nor();
1359 #if defined(CONFIG_CMD_IMLS_NAND)
1360 ret_nand
= do_imls_nand();
1373 imls
, 1, 1, do_imls
,
1374 "list all images found in flash",
1376 " - Prints information about all images found at sector/block\n"
1377 " boundaries in nor/nand flash."
1381 /*******************************************************************/
1382 /* helper routines */
1383 /*******************************************************************/
1384 #if defined(CONFIG_SILENT_CONSOLE) && !defined(CONFIG_SILENT_U_BOOT_ONLY)
1386 #define CONSOLE_ARG "console="
1387 #define CONSOLE_ARG_LEN (sizeof(CONSOLE_ARG) - 1)
1389 static void fixup_silent_linux(void)
1392 const char *env_val
;
1393 char *cmdline
= getenv("bootargs");
1397 * Only fix cmdline when requested. The environment variable can be:
1399 * no - we never fixup
1400 * yes - we always fixup
1401 * unset - we rely on the console silent flag
1403 want_silent
= getenv_yesno("silent_linux");
1404 if (want_silent
== 0)
1406 else if (want_silent
== -1 && !(gd
->flags
& GD_FLG_SILENT
))
1409 debug("before silent fix-up: %s\n", cmdline
);
1410 if (cmdline
&& (cmdline
[0] != '\0')) {
1411 char *start
= strstr(cmdline
, CONSOLE_ARG
);
1413 /* Allocate space for maximum possible new command line */
1414 buf
= malloc(strlen(cmdline
) + 1 + CONSOLE_ARG_LEN
+ 1);
1416 debug("%s: out of memory\n", __func__
);
1421 char *end
= strchr(start
, ' ');
1422 int num_start_bytes
= start
- cmdline
+ CONSOLE_ARG_LEN
;
1424 strncpy(buf
, cmdline
, num_start_bytes
);
1426 strcpy(buf
+ num_start_bytes
, end
);
1428 buf
[num_start_bytes
] = '\0';
1430 sprintf(buf
, "%s %s", cmdline
, CONSOLE_ARG
);
1435 env_val
= CONSOLE_ARG
;
1438 setenv("bootargs", env_val
);
1439 debug("after silent fix-up: %s\n", env_val
);
1442 #endif /* CONFIG_SILENT_CONSOLE */
1444 #if defined(CONFIG_BOOTM_NETBSD) || defined(CONFIG_BOOTM_PLAN9)
1445 static void copy_args(char *dest
, int argc
, char * const argv
[], char delim
)
1449 for (i
= 0; i
< argc
; i
++) {
1452 strcpy(dest
, argv
[i
]);
1453 dest
+= strlen(argv
[i
]);
1458 /*******************************************************************/
1459 /* OS booting routines */
1460 /*******************************************************************/
1462 #ifdef CONFIG_BOOTM_NETBSD
1463 static int do_bootm_netbsd(int flag
, int argc
, char * const argv
[],
1464 bootm_headers_t
*images
)
1466 void (*loader
)(bd_t
*, image_header_t
*, char *, char *);
1467 image_header_t
*os_hdr
, *hdr
;
1468 ulong kernel_data
, kernel_len
;
1472 if (flag
!= BOOTM_STATE_OS_GO
)
1475 #if defined(CONFIG_FIT)
1476 if (!images
->legacy_hdr_valid
) {
1477 fit_unsupported_reset("NetBSD");
1481 hdr
= images
->legacy_hdr_os
;
1484 * Booting a (NetBSD) kernel image
1486 * This process is pretty similar to a standalone application:
1487 * The (first part of an multi-) image must be a stage-2 loader,
1488 * which in turn is responsible for loading & invoking the actual
1489 * kernel. The only differences are the parameters being passed:
1490 * besides the board info strucure, the loader expects a command
1491 * line, the name of the console device, and (optionally) the
1492 * address of the original image header.
1495 if (image_check_type(&images
->legacy_hdr_os_copy
, IH_TYPE_MULTI
)) {
1496 image_multi_getimg(hdr
, 1, &kernel_data
, &kernel_len
);
1502 #if defined(CONFIG_8xx_CONS_SMC1)
1504 #elif defined(CONFIG_8xx_CONS_SMC2)
1506 #elif defined(CONFIG_8xx_CONS_SCC2)
1508 #elif defined(CONFIG_8xx_CONS_SCC3)
1516 for (i
= 0, len
= 0; i
< argc
; i
+= 1)
1517 len
+= strlen(argv
[i
]) + 1;
1518 cmdline
= malloc(len
);
1519 copy_args(cmdline
, argc
, argv
, ' ');
1520 } else if ((cmdline
= getenv("bootargs")) == NULL
) {
1524 loader
= (void (*)(bd_t
*, image_header_t
*, char *, char *))images
->ep
;
1526 printf("## Transferring control to NetBSD stage-2 loader "
1527 "(at address %08lx) ...\n",
1530 bootstage_mark(BOOTSTAGE_ID_RUN_OS
);
1533 * NetBSD Stage-2 Loader Parameters:
1534 * r3: ptr to board info data
1536 * r5: console device
1537 * r6: boot args string
1539 (*loader
)(gd
->bd
, os_hdr
, consdev
, cmdline
);
1543 #endif /* CONFIG_BOOTM_NETBSD*/
1545 #ifdef CONFIG_LYNXKDI
1546 static int do_bootm_lynxkdi(int flag
, int argc
, char * const argv
[],
1547 bootm_headers_t
*images
)
1549 image_header_t
*hdr
= &images
->legacy_hdr_os_copy
;
1551 if (flag
!= BOOTM_STATE_OS_GO
)
1554 #if defined(CONFIG_FIT)
1555 if (!images
->legacy_hdr_valid
) {
1556 fit_unsupported_reset("Lynx");
1561 lynxkdi_boot((image_header_t
*)hdr
);
1565 #endif /* CONFIG_LYNXKDI */
1567 #ifdef CONFIG_BOOTM_RTEMS
1568 static int do_bootm_rtems(int flag
, int argc
, char * const argv
[],
1569 bootm_headers_t
*images
)
1571 void (*entry_point
)(bd_t
*);
1573 if (flag
!= BOOTM_STATE_OS_GO
)
1576 #if defined(CONFIG_FIT)
1577 if (!images
->legacy_hdr_valid
) {
1578 fit_unsupported_reset("RTEMS");
1583 entry_point
= (void (*)(bd_t
*))images
->ep
;
1585 printf("## Transferring control to RTEMS (at address %08lx) ...\n",
1586 (ulong
)entry_point
);
1588 bootstage_mark(BOOTSTAGE_ID_RUN_OS
);
1592 * r3: ptr to board info data
1594 (*entry_point
)(gd
->bd
);
1598 #endif /* CONFIG_BOOTM_RTEMS */
1600 #if defined(CONFIG_BOOTM_OSE)
1601 static int do_bootm_ose(int flag
, int argc
, char * const argv
[],
1602 bootm_headers_t
*images
)
1604 void (*entry_point
)(void);
1606 if (flag
!= BOOTM_STATE_OS_GO
)
1609 #if defined(CONFIG_FIT)
1610 if (!images
->legacy_hdr_valid
) {
1611 fit_unsupported_reset("OSE");
1616 entry_point
= (void (*)(void))images
->ep
;
1618 printf("## Transferring control to OSE (at address %08lx) ...\n",
1619 (ulong
)entry_point
);
1621 bootstage_mark(BOOTSTAGE_ID_RUN_OS
);
1631 #endif /* CONFIG_BOOTM_OSE */
1633 #if defined(CONFIG_BOOTM_PLAN9)
1634 static int do_bootm_plan9(int flag
, int argc
, char * const argv
[],
1635 bootm_headers_t
*images
)
1637 void (*entry_point
)(void);
1640 if (flag
!= BOOTM_STATE_OS_GO
)
1643 #if defined(CONFIG_FIT)
1644 if (!images
->legacy_hdr_valid
) {
1645 fit_unsupported_reset("Plan 9");
1650 /* See README.plan9 */
1651 s
= getenv("confaddr");
1653 char *confaddr
= (char *)simple_strtoul(s
, NULL
, 16);
1656 copy_args(confaddr
, argc
, argv
, '\n');
1658 s
= getenv("bootargs");
1660 strcpy(confaddr
, s
);
1664 entry_point
= (void (*)(void))images
->ep
;
1666 printf("## Transferring control to Plan 9 (at address %08lx) ...\n",
1667 (ulong
)entry_point
);
1669 bootstage_mark(BOOTSTAGE_ID_RUN_OS
);
1672 * Plan 9 Parameters:
1679 #endif /* CONFIG_BOOTM_PLAN9 */
1681 #if defined(CONFIG_CMD_ELF)
1682 static int do_bootm_vxworks(int flag
, int argc
, char * const argv
[],
1683 bootm_headers_t
*images
)
1687 if (flag
!= BOOTM_STATE_OS_GO
)
1690 #if defined(CONFIG_FIT)
1691 if (!images
->legacy_hdr_valid
) {
1692 fit_unsupported_reset("VxWorks");
1697 sprintf(str
, "%lx", images
->ep
); /* write entry-point into string */
1698 setenv("loadaddr", str
);
1699 do_bootvx(NULL
, 0, 0, NULL
);
1704 static int do_bootm_qnxelf(int flag
, int argc
, char * const argv
[],
1705 bootm_headers_t
*images
)
1707 char *local_args
[2];
1710 if (flag
!= BOOTM_STATE_OS_GO
)
1713 #if defined(CONFIG_FIT)
1714 if (!images
->legacy_hdr_valid
) {
1715 fit_unsupported_reset("QNX");
1720 sprintf(str
, "%lx", images
->ep
); /* write entry-point into string */
1721 local_args
[0] = argv
[0];
1722 local_args
[1] = str
; /* and provide it via the arguments */
1723 do_bootelf(NULL
, 0, 2, local_args
);
1729 #ifdef CONFIG_INTEGRITY
1730 static int do_bootm_integrity(int flag
, int argc
, char * const argv
[],
1731 bootm_headers_t
*images
)
1733 void (*entry_point
)(void);
1735 if (flag
!= BOOTM_STATE_OS_GO
)
1738 #if defined(CONFIG_FIT)
1739 if (!images
->legacy_hdr_valid
) {
1740 fit_unsupported_reset("INTEGRITY");
1745 entry_point
= (void (*)(void))images
->ep
;
1747 printf("## Transferring control to INTEGRITY (at address %08lx) ...\n",
1748 (ulong
)entry_point
);
1750 bootstage_mark(BOOTSTAGE_ID_RUN_OS
);
1753 * INTEGRITY Parameters:
1762 #ifdef CONFIG_CMD_BOOTZ
1764 int __weak
bootz_setup(ulong image
, ulong
*start
, ulong
*end
)
1766 /* Please define bootz_setup() for your platform */
1768 puts("Your platform's zImage format isn't supported yet!\n");
1773 * zImage booting support
1775 static int bootz_start(cmd_tbl_t
*cmdtp
, int flag
, int argc
,
1776 char * const argv
[], bootm_headers_t
*images
)
1779 ulong zi_start
, zi_end
;
1781 ret
= do_bootm_states(cmdtp
, flag
, argc
, argv
, BOOTM_STATE_START
,
1784 /* Setup Linux kernel zImage entry point */
1786 images
->ep
= load_addr
;
1787 debug("* kernel: default image load address = 0x%08lx\n",
1790 images
->ep
= simple_strtoul(argv
[0], NULL
, 16);
1791 debug("* kernel: cmdline image address = 0x%08lx\n",
1795 ret
= bootz_setup(images
->ep
, &zi_start
, &zi_end
);
1799 lmb_reserve(&images
->lmb
, images
->ep
, zi_end
- zi_start
);
1802 * Handle the BOOTM_STATE_FINDOTHER state ourselves as we do not
1803 * have a header that provide this informaiton.
1805 if (bootm_find_ramdisk(flag
, argc
, argv
))
1808 #if defined(CONFIG_OF_LIBFDT)
1809 if (bootm_find_fdt(flag
, argc
, argv
))
1816 int do_bootz(cmd_tbl_t
*cmdtp
, int flag
, int argc
, char * const argv
[])
1820 /* Consume 'bootz' */
1823 if (bootz_start(cmdtp
, flag
, argc
, argv
, &images
))
1827 * We are doing the BOOTM_STATE_LOADOS state ourselves, so must
1828 * disable interrupts ourselves
1830 bootm_disable_interrupts();
1832 images
.os
.os
= IH_OS_LINUX
;
1833 ret
= do_bootm_states(cmdtp
, flag
, argc
, argv
,
1834 BOOTM_STATE_OS_PREP
| BOOTM_STATE_OS_FAKE_GO
|
1841 #ifdef CONFIG_SYS_LONGHELP
1842 static char bootz_help_text
[] =
1843 "[addr [initrd[:size]] [fdt]]\n"
1844 " - boot Linux zImage stored in memory\n"
1845 "\tThe argument 'initrd' is optional and specifies the address\n"
1846 "\tof the initrd in memory. The optional argument ':size' allows\n"
1847 "\tspecifying the size of RAW initrd.\n"
1848 #if defined(CONFIG_OF_LIBFDT)
1849 "\tWhen booting a Linux kernel which requires a flat device-tree\n"
1850 "\ta third argument is required which is the address of the\n"
1851 "\tdevice-tree blob. To boot that kernel without an initrd image,\n"
1852 "\tuse a '-' for the second argument. If you do not pass a third\n"
1853 "\ta bd_info struct will be passed instead\n"
1859 bootz
, CONFIG_SYS_MAXARGS
, 1, do_bootz
,
1860 "boot Linux zImage image from memory", bootz_help_text
1862 #endif /* CONFIG_CMD_BOOTZ */