2 * (C) Copyright 2000-2009
3 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
5 * See file CREDITS for list of people who contributed to this
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License as
10 * published by the Free Software Foundation; either version 2 of
11 * the License, or (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
33 #include <u-boot/zlib.h>
35 #include <environment.h>
37 #include <linux/ctype.h>
38 #include <asm/byteorder.h>
40 #include <linux/compiler.h>
42 #if defined(CONFIG_CMD_USB)
46 #ifdef CONFIG_SYS_HUSH_PARSER
50 #if defined(CONFIG_OF_LIBFDT)
52 #include <fdt_support.h>
56 #include <lzma/LzmaTypes.h>
57 #include <lzma/LzmaDec.h>
58 #include <lzma/LzmaTools.h>
59 #endif /* CONFIG_LZMA */
62 #include <linux/lzo.h>
63 #endif /* CONFIG_LZO */
65 DECLARE_GLOBAL_DATA_PTR
;
67 #ifndef CONFIG_SYS_BOOTM_LEN
68 #define CONFIG_SYS_BOOTM_LEN 0x800000 /* use 8MByte as default max gunzip size */
72 extern void bz_internal_error(int);
75 #if defined(CONFIG_CMD_IMI)
76 static int image_info(unsigned long addr
);
79 #if defined(CONFIG_CMD_IMLS)
81 #include <mtd/cfi_flash.h>
82 extern flash_info_t flash_info
[]; /* info for FLASH chips */
85 #if defined(CONFIG_CMD_IMLS) || defined(CONFIG_CMD_IMLS_NAND)
86 static int do_imls(cmd_tbl_t
*cmdtp
, int flag
, int argc
, char * const argv
[]);
89 #include <linux/err.h>
92 #if defined(CONFIG_SILENT_CONSOLE) && !defined(CONFIG_SILENT_U_BOOT_ONLY)
93 static void fixup_silent_linux(void);
96 static image_header_t
*image_get_kernel(ulong img_addr
, int verify
);
97 #if defined(CONFIG_FIT)
98 static int fit_check_kernel(const void *fit
, int os_noffset
, int verify
);
101 static const void *boot_get_kernel(cmd_tbl_t
*cmdtp
, int flag
, int argc
,
102 char * const argv
[], bootm_headers_t
*images
,
103 ulong
*os_data
, ulong
*os_len
);
106 * Continue booting an OS image; caller already has:
107 * - copied image header to global variable `header'
108 * - checked header magic number, checksums (both header & image),
109 * - verified image architecture (PPC) and type (KERNEL or MULTI),
110 * - loaded (first part of) image to header load address,
111 * - disabled interrupts.
113 typedef int boot_os_fn(int flag
, int argc
, char * const argv
[],
114 bootm_headers_t
*images
); /* pointers to os/initrd/fdt */
116 #ifdef CONFIG_BOOTM_LINUX
117 extern boot_os_fn do_bootm_linux
;
119 #ifdef CONFIG_BOOTM_NETBSD
120 static boot_os_fn do_bootm_netbsd
;
122 #if defined(CONFIG_LYNXKDI)
123 static boot_os_fn do_bootm_lynxkdi
;
124 extern void lynxkdi_boot(image_header_t
*);
126 #ifdef CONFIG_BOOTM_RTEMS
127 static boot_os_fn do_bootm_rtems
;
129 #if defined(CONFIG_BOOTM_OSE)
130 static boot_os_fn do_bootm_ose
;
132 #if defined(CONFIG_BOOTM_PLAN9)
133 static boot_os_fn do_bootm_plan9
;
135 #if defined(CONFIG_CMD_ELF)
136 static boot_os_fn do_bootm_vxworks
;
137 static boot_os_fn do_bootm_qnxelf
;
138 int do_bootvx(cmd_tbl_t
*cmdtp
, int flag
, int argc
, char * const argv
[]);
139 int do_bootelf(cmd_tbl_t
*cmdtp
, int flag
, int argc
, char * const argv
[]);
141 #if defined(CONFIG_INTEGRITY)
142 static boot_os_fn do_bootm_integrity
;
145 static boot_os_fn
*boot_os
[] = {
146 #ifdef CONFIG_BOOTM_LINUX
147 [IH_OS_LINUX
] = do_bootm_linux
,
149 #ifdef CONFIG_BOOTM_NETBSD
150 [IH_OS_NETBSD
] = do_bootm_netbsd
,
152 #ifdef CONFIG_LYNXKDI
153 [IH_OS_LYNXOS
] = do_bootm_lynxkdi
,
155 #ifdef CONFIG_BOOTM_RTEMS
156 [IH_OS_RTEMS
] = do_bootm_rtems
,
158 #if defined(CONFIG_BOOTM_OSE)
159 [IH_OS_OSE
] = do_bootm_ose
,
161 #if defined(CONFIG_BOOTM_PLAN9)
162 [IH_OS_PLAN9
] = do_bootm_plan9
,
164 #if defined(CONFIG_CMD_ELF)
165 [IH_OS_VXWORKS
] = do_bootm_vxworks
,
166 [IH_OS_QNX
] = do_bootm_qnxelf
,
168 #ifdef CONFIG_INTEGRITY
169 [IH_OS_INTEGRITY
] = do_bootm_integrity
,
173 bootm_headers_t images
; /* pointers to os/initrd/fdt images */
175 /* Allow for arch specific config before we boot */
176 static void __arch_preboot_os(void)
178 /* please define platform specific arch_preboot_os() */
180 void arch_preboot_os(void) __attribute__((weak
, alias("__arch_preboot_os")));
182 #define IH_INITRD_ARCH IH_ARCH_DEFAULT
185 static void boot_start_lmb(bootm_headers_t
*images
)
188 phys_size_t mem_size
;
190 lmb_init(&images
->lmb
);
192 mem_start
= getenv_bootm_low();
193 mem_size
= getenv_bootm_size();
195 lmb_add(&images
->lmb
, (phys_addr_t
)mem_start
, mem_size
);
197 arch_lmb_reserve(&images
->lmb
);
198 board_lmb_reserve(&images
->lmb
);
201 #define lmb_reserve(lmb, base, size)
202 static inline void boot_start_lmb(bootm_headers_t
*images
) { }
205 static int bootm_start(cmd_tbl_t
*cmdtp
, int flag
, int argc
, char * const argv
[])
210 memset((void *)&images
, 0, sizeof(images
));
211 images
.verify
= getenv_yesno("verify");
213 boot_start_lmb(&images
);
215 bootstage_mark_name(BOOTSTAGE_ID_BOOTM_START
, "bootm_start");
217 /* get kernel image header, start address and length */
218 os_hdr
= boot_get_kernel(cmdtp
, flag
, argc
, argv
,
219 &images
, &images
.os
.image_start
, &images
.os
.image_len
);
220 if (images
.os
.image_len
== 0) {
221 puts("ERROR: can't get kernel image!\n");
225 /* get image parameters */
226 switch (genimg_get_format(os_hdr
)) {
227 case IMAGE_FORMAT_LEGACY
:
228 images
.os
.type
= image_get_type(os_hdr
);
229 images
.os
.comp
= image_get_comp(os_hdr
);
230 images
.os
.os
= image_get_os(os_hdr
);
232 images
.os
.end
= image_get_image_end(os_hdr
);
233 images
.os
.load
= image_get_load(os_hdr
);
235 #if defined(CONFIG_FIT)
236 case IMAGE_FORMAT_FIT
:
237 if (fit_image_get_type(images
.fit_hdr_os
,
238 images
.fit_noffset_os
, &images
.os
.type
)) {
239 puts("Can't get image type!\n");
240 bootstage_error(BOOTSTAGE_ID_FIT_TYPE
);
244 if (fit_image_get_comp(images
.fit_hdr_os
,
245 images
.fit_noffset_os
, &images
.os
.comp
)) {
246 puts("Can't get image compression!\n");
247 bootstage_error(BOOTSTAGE_ID_FIT_COMPRESSION
);
251 if (fit_image_get_os(images
.fit_hdr_os
,
252 images
.fit_noffset_os
, &images
.os
.os
)) {
253 puts("Can't get image OS!\n");
254 bootstage_error(BOOTSTAGE_ID_FIT_OS
);
258 images
.os
.end
= fit_get_end(images
.fit_hdr_os
);
260 if (fit_image_get_load(images
.fit_hdr_os
, images
.fit_noffset_os
,
262 puts("Can't get image load address!\n");
263 bootstage_error(BOOTSTAGE_ID_FIT_LOADADDR
);
269 puts("ERROR: unknown image format type!\n");
273 /* find kernel entry point */
274 if (images
.legacy_hdr_valid
) {
275 images
.ep
= image_get_ep(&images
.legacy_hdr_os_copy
);
276 #if defined(CONFIG_FIT)
277 } else if (images
.fit_uname_os
) {
278 ret
= fit_image_get_entry(images
.fit_hdr_os
,
279 images
.fit_noffset_os
, &images
.ep
);
281 puts("Can't get entry point property!\n");
286 puts("Could not find kernel entry point!\n");
290 if (images
.os
.type
== IH_TYPE_KERNEL_NOLOAD
) {
291 images
.os
.load
= images
.os
.image_start
;
292 images
.ep
+= images
.os
.load
;
295 if (((images
.os
.type
== IH_TYPE_KERNEL
) ||
296 (images
.os
.type
== IH_TYPE_KERNEL_NOLOAD
) ||
297 (images
.os
.type
== IH_TYPE_MULTI
)) &&
298 (images
.os
.os
== IH_OS_LINUX
)) {
300 ret
= boot_get_ramdisk(argc
, argv
, &images
, IH_INITRD_ARCH
,
301 &images
.rd_start
, &images
.rd_end
);
303 puts("Ramdisk image is corrupt or invalid\n");
307 #if defined(CONFIG_OF_LIBFDT)
308 /* find flattened device tree */
309 ret
= boot_get_fdt(flag
, argc
, argv
, &images
,
310 &images
.ft_addr
, &images
.ft_len
);
312 puts("Could not find a valid device tree\n");
316 set_working_fdt_addr(images
.ft_addr
);
320 images
.os
.start
= (ulong
)os_hdr
;
321 images
.state
= BOOTM_STATE_START
;
326 #define BOOTM_ERR_RESET -1
327 #define BOOTM_ERR_OVERLAP -2
328 #define BOOTM_ERR_UNIMPLEMENTED -3
329 static int bootm_load_os(image_info_t os
, ulong
*load_end
, int boot_progress
)
331 uint8_t comp
= os
.comp
;
332 ulong load
= os
.load
;
333 ulong blob_start
= os
.start
;
334 ulong blob_end
= os
.end
;
335 ulong image_start
= os
.image_start
;
336 ulong image_len
= os
.image_len
;
337 __maybe_unused uint unc_len
= CONFIG_SYS_BOOTM_LEN
;
339 #if defined(CONFIG_LZMA) || defined(CONFIG_LZO)
341 #endif /* defined(CONFIG_LZMA) || defined(CONFIG_LZO) */
343 const char *type_name
= genimg_get_type_name(os
.type
);
347 if (load
== blob_start
|| load
== image_start
) {
348 printf(" XIP %s ... ", type_name
);
351 printf(" Loading %s ... ", type_name
);
352 memmove_wd((void *)load
, (void *)image_start
,
355 *load_end
= load
+ image_len
;
360 printf(" Uncompressing %s ... ", type_name
);
361 if (gunzip((void *)load
, unc_len
,
362 (uchar
*)image_start
, &image_len
) != 0) {
363 puts("GUNZIP: uncompress, out-of-mem or overwrite "
364 "error - must RESET board to recover\n");
366 bootstage_error(BOOTSTAGE_ID_DECOMP_IMAGE
);
367 return BOOTM_ERR_RESET
;
370 *load_end
= load
+ image_len
;
372 #endif /* CONFIG_GZIP */
375 printf(" Uncompressing %s ... ", type_name
);
377 * If we've got less than 4 MB of malloc() space,
378 * use slower decompression algorithm which requires
379 * at most 2300 KB of memory.
381 int i
= BZ2_bzBuffToBuffDecompress((char *)load
,
382 &unc_len
, (char *)image_start
, image_len
,
383 CONFIG_SYS_MALLOC_LEN
< (4096 * 1024), 0);
385 printf("BUNZIP2: uncompress or overwrite error %d "
386 "- must RESET board to recover\n", i
);
388 bootstage_error(BOOTSTAGE_ID_DECOMP_IMAGE
);
389 return BOOTM_ERR_RESET
;
392 *load_end
= load
+ unc_len
;
394 #endif /* CONFIG_BZIP2 */
397 SizeT lzma_len
= unc_len
;
398 printf(" Uncompressing %s ... ", type_name
);
400 ret
= lzmaBuffToBuffDecompress(
401 (unsigned char *)load
, &lzma_len
,
402 (unsigned char *)image_start
, image_len
);
405 printf("LZMA: uncompress or overwrite error %d "
406 "- must RESET board to recover\n", ret
);
407 bootstage_error(BOOTSTAGE_ID_DECOMP_IMAGE
);
408 return BOOTM_ERR_RESET
;
410 *load_end
= load
+ unc_len
;
413 #endif /* CONFIG_LZMA */
416 printf(" Uncompressing %s ... ", type_name
);
418 ret
= lzop_decompress((const unsigned char *)image_start
,
419 image_len
, (unsigned char *)load
,
421 if (ret
!= LZO_E_OK
) {
422 printf("LZO: uncompress or overwrite error %d "
423 "- must RESET board to recover\n", ret
);
425 bootstage_error(BOOTSTAGE_ID_DECOMP_IMAGE
);
426 return BOOTM_ERR_RESET
;
429 *load_end
= load
+ unc_len
;
431 #endif /* CONFIG_LZO */
433 printf("Unimplemented compression type %d\n", comp
);
434 return BOOTM_ERR_UNIMPLEMENTED
;
437 flush_cache(load
, (*load_end
- load
) * sizeof(ulong
));
440 debug(" kernel loaded at 0x%08lx, end = 0x%08lx\n", load
, *load_end
);
441 bootstage_mark(BOOTSTAGE_ID_KERNEL_LOADED
);
443 if (!no_overlap
&& (load
< blob_end
) && (*load_end
> blob_start
)) {
444 debug("images.os.start = 0x%lX, images.os.end = 0x%lx\n",
445 blob_start
, blob_end
);
446 debug("images.os.load = 0x%lx, load_end = 0x%lx\n", load
,
449 return BOOTM_ERR_OVERLAP
;
455 static int bootm_start_standalone(ulong iflag
, int argc
, char * const argv
[])
458 int (*appl
)(int, char * const []);
460 /* Don't start if "autostart" is set to "no" */
461 if (((s
= getenv("autostart")) != NULL
) && (strcmp(s
, "no") == 0)) {
462 setenv_hex("filesize", images
.os
.image_len
);
465 appl
= (int (*)(int, char * const []))(ulong
)ntohl(images
.ep
);
466 (*appl
)(argc
-1, &argv
[1]);
470 /* we overload the cmd field with our state machine info instead of a
471 * function pointer */
472 static cmd_tbl_t cmd_bootm_sub
[] = {
473 U_BOOT_CMD_MKENT(start
, 0, 1, (void *)BOOTM_STATE_START
, "", ""),
474 U_BOOT_CMD_MKENT(loados
, 0, 1, (void *)BOOTM_STATE_LOADOS
, "", ""),
475 #ifdef CONFIG_SYS_BOOT_RAMDISK_HIGH
476 U_BOOT_CMD_MKENT(ramdisk
, 0, 1, (void *)BOOTM_STATE_RAMDISK
, "", ""),
478 #ifdef CONFIG_OF_LIBFDT
479 U_BOOT_CMD_MKENT(fdt
, 0, 1, (void *)BOOTM_STATE_FDT
, "", ""),
481 U_BOOT_CMD_MKENT(cmdline
, 0, 1, (void *)BOOTM_STATE_OS_CMDLINE
, "", ""),
482 U_BOOT_CMD_MKENT(bdt
, 0, 1, (void *)BOOTM_STATE_OS_BD_T
, "", ""),
483 U_BOOT_CMD_MKENT(prep
, 0, 1, (void *)BOOTM_STATE_OS_PREP
, "", ""),
484 U_BOOT_CMD_MKENT(go
, 0, 1, (void *)BOOTM_STATE_OS_GO
, "", ""),
487 static int do_bootm_subcommand(cmd_tbl_t
*cmdtp
, int flag
, int argc
,
495 c
= find_cmd_tbl(argv
[1], &cmd_bootm_sub
[0], ARRAY_SIZE(cmd_bootm_sub
));
498 state
= (long)c
->cmd
;
500 /* treat start special since it resets the state machine */
501 if (state
== BOOTM_STATE_START
) {
504 return bootm_start(cmdtp
, flag
, argc
, argv
);
507 /* Unrecognized command */
508 return CMD_RET_USAGE
;
511 if (images
.state
< BOOTM_STATE_START
||
512 images
.state
>= state
) {
513 printf("Trying to execute a command out of order\n");
514 return CMD_RET_USAGE
;
517 images
.state
|= state
;
518 boot_fn
= boot_os
[images
.os
.os
];
522 case BOOTM_STATE_START
:
523 /* should never occur */
525 case BOOTM_STATE_LOADOS
:
526 ret
= bootm_load_os(images
.os
, &load_end
, 0);
530 lmb_reserve(&images
.lmb
, images
.os
.load
,
531 (load_end
- images
.os
.load
));
533 #ifdef CONFIG_SYS_BOOT_RAMDISK_HIGH
534 case BOOTM_STATE_RAMDISK
:
536 ulong rd_len
= images
.rd_end
- images
.rd_start
;
538 ret
= boot_ramdisk_high(&images
.lmb
, images
.rd_start
,
539 rd_len
, &images
.initrd_start
, &images
.initrd_end
);
543 setenv_hex("initrd_start", images
.initrd_start
);
544 setenv_hex("initrd_end", images
.initrd_end
);
548 #if defined(CONFIG_OF_LIBFDT) && defined(CONFIG_LMB)
549 case BOOTM_STATE_FDT
:
551 boot_fdt_add_mem_rsv_regions(&images
.lmb
,
553 ret
= boot_relocate_fdt(&images
.lmb
,
554 &images
.ft_addr
, &images
.ft_len
);
558 case BOOTM_STATE_OS_CMDLINE
:
559 ret
= boot_fn(BOOTM_STATE_OS_CMDLINE
, argc
, argv
, &images
);
561 printf("cmdline subcommand not supported\n");
563 case BOOTM_STATE_OS_BD_T
:
564 ret
= boot_fn(BOOTM_STATE_OS_BD_T
, argc
, argv
, &images
);
566 printf("bdt subcommand not supported\n");
568 case BOOTM_STATE_OS_PREP
:
569 ret
= boot_fn(BOOTM_STATE_OS_PREP
, argc
, argv
, &images
);
571 printf("prep subcommand not supported\n");
573 case BOOTM_STATE_OS_GO
:
574 disable_interrupts();
575 #ifdef CONFIG_NETCONSOLE
577 * Stop the ethernet stack if NetConsole could have
583 boot_fn(BOOTM_STATE_OS_GO
, argc
, argv
, &images
);
590 /*******************************************************************/
591 /* bootm - boot application image from image in memory */
592 /*******************************************************************/
594 int do_bootm(cmd_tbl_t
*cmdtp
, int flag
, int argc
, char * const argv
[])
600 #ifdef CONFIG_NEEDS_MANUAL_RELOC
601 static int relocated
= 0;
606 /* relocate boot function table */
607 for (i
= 0; i
< ARRAY_SIZE(boot_os
); i
++)
608 if (boot_os
[i
] != NULL
)
609 boot_os
[i
] += gd
->reloc_off
;
611 /* relocate names of sub-command table */
612 for (i
= 0; i
< ARRAY_SIZE(cmd_bootm_sub
); i
++)
613 cmd_bootm_sub
[i
].name
+= gd
->reloc_off
;
619 /* determine if we have a sub command */
623 simple_strtoul(argv
[1], &endp
, 16);
624 /* endp pointing to NULL means that argv[1] was just a
625 * valid number, pass it along to the normal bootm processing
627 * If endp is ':' or '#' assume a FIT identifier so pass
628 * along for normal processing.
630 * Right now we assume the first arg should never be '-'
632 if ((*endp
!= 0) && (*endp
!= ':') && (*endp
!= '#'))
633 return do_bootm_subcommand(cmdtp
, flag
, argc
, argv
);
636 if (bootm_start(cmdtp
, flag
, argc
, argv
))
640 * We have reached the point of no return: we are going to
641 * overwrite all exception vector code, so we cannot easily
642 * recover from any failures any more...
644 iflag
= disable_interrupts();
646 #ifdef CONFIG_NETCONSOLE
647 /* Stop the ethernet stack if NetConsole could have left it up */
651 #if defined(CONFIG_CMD_USB)
653 * turn off USB to prevent the host controller from writing to the
654 * SDRAM while Linux is booting. This could happen (at least for OHCI
655 * controller), because the HCCA (Host Controller Communication Area)
656 * lies within the SDRAM and the host controller writes continously to
657 * this area (as busmaster!). The HccaFrameNumber is for example
658 * updated every 1 ms within the HCCA structure in SDRAM! For more
659 * details see the OpenHCI specification.
664 ret
= bootm_load_os(images
.os
, &load_end
, 1);
667 if (ret
== BOOTM_ERR_RESET
)
668 do_reset(cmdtp
, flag
, argc
, argv
);
669 if (ret
== BOOTM_ERR_OVERLAP
) {
670 if (images
.legacy_hdr_valid
) {
672 hdr
= &images
.legacy_hdr_os_copy
;
673 if (image_get_type(hdr
) == IH_TYPE_MULTI
)
674 puts("WARNING: legacy format multi "
678 puts("ERROR: new format image overwritten - "
679 "must RESET the board to recover\n");
680 bootstage_error(BOOTSTAGE_ID_OVERWRITTEN
);
681 do_reset(cmdtp
, flag
, argc
, argv
);
684 if (ret
== BOOTM_ERR_UNIMPLEMENTED
) {
687 bootstage_error(BOOTSTAGE_ID_DECOMP_UNIMPL
);
692 lmb_reserve(&images
.lmb
, images
.os
.load
, (load_end
- images
.os
.load
));
694 if (images
.os
.type
== IH_TYPE_STANDALONE
) {
697 /* This may return when 'autostart' is 'no' */
698 bootm_start_standalone(iflag
, argc
, argv
);
702 bootstage_mark(BOOTSTAGE_ID_CHECK_BOOT_OS
);
704 #if defined(CONFIG_SILENT_CONSOLE) && !defined(CONFIG_SILENT_U_BOOT_ONLY)
705 if (images
.os
.os
== IH_OS_LINUX
)
706 fixup_silent_linux();
709 boot_fn
= boot_os
[images
.os
.os
];
711 if (boot_fn
== NULL
) {
714 printf("ERROR: booting os '%s' (%d) is not supported\n",
715 genimg_get_os_name(images
.os
.os
), images
.os
.os
);
716 bootstage_error(BOOTSTAGE_ID_CHECK_BOOT_OS
);
722 boot_fn(0, argc
, argv
, &images
);
724 bootstage_error(BOOTSTAGE_ID_BOOT_OS_RETURNED
);
726 puts("\n## Control returned to monitor - resetting...\n");
728 do_reset(cmdtp
, flag
, argc
, argv
);
733 int bootm_maybe_autostart(cmd_tbl_t
*cmdtp
, const char *cmd
)
735 const char *ep
= getenv("autostart");
737 if (ep
&& !strcmp(ep
, "yes")) {
739 local_args
[0] = (char *)cmd
;
740 local_args
[1] = NULL
;
741 printf("Automatic boot of image at addr 0x%08lX ...\n", load_addr
);
742 return do_bootm(cmdtp
, 0, 1, local_args
);
749 * image_get_kernel - verify legacy format kernel image
750 * @img_addr: in RAM address of the legacy format image to be verified
751 * @verify: data CRC verification flag
753 * image_get_kernel() verifies legacy image integrity and returns pointer to
754 * legacy image header if image verification was completed successfully.
757 * pointer to a legacy image header if valid image was found
758 * otherwise return NULL
760 static image_header_t
*image_get_kernel(ulong img_addr
, int verify
)
762 image_header_t
*hdr
= (image_header_t
*)img_addr
;
764 if (!image_check_magic(hdr
)) {
765 puts("Bad Magic Number\n");
766 bootstage_error(BOOTSTAGE_ID_CHECK_MAGIC
);
769 bootstage_mark(BOOTSTAGE_ID_CHECK_HEADER
);
771 if (!image_check_hcrc(hdr
)) {
772 puts("Bad Header Checksum\n");
773 bootstage_error(BOOTSTAGE_ID_CHECK_HEADER
);
777 bootstage_mark(BOOTSTAGE_ID_CHECK_CHECKSUM
);
778 image_print_contents(hdr
);
781 puts(" Verifying Checksum ... ");
782 if (!image_check_dcrc(hdr
)) {
783 printf("Bad Data CRC\n");
784 bootstage_error(BOOTSTAGE_ID_CHECK_CHECKSUM
);
789 bootstage_mark(BOOTSTAGE_ID_CHECK_ARCH
);
791 if (!image_check_target_arch(hdr
)) {
792 printf("Unsupported Architecture 0x%x\n", image_get_arch(hdr
));
793 bootstage_error(BOOTSTAGE_ID_CHECK_ARCH
);
800 * fit_check_kernel - verify FIT format kernel subimage
801 * @fit_hdr: pointer to the FIT image header
802 * os_noffset: kernel subimage node offset within FIT image
803 * @verify: data CRC verification flag
805 * fit_check_kernel() verifies integrity of the kernel subimage and from
806 * specified FIT image.
812 #if defined(CONFIG_FIT)
813 static int fit_check_kernel(const void *fit
, int os_noffset
, int verify
)
815 fit_image_print(fit
, os_noffset
, " ");
818 puts(" Verifying Hash Integrity ... ");
819 if (!fit_image_verify(fit
, os_noffset
)) {
820 puts("Bad Data Hash\n");
821 bootstage_error(BOOTSTAGE_ID_FIT_CHECK_HASH
);
826 bootstage_mark(BOOTSTAGE_ID_FIT_CHECK_ARCH
);
828 if (!fit_image_check_target_arch(fit
, os_noffset
)) {
829 puts("Unsupported Architecture\n");
830 bootstage_error(BOOTSTAGE_ID_FIT_CHECK_ARCH
);
834 bootstage_mark(BOOTSTAGE_ID_FIT_CHECK_KERNEL
);
835 if (!fit_image_check_type(fit
, os_noffset
, IH_TYPE_KERNEL
) &&
836 !fit_image_check_type(fit
, os_noffset
, IH_TYPE_KERNEL_NOLOAD
)) {
837 puts("Not a kernel image\n");
838 bootstage_error(BOOTSTAGE_ID_FIT_CHECK_KERNEL
);
842 bootstage_mark(BOOTSTAGE_ID_FIT_CHECKED
);
845 #endif /* CONFIG_FIT */
848 * boot_get_kernel - find kernel image
849 * @os_data: pointer to a ulong variable, will hold os data start address
850 * @os_len: pointer to a ulong variable, will hold os data length
852 * boot_get_kernel() tries to find a kernel image, verifies its integrity
853 * and locates kernel data.
856 * pointer to image header if valid image was found, plus kernel start
857 * address and length, otherwise NULL
859 static const void *boot_get_kernel(cmd_tbl_t
*cmdtp
, int flag
, int argc
,
860 char * const argv
[], bootm_headers_t
*images
, ulong
*os_data
,
866 #if defined(CONFIG_FIT)
868 const char *fit_uname_config
= NULL
;
869 const char *fit_uname_kernel
= NULL
;
876 /* find out kernel image address */
878 img_addr
= load_addr
;
879 debug("* kernel: default image load address = 0x%08lx\n",
881 #if defined(CONFIG_FIT)
882 } else if (fit_parse_conf(argv
[1], load_addr
, &img_addr
,
883 &fit_uname_config
)) {
884 debug("* kernel: config '%s' from image at 0x%08lx\n",
885 fit_uname_config
, img_addr
);
886 } else if (fit_parse_subimage(argv
[1], load_addr
, &img_addr
,
887 &fit_uname_kernel
)) {
888 debug("* kernel: subimage '%s' from image at 0x%08lx\n",
889 fit_uname_kernel
, img_addr
);
892 img_addr
= simple_strtoul(argv
[1], NULL
, 16);
893 debug("* kernel: cmdline image address = 0x%08lx\n", img_addr
);
896 bootstage_mark(BOOTSTAGE_ID_CHECK_MAGIC
);
898 /* copy from dataflash if needed */
899 img_addr
= genimg_get_image(img_addr
);
901 /* check image type, for FIT images get FIT kernel node */
902 *os_data
= *os_len
= 0;
903 buf
= map_sysmem(img_addr
, 0);
904 switch (genimg_get_format(buf
)) {
905 case IMAGE_FORMAT_LEGACY
:
906 printf("## Booting kernel from Legacy Image at %08lx ...\n",
908 hdr
= image_get_kernel(img_addr
, images
->verify
);
911 bootstage_mark(BOOTSTAGE_ID_CHECK_IMAGETYPE
);
913 /* get os_data and os_len */
914 switch (image_get_type(hdr
)) {
916 case IH_TYPE_KERNEL_NOLOAD
:
917 *os_data
= image_get_data(hdr
);
918 *os_len
= image_get_data_size(hdr
);
921 image_multi_getimg(hdr
, 0, os_data
, os_len
);
923 case IH_TYPE_STANDALONE
:
924 *os_data
= image_get_data(hdr
);
925 *os_len
= image_get_data_size(hdr
);
928 printf("Wrong Image Type for %s command\n",
930 bootstage_error(BOOTSTAGE_ID_CHECK_IMAGETYPE
);
935 * copy image header to allow for image overwrites during
936 * kernel decompression.
938 memmove(&images
->legacy_hdr_os_copy
, hdr
,
939 sizeof(image_header_t
));
941 /* save pointer to image header */
942 images
->legacy_hdr_os
= hdr
;
944 images
->legacy_hdr_valid
= 1;
945 bootstage_mark(BOOTSTAGE_ID_DECOMP_IMAGE
);
947 #if defined(CONFIG_FIT)
948 case IMAGE_FORMAT_FIT
:
950 printf("## Booting kernel from FIT Image at %08lx ...\n",
953 if (!fit_check_format(fit_hdr
)) {
954 puts("Bad FIT kernel image format!\n");
955 bootstage_error(BOOTSTAGE_ID_FIT_FORMAT
);
958 bootstage_mark(BOOTSTAGE_ID_FIT_FORMAT
);
960 if (!fit_uname_kernel
) {
962 * no kernel image node unit name, try to get config
963 * node first. If config unit node name is NULL
964 * fit_conf_get_node() will try to find default config
967 bootstage_mark(BOOTSTAGE_ID_FIT_NO_UNIT_NAME
);
968 #ifdef CONFIG_FIT_BEST_MATCH
969 if (fit_uname_config
)
971 fit_conf_get_node(fit_hdr
,
975 fit_conf_find_compat(fit_hdr
,
978 cfg_noffset
= fit_conf_get_node(fit_hdr
,
981 if (cfg_noffset
< 0) {
982 bootstage_error(BOOTSTAGE_ID_FIT_NO_UNIT_NAME
);
985 /* save configuration uname provided in the first
988 images
->fit_uname_cfg
= fdt_get_name(fit_hdr
,
991 printf(" Using '%s' configuration\n",
992 images
->fit_uname_cfg
);
993 bootstage_mark(BOOTSTAGE_ID_FIT_CONFIG
);
995 os_noffset
= fit_conf_get_kernel_node(fit_hdr
,
997 fit_uname_kernel
= fit_get_name(fit_hdr
, os_noffset
,
1000 /* get kernel component image node offset */
1001 bootstage_mark(BOOTSTAGE_ID_FIT_UNIT_NAME
);
1002 os_noffset
= fit_image_get_node(fit_hdr
,
1005 if (os_noffset
< 0) {
1006 bootstage_error(BOOTSTAGE_ID_FIT_CONFIG
);
1010 printf(" Trying '%s' kernel subimage\n", fit_uname_kernel
);
1012 bootstage_mark(BOOTSTAGE_ID_FIT_CHECK_SUBIMAGE
);
1013 if (!fit_check_kernel(fit_hdr
, os_noffset
, images
->verify
))
1016 /* get kernel image data address and length */
1017 if (fit_image_get_data(fit_hdr
, os_noffset
, &data
, &len
)) {
1018 puts("Could not find kernel subimage data!\n");
1019 bootstage_error(BOOTSTAGE_ID_FIT_KERNEL_INFO_ERR
);
1022 bootstage_mark(BOOTSTAGE_ID_FIT_KERNEL_INFO
);
1025 *os_data
= (ulong
)data
;
1026 images
->fit_hdr_os
= (void *)fit_hdr
;
1027 images
->fit_uname_os
= fit_uname_kernel
;
1028 images
->fit_noffset_os
= os_noffset
;
1032 printf("Wrong Image Format for %s command\n", cmdtp
->name
);
1033 bootstage_error(BOOTSTAGE_ID_FIT_KERNEL_INFO
);
1037 debug(" kernel data at 0x%08lx, len = 0x%08lx (%ld)\n",
1038 *os_data
, *os_len
, *os_len
);
1043 #ifdef CONFIG_SYS_LONGHELP
1044 static char bootm_help_text
[] =
1045 "[addr [arg ...]]\n - boot application image stored in memory\n"
1046 "\tpassing arguments 'arg ...'; when booting a Linux kernel,\n"
1047 "\t'arg' can be the address of an initrd image\n"
1048 #if defined(CONFIG_OF_LIBFDT)
1049 "\tWhen booting a Linux kernel which requires a flat device-tree\n"
1050 "\ta third argument is required which is the address of the\n"
1051 "\tdevice-tree blob. To boot that kernel without an initrd image,\n"
1052 "\tuse a '-' for the second argument. If you do not pass a third\n"
1053 "\ta bd_info struct will be passed instead\n"
1055 #if defined(CONFIG_FIT)
1056 "\t\nFor the new multi component uImage format (FIT) addresses\n"
1057 "\tmust be extened to include component or configuration unit name:\n"
1058 "\taddr:<subimg_uname> - direct component image specification\n"
1059 "\taddr#<conf_uname> - configuration specification\n"
1060 "\tUse iminfo command to get the list of existing component\n"
1061 "\timages and configurations.\n"
1063 "\nSub-commands to do part of the bootm sequence. The sub-commands "
1065 "issued in the order below (it's ok to not issue all sub-commands):\n"
1066 "\tstart [addr [arg ...]]\n"
1067 "\tloados - load OS image\n"
1068 #if defined(CONFIG_SYS_BOOT_RAMDISK_HIGH)
1069 "\tramdisk - relocate initrd, set env initrd_start/initrd_end\n"
1071 #if defined(CONFIG_OF_LIBFDT)
1072 "\tfdt - relocate flat device tree\n"
1074 "\tcmdline - OS specific command line processing/setup\n"
1075 "\tbdt - OS specific bd_t processing\n"
1076 "\tprep - OS specific prep before relocation or go\n"
1081 bootm
, CONFIG_SYS_MAXARGS
, 1, do_bootm
,
1082 "boot application image from memory", bootm_help_text
1085 /*******************************************************************/
1086 /* bootd - boot default image */
1087 /*******************************************************************/
1088 #if defined(CONFIG_CMD_BOOTD)
1089 int do_bootd(cmd_tbl_t
*cmdtp
, int flag
, int argc
, char * const argv
[])
1093 if (run_command(getenv("bootcmd"), flag
) < 0)
1099 boot
, 1, 1, do_bootd
,
1100 "boot default, i.e., run 'bootcmd'",
1104 /* keep old command name "bootd" for backward compatibility */
1106 bootd
, 1, 1, do_bootd
,
1107 "boot default, i.e., run 'bootcmd'",
1114 /*******************************************************************/
1115 /* iminfo - print header info for a requested image */
1116 /*******************************************************************/
1117 #if defined(CONFIG_CMD_IMI)
1118 static int do_iminfo(cmd_tbl_t
*cmdtp
, int flag
, int argc
, char * const argv
[])
1125 return image_info(load_addr
);
1128 for (arg
= 1; arg
< argc
; ++arg
) {
1129 addr
= simple_strtoul(argv
[arg
], NULL
, 16);
1130 if (image_info(addr
) != 0)
1136 static int image_info(ulong addr
)
1138 void *hdr
= (void *)addr
;
1140 printf("\n## Checking Image at %08lx ...\n", addr
);
1142 switch (genimg_get_format(hdr
)) {
1143 case IMAGE_FORMAT_LEGACY
:
1144 puts(" Legacy image found\n");
1145 if (!image_check_magic(hdr
)) {
1146 puts(" Bad Magic Number\n");
1150 if (!image_check_hcrc(hdr
)) {
1151 puts(" Bad Header Checksum\n");
1155 image_print_contents(hdr
);
1157 puts(" Verifying Checksum ... ");
1158 if (!image_check_dcrc(hdr
)) {
1159 puts(" Bad Data CRC\n");
1164 #if defined(CONFIG_FIT)
1165 case IMAGE_FORMAT_FIT
:
1166 puts(" FIT image found\n");
1168 if (!fit_check_format(hdr
)) {
1169 puts("Bad FIT image format!\n");
1173 fit_print_contents(hdr
);
1175 if (!fit_all_image_verify(hdr
)) {
1176 puts("Bad hash in FIT image!\n");
1183 puts("Unknown image format!\n");
1191 iminfo
, CONFIG_SYS_MAXARGS
, 1, do_iminfo
,
1192 "print header information for application image",
1194 " - print header information for application image starting at\n"
1195 " address 'addr' in memory; this includes verification of the\n"
1196 " image contents (magic number, header and payload checksums)"
1201 /*******************************************************************/
1202 /* imls - list all images found in flash */
1203 /*******************************************************************/
1204 #if defined(CONFIG_CMD_IMLS)
1205 static int do_imls_nor(void)
1211 for (i
= 0, info
= &flash_info
[0];
1212 i
< CONFIG_SYS_MAX_FLASH_BANKS
; ++i
, ++info
) {
1214 if (info
->flash_id
== FLASH_UNKNOWN
)
1216 for (j
= 0; j
< info
->sector_count
; ++j
) {
1218 hdr
= (void *)info
->start
[j
];
1222 switch (genimg_get_format(hdr
)) {
1223 case IMAGE_FORMAT_LEGACY
:
1224 if (!image_check_hcrc(hdr
))
1227 printf("Legacy Image at %08lX:\n", (ulong
)hdr
);
1228 image_print_contents(hdr
);
1230 puts(" Verifying Checksum ... ");
1231 if (!image_check_dcrc(hdr
)) {
1232 puts("Bad Data CRC\n");
1237 #if defined(CONFIG_FIT)
1238 case IMAGE_FORMAT_FIT
:
1239 if (!fit_check_format(hdr
))
1242 printf("FIT Image at %08lX:\n", (ulong
)hdr
);
1243 fit_print_contents(hdr
);
1258 #if defined(CONFIG_CMD_IMLS_NAND)
1259 static int nand_imls_legacyimage(nand_info_t
*nand
, int nand_dev
, loff_t off
,
1265 imgdata
= malloc(len
);
1267 printf("May be a Legacy 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 (!image_check_hcrc(imgdata
)) {
1285 printf("Legacy Image at NAND device %d offset %08llX:\n",
1287 image_print_contents(imgdata
);
1289 puts(" Verifying Checksum ... ");
1290 if (!image_check_dcrc(imgdata
))
1291 puts("Bad Data CRC\n");
1300 static int nand_imls_fitimage(nand_info_t
*nand
, int nand_dev
, loff_t off
,
1306 imgdata
= malloc(len
);
1308 printf("May be a FIT Image at NAND device %d offset %08llX:\n",
1310 printf(" Low memory(cannot allocate memory for image)\n");
1314 ret
= nand_read_skip_bad(nand
, off
, &len
,
1316 if (ret
< 0 && ret
!= -EUCLEAN
) {
1321 if (!fit_check_format(imgdata
)) {
1326 printf("FIT Image at NAND device %d offset %08llX:\n", nand_dev
, off
);
1328 fit_print_contents(imgdata
);
1334 static int do_imls_nand(void)
1337 int nand_dev
= nand_curr_device
;
1342 if (nand_dev
< 0 || nand_dev
>= CONFIG_SYS_MAX_NAND_DEVICE
) {
1343 puts("\nNo NAND devices available\n");
1349 for (nand_dev
= 0; nand_dev
< CONFIG_SYS_MAX_NAND_DEVICE
; nand_dev
++) {
1350 nand
= &nand_info
[nand_dev
];
1351 if (!nand
->name
|| !nand
->size
)
1354 for (off
= 0; off
< nand
->size
; off
+= nand
->erasesize
) {
1355 const image_header_t
*header
;
1358 if (nand_block_isbad(nand
, off
))
1361 len
= sizeof(buffer
);
1363 ret
= nand_read(nand
, off
, &len
, (u8
*)buffer
);
1364 if (ret
< 0 && ret
!= -EUCLEAN
) {
1365 printf("NAND read error %d at offset %08llX\n",
1370 switch (genimg_get_format(buffer
)) {
1371 case IMAGE_FORMAT_LEGACY
:
1372 header
= (const image_header_t
*)buffer
;
1374 len
= image_get_image_size(header
);
1375 nand_imls_legacyimage(nand
, nand_dev
, off
, len
);
1377 #if defined(CONFIG_FIT)
1378 case IMAGE_FORMAT_FIT
:
1379 len
= fit_get_size(buffer
);
1380 nand_imls_fitimage(nand
, nand_dev
, off
, len
);
1391 #if defined(CONFIG_CMD_IMLS) || defined(CONFIG_CMD_IMLS_NAND)
1392 static int do_imls(cmd_tbl_t
*cmdtp
, int flag
, int argc
, char * const argv
[])
1394 int ret_nor
= 0, ret_nand
= 0;
1396 #if defined(CONFIG_CMD_IMLS)
1397 ret_nor
= do_imls_nor();
1400 #if defined(CONFIG_CMD_IMLS_NAND)
1401 ret_nand
= do_imls_nand();
1414 imls
, 1, 1, do_imls
,
1415 "list all images found in flash",
1417 " - Prints information about all images found at sector/block\n"
1418 " boundaries in nor/nand flash."
1422 /*******************************************************************/
1423 /* helper routines */
1424 /*******************************************************************/
1425 #if defined(CONFIG_SILENT_CONSOLE) && !defined(CONFIG_SILENT_U_BOOT_ONLY)
1427 #define CONSOLE_ARG "console="
1428 #define CONSOLE_ARG_LEN (sizeof(CONSOLE_ARG) - 1)
1430 static void fixup_silent_linux(void)
1433 const char *env_val
;
1434 char *cmdline
= getenv("bootargs");
1436 /* Only fix cmdline when requested */
1437 if (!(gd
->flags
& GD_FLG_SILENT
))
1440 debug("before silent fix-up: %s\n", cmdline
);
1441 if (cmdline
&& (cmdline
[0] != '\0')) {
1442 char *start
= strstr(cmdline
, CONSOLE_ARG
);
1444 /* Allocate space for maximum possible new command line */
1445 buf
= malloc(strlen(cmdline
) + 1 + CONSOLE_ARG_LEN
+ 1);
1447 debug("%s: out of memory\n", __func__
);
1452 char *end
= strchr(start
, ' ');
1453 int num_start_bytes
= start
- cmdline
+ CONSOLE_ARG_LEN
;
1455 strncpy(buf
, cmdline
, num_start_bytes
);
1457 strcpy(buf
+ num_start_bytes
, end
);
1459 buf
[num_start_bytes
] = '\0';
1461 sprintf(buf
, "%s %s", cmdline
, CONSOLE_ARG
);
1466 env_val
= CONSOLE_ARG
;
1469 setenv("bootargs", env_val
);
1470 debug("after silent fix-up: %s\n", env_val
);
1473 #endif /* CONFIG_SILENT_CONSOLE */
1476 /*******************************************************************/
1477 /* OS booting routines */
1478 /*******************************************************************/
1480 #ifdef CONFIG_BOOTM_NETBSD
1481 static int do_bootm_netbsd(int flag
, int argc
, char * const argv
[],
1482 bootm_headers_t
*images
)
1484 void (*loader
)(bd_t
*, image_header_t
*, char *, char *);
1485 image_header_t
*os_hdr
, *hdr
;
1486 ulong kernel_data
, kernel_len
;
1490 if ((flag
!= 0) && (flag
!= BOOTM_STATE_OS_GO
))
1493 #if defined(CONFIG_FIT)
1494 if (!images
->legacy_hdr_valid
) {
1495 fit_unsupported_reset("NetBSD");
1499 hdr
= images
->legacy_hdr_os
;
1502 * Booting a (NetBSD) kernel image
1504 * This process is pretty similar to a standalone application:
1505 * The (first part of an multi-) image must be a stage-2 loader,
1506 * which in turn is responsible for loading & invoking the actual
1507 * kernel. The only differences are the parameters being passed:
1508 * besides the board info strucure, the loader expects a command
1509 * line, the name of the console device, and (optionally) the
1510 * address of the original image header.
1513 if (image_check_type(&images
->legacy_hdr_os_copy
, IH_TYPE_MULTI
)) {
1514 image_multi_getimg(hdr
, 1, &kernel_data
, &kernel_len
);
1520 #if defined(CONFIG_8xx_CONS_SMC1)
1522 #elif defined(CONFIG_8xx_CONS_SMC2)
1524 #elif defined(CONFIG_8xx_CONS_SCC2)
1526 #elif defined(CONFIG_8xx_CONS_SCC3)
1534 for (i
= 2, len
= 0; i
< argc
; i
+= 1)
1535 len
+= strlen(argv
[i
]) + 1;
1536 cmdline
= malloc(len
);
1538 for (i
= 2, len
= 0; i
< argc
; i
+= 1) {
1540 cmdline
[len
++] = ' ';
1541 strcpy(&cmdline
[len
], argv
[i
]);
1542 len
+= strlen(argv
[i
]);
1544 } else if ((cmdline
= getenv("bootargs")) == NULL
) {
1548 loader
= (void (*)(bd_t
*, image_header_t
*, char *, char *))images
->ep
;
1550 printf("## Transferring control to NetBSD stage-2 loader "
1551 "(at address %08lx) ...\n",
1554 bootstage_mark(BOOTSTAGE_ID_RUN_OS
);
1557 * NetBSD Stage-2 Loader Parameters:
1558 * r3: ptr to board info data
1560 * r5: console device
1561 * r6: boot args string
1563 (*loader
)(gd
->bd
, os_hdr
, consdev
, cmdline
);
1567 #endif /* CONFIG_BOOTM_NETBSD*/
1569 #ifdef CONFIG_LYNXKDI
1570 static int do_bootm_lynxkdi(int flag
, int argc
, char * const argv
[],
1571 bootm_headers_t
*images
)
1573 image_header_t
*hdr
= &images
->legacy_hdr_os_copy
;
1575 if ((flag
!= 0) && (flag
!= BOOTM_STATE_OS_GO
))
1578 #if defined(CONFIG_FIT)
1579 if (!images
->legacy_hdr_valid
) {
1580 fit_unsupported_reset("Lynx");
1585 lynxkdi_boot((image_header_t
*)hdr
);
1589 #endif /* CONFIG_LYNXKDI */
1591 #ifdef CONFIG_BOOTM_RTEMS
1592 static int do_bootm_rtems(int flag
, int argc
, char * const argv
[],
1593 bootm_headers_t
*images
)
1595 void (*entry_point
)(bd_t
*);
1597 if ((flag
!= 0) && (flag
!= BOOTM_STATE_OS_GO
))
1600 #if defined(CONFIG_FIT)
1601 if (!images
->legacy_hdr_valid
) {
1602 fit_unsupported_reset("RTEMS");
1607 entry_point
= (void (*)(bd_t
*))images
->ep
;
1609 printf("## Transferring control to RTEMS (at address %08lx) ...\n",
1610 (ulong
)entry_point
);
1612 bootstage_mark(BOOTSTAGE_ID_RUN_OS
);
1616 * r3: ptr to board info data
1618 (*entry_point
)(gd
->bd
);
1622 #endif /* CONFIG_BOOTM_RTEMS */
1624 #if defined(CONFIG_BOOTM_OSE)
1625 static int do_bootm_ose(int flag
, int argc
, char * const argv
[],
1626 bootm_headers_t
*images
)
1628 void (*entry_point
)(void);
1630 if ((flag
!= 0) && (flag
!= BOOTM_STATE_OS_GO
))
1633 #if defined(CONFIG_FIT)
1634 if (!images
->legacy_hdr_valid
) {
1635 fit_unsupported_reset("OSE");
1640 entry_point
= (void (*)(void))images
->ep
;
1642 printf("## Transferring control to OSE (at address %08lx) ...\n",
1643 (ulong
)entry_point
);
1645 bootstage_mark(BOOTSTAGE_ID_RUN_OS
);
1655 #endif /* CONFIG_BOOTM_OSE */
1657 #if defined(CONFIG_BOOTM_PLAN9)
1658 static int do_bootm_plan9(int flag
, int argc
, char * const argv
[],
1659 bootm_headers_t
*images
)
1661 void (*entry_point
)(void);
1663 if ((flag
!= 0) && (flag
!= BOOTM_STATE_OS_GO
))
1666 #if defined(CONFIG_FIT)
1667 if (!images
->legacy_hdr_valid
) {
1668 fit_unsupported_reset("Plan 9");
1673 entry_point
= (void (*)(void))images
->ep
;
1675 printf("## Transferring control to Plan 9 (at address %08lx) ...\n",
1676 (ulong
)entry_point
);
1678 bootstage_mark(BOOTSTAGE_ID_RUN_OS
);
1681 * Plan 9 Parameters:
1688 #endif /* CONFIG_BOOTM_PLAN9 */
1690 #if defined(CONFIG_CMD_ELF)
1691 static int do_bootm_vxworks(int flag
, int argc
, char * const argv
[],
1692 bootm_headers_t
*images
)
1696 if ((flag
!= 0) && (flag
!= BOOTM_STATE_OS_GO
))
1699 #if defined(CONFIG_FIT)
1700 if (!images
->legacy_hdr_valid
) {
1701 fit_unsupported_reset("VxWorks");
1706 sprintf(str
, "%lx", images
->ep
); /* write entry-point into string */
1707 setenv("loadaddr", str
);
1708 do_bootvx(NULL
, 0, 0, NULL
);
1713 static int do_bootm_qnxelf(int flag
, int argc
, char * const argv
[],
1714 bootm_headers_t
*images
)
1716 char *local_args
[2];
1719 if ((flag
!= 0) && (flag
!= BOOTM_STATE_OS_GO
))
1722 #if defined(CONFIG_FIT)
1723 if (!images
->legacy_hdr_valid
) {
1724 fit_unsupported_reset("QNX");
1729 sprintf(str
, "%lx", images
->ep
); /* write entry-point into string */
1730 local_args
[0] = argv
[0];
1731 local_args
[1] = str
; /* and provide it via the arguments */
1732 do_bootelf(NULL
, 0, 2, local_args
);
1738 #ifdef CONFIG_INTEGRITY
1739 static int do_bootm_integrity(int flag
, int argc
, char * const argv
[],
1740 bootm_headers_t
*images
)
1742 void (*entry_point
)(void);
1744 if ((flag
!= 0) && (flag
!= BOOTM_STATE_OS_GO
))
1747 #if defined(CONFIG_FIT)
1748 if (!images
->legacy_hdr_valid
) {
1749 fit_unsupported_reset("INTEGRITY");
1754 entry_point
= (void (*)(void))images
->ep
;
1756 printf("## Transferring control to INTEGRITY (at address %08lx) ...\n",
1757 (ulong
)entry_point
);
1759 bootstage_mark(BOOTSTAGE_ID_RUN_OS
);
1762 * INTEGRITY Parameters:
1771 #ifdef CONFIG_CMD_BOOTZ
1773 static int __bootz_setup(void *image
, void **start
, void **end
)
1775 /* Please define bootz_setup() for your platform */
1777 puts("Your platform's zImage format isn't supported yet!\n");
1780 int bootz_setup(void *image
, void **start
, void **end
)
1781 __attribute__((weak
, alias("__bootz_setup")));
1784 * zImage booting support
1786 static int bootz_start(cmd_tbl_t
*cmdtp
, int flag
, int argc
,
1787 char * const argv
[], bootm_headers_t
*images
)
1790 void *zi_start
, *zi_end
;
1792 memset(images
, 0, sizeof(bootm_headers_t
));
1794 boot_start_lmb(images
);
1796 /* Setup Linux kernel zImage entry point */
1798 images
->ep
= load_addr
;
1799 debug("* kernel: default image load address = 0x%08lx\n",
1802 images
->ep
= simple_strtoul(argv
[1], NULL
, 16);
1803 debug("* kernel: cmdline image address = 0x%08lx\n",
1807 ret
= bootz_setup((void *)images
->ep
, &zi_start
, &zi_end
);
1811 lmb_reserve(&images
->lmb
, images
->ep
, zi_end
- zi_start
);
1814 ret
= boot_get_ramdisk(argc
, argv
, images
, IH_INITRD_ARCH
,
1815 &images
->rd_start
, &images
->rd_end
);
1817 puts("Ramdisk image is corrupt or invalid\n");
1821 #if defined(CONFIG_OF_LIBFDT)
1822 /* find flattened device tree */
1823 ret
= boot_get_fdt(flag
, argc
, argv
, images
,
1824 &images
->ft_addr
, &images
->ft_len
);
1826 puts("Could not find a valid device tree\n");
1830 set_working_fdt_addr(images
->ft_addr
);
1836 static int do_bootz(cmd_tbl_t
*cmdtp
, int flag
, int argc
, char * const argv
[])
1838 bootm_headers_t images
;
1840 if (bootz_start(cmdtp
, flag
, argc
, argv
, &images
))
1844 * We have reached the point of no return: we are going to
1845 * overwrite all exception vector code, so we cannot easily
1846 * recover from any failures any more...
1848 disable_interrupts();
1850 #ifdef CONFIG_NETCONSOLE
1851 /* Stop the ethernet stack if NetConsole could have left it up */
1855 #if defined(CONFIG_CMD_USB)
1857 * turn off USB to prevent the host controller from writing to the
1858 * SDRAM while Linux is booting. This could happen (at least for OHCI
1859 * controller), because the HCCA (Host Controller Communication Area)
1860 * lies within the SDRAM and the host controller writes continously to
1861 * this area (as busmaster!). The HccaFrameNumber is for example
1862 * updated every 1 ms within the HCCA structure in SDRAM! For more
1863 * details see the OpenHCI specification.
1868 #if defined(CONFIG_SILENT_CONSOLE) && !defined(CONFIG_SILENT_U_BOOT_ONLY)
1869 fixup_silent_linux();
1873 do_bootm_linux(0, argc
, argv
, &images
);
1875 puts("\n## Control returned to monitor - resetting...\n");
1877 do_reset(cmdtp
, flag
, argc
, argv
);
1882 #ifdef CONFIG_SYS_LONGHELP
1883 static char bootz_help_text
[] =
1884 "[addr [initrd[:size]] [fdt]]\n"
1885 " - boot Linux zImage stored in memory\n"
1886 "\tThe argument 'initrd' is optional and specifies the address\n"
1887 "\tof the initrd in memory. The optional argument ':size' allows\n"
1888 "\tspecifying the size of RAW initrd.\n"
1889 #if defined(CONFIG_OF_LIBFDT)
1890 "\tWhen booting a Linux kernel which requires a flat device-tree\n"
1891 "\ta third argument is required which is the address of the\n"
1892 "\tdevice-tree blob. To boot that kernel without an initrd image,\n"
1893 "\tuse a '-' for the second argument. If you do not pass a third\n"
1894 "\ta bd_info struct will be passed instead\n"
1900 bootz
, CONFIG_SYS_MAXARGS
, 1, do_bootz
,
1901 "boot Linux zImage image from memory", bootz_help_text
1903 #endif /* CONFIG_CMD_BOOTZ */