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>
39 #include <linux/compiler.h>
41 #if defined(CONFIG_CMD_USB)
45 #ifdef CONFIG_SYS_HUSH_PARSER
49 #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 */
83 static int do_imls(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
86 #ifdef CONFIG_SILENT_CONSOLE
87 static void fixup_silent_linux(void);
90 static image_header_t *image_get_kernel(ulong img_addr, int verify);
91 #if defined(CONFIG_FIT)
92 static int fit_check_kernel(const void *fit, int os_noffset, int verify);
95 static void *boot_get_kernel(cmd_tbl_t *cmdtp, int flag, int argc,
96 char * const argv[], bootm_headers_t *images,
97 ulong *os_data, ulong *os_len);
100 * Continue booting an OS image; caller already has:
101 * - copied image header to global variable `header'
102 * - checked header magic number, checksums (both header & image),
103 * - verified image architecture (PPC) and type (KERNEL or MULTI),
104 * - loaded (first part of) image to header load address,
105 * - disabled interrupts.
107 typedef int boot_os_fn(int flag, int argc, char * const argv[],
108 bootm_headers_t *images); /* pointers to os/initrd/fdt */
110 #ifdef CONFIG_BOOTM_LINUX
111 extern boot_os_fn do_bootm_linux;
113 #ifdef CONFIG_BOOTM_NETBSD
114 static boot_os_fn do_bootm_netbsd;
116 #if defined(CONFIG_LYNXKDI)
117 static boot_os_fn do_bootm_lynxkdi;
118 extern void lynxkdi_boot(image_header_t *);
120 #ifdef CONFIG_BOOTM_RTEMS
121 static boot_os_fn do_bootm_rtems;
123 #if defined(CONFIG_BOOTM_OSE)
124 static boot_os_fn do_bootm_ose;
126 #if defined(CONFIG_CMD_ELF)
127 static boot_os_fn do_bootm_vxworks;
128 static boot_os_fn do_bootm_qnxelf;
129 int do_bootvx(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
130 int do_bootelf(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
132 #if defined(CONFIG_INTEGRITY)
133 static boot_os_fn do_bootm_integrity;
136 static boot_os_fn *boot_os[] = {
137 #ifdef CONFIG_BOOTM_LINUX
138 [IH_OS_LINUX] = do_bootm_linux,
140 #ifdef CONFIG_BOOTM_NETBSD
141 [IH_OS_NETBSD] = do_bootm_netbsd,
143 #ifdef CONFIG_LYNXKDI
144 [IH_OS_LYNXOS] = do_bootm_lynxkdi,
146 #ifdef CONFIG_BOOTM_RTEMS
147 [IH_OS_RTEMS] = do_bootm_rtems,
149 #if defined(CONFIG_BOOTM_OSE)
150 [IH_OS_OSE] = do_bootm_ose,
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 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[])
198 memset((void *)&images, 0, sizeof(images));
199 images.verify = getenv_yesno("verify");
201 boot_start_lmb(&images);
203 bootstage_mark_name(BOOTSTAGE_ID_BOOTM_START, "bootm_start");
205 /* get kernel image header, start address and length */
206 os_hdr = boot_get_kernel(cmdtp, flag, argc, argv,
207 &images, &images.os.image_start, &images.os.image_len);
208 if (images.os.image_len == 0) {
209 puts("ERROR: can't get kernel image!\n");
213 /* get image parameters */
214 switch (genimg_get_format(os_hdr)) {
215 case IMAGE_FORMAT_LEGACY:
216 images.os.type = image_get_type(os_hdr);
217 images.os.comp = image_get_comp(os_hdr);
218 images.os.os = image_get_os(os_hdr);
220 images.os.end = image_get_image_end(os_hdr);
221 images.os.load = image_get_load(os_hdr);
223 #if defined(CONFIG_FIT)
224 case IMAGE_FORMAT_FIT:
225 if (fit_image_get_type(images.fit_hdr_os,
226 images.fit_noffset_os, &images.os.type)) {
227 puts("Can't get image type!\n");
228 bootstage_error(BOOTSTAGE_ID_FIT_TYPE);
232 if (fit_image_get_comp(images.fit_hdr_os,
233 images.fit_noffset_os, &images.os.comp)) {
234 puts("Can't get image compression!\n");
235 bootstage_error(BOOTSTAGE_ID_FIT_COMPRESSION);
239 if (fit_image_get_os(images.fit_hdr_os,
240 images.fit_noffset_os, &images.os.os)) {
241 puts("Can't get image OS!\n");
242 bootstage_error(BOOTSTAGE_ID_FIT_OS);
246 images.os.end = fit_get_end(images.fit_hdr_os);
248 if (fit_image_get_load(images.fit_hdr_os, images.fit_noffset_os,
250 puts("Can't get image load address!\n");
251 bootstage_error(BOOTSTAGE_ID_FIT_LOADADDR);
257 puts("ERROR: unknown image format type!\n");
261 /* find kernel entry point */
262 if (images.legacy_hdr_valid) {
263 images.ep = image_get_ep(&images.legacy_hdr_os_copy);
264 #if defined(CONFIG_FIT)
265 } else if (images.fit_uname_os) {
266 ret = fit_image_get_entry(images.fit_hdr_os,
267 images.fit_noffset_os, &images.ep);
269 puts("Can't get entry point property!\n");
274 puts("Could not find kernel entry point!\n");
278 if (images.os.type == IH_TYPE_KERNEL_NOLOAD) {
279 images.os.load = images.os.image_start;
280 images.ep += images.os.load;
283 if (((images.os.type == IH_TYPE_KERNEL) ||
284 (images.os.type == IH_TYPE_KERNEL_NOLOAD) ||
285 (images.os.type == IH_TYPE_MULTI)) &&
286 (images.os.os == IH_OS_LINUX)) {
288 ret = boot_get_ramdisk(argc, argv, &images, IH_INITRD_ARCH,
289 &images.rd_start, &images.rd_end);
291 puts("Ramdisk image is corrupt or invalid\n");
295 #if defined(CONFIG_OF_LIBFDT)
296 /* find flattened device tree */
297 ret = boot_get_fdt(flag, argc, argv, &images,
298 &images.ft_addr, &images.ft_len);
300 puts("Could not find a valid device tree\n");
304 set_working_fdt_addr(images.ft_addr);
308 images.os.start = (ulong)os_hdr;
309 images.state = BOOTM_STATE_START;
314 #define BOOTM_ERR_RESET -1
315 #define BOOTM_ERR_OVERLAP -2
316 #define BOOTM_ERR_UNIMPLEMENTED -3
317 static int bootm_load_os(image_info_t os, ulong *load_end, int boot_progress)
319 uint8_t comp = os.comp;
320 ulong load = os.load;
321 ulong blob_start = os.start;
322 ulong blob_end = os.end;
323 ulong image_start = os.image_start;
324 ulong image_len = os.image_len;
325 __maybe_unused uint unc_len = CONFIG_SYS_BOOTM_LEN;
327 #if defined(CONFIG_LZMA) || defined(CONFIG_LZO)
329 #endif /* defined(CONFIG_LZMA) || defined(CONFIG_LZO) */
331 const char *type_name = genimg_get_type_name(os.type);
335 if (load == blob_start || load == image_start) {
336 printf(" XIP %s ... ", type_name);
339 printf(" Loading %s ... ", type_name);
340 memmove_wd((void *)load, (void *)image_start,
343 *load_end = load + image_len;
348 printf(" Uncompressing %s ... ", type_name);
349 if (gunzip((void *)load, unc_len,
350 (uchar *)image_start, &image_len) != 0) {
351 puts("GUNZIP: uncompress, out-of-mem or overwrite "
352 "error - must RESET board to recover\n");
354 bootstage_error(BOOTSTAGE_ID_DECOMP_IMAGE);
355 return BOOTM_ERR_RESET;
358 *load_end = load + image_len;
360 #endif /* CONFIG_GZIP */
363 printf(" Uncompressing %s ... ", type_name);
365 * If we've got less than 4 MB of malloc() space,
366 * use slower decompression algorithm which requires
367 * at most 2300 KB of memory.
369 int i = BZ2_bzBuffToBuffDecompress((char *)load,
370 &unc_len, (char *)image_start, image_len,
371 CONFIG_SYS_MALLOC_LEN < (4096 * 1024), 0);
373 printf("BUNZIP2: uncompress or overwrite error %d "
374 "- must RESET board to recover\n", i);
376 bootstage_error(BOOTSTAGE_ID_DECOMP_IMAGE);
377 return BOOTM_ERR_RESET;
380 *load_end = load + unc_len;
382 #endif /* CONFIG_BZIP2 */
385 SizeT lzma_len = unc_len;
386 printf(" Uncompressing %s ... ", type_name);
388 ret = lzmaBuffToBuffDecompress(
389 (unsigned char *)load, &lzma_len,
390 (unsigned char *)image_start, image_len);
393 printf("LZMA: uncompress or overwrite error %d "
394 "- must RESET board to recover\n", ret);
395 bootstage_error(BOOTSTAGE_ID_DECOMP_IMAGE);
396 return BOOTM_ERR_RESET;
398 *load_end = load + unc_len;
401 #endif /* CONFIG_LZMA */
404 printf(" Uncompressing %s ... ", type_name);
406 ret = lzop_decompress((const unsigned char *)image_start,
407 image_len, (unsigned char *)load,
409 if (ret != LZO_E_OK) {
410 printf("LZO: uncompress or overwrite error %d "
411 "- must RESET board to recover\n", ret);
413 bootstage_error(BOOTSTAGE_ID_DECOMP_IMAGE);
414 return BOOTM_ERR_RESET;
417 *load_end = load + unc_len;
419 #endif /* CONFIG_LZO */
421 printf("Unimplemented compression type %d\n", comp);
422 return BOOTM_ERR_UNIMPLEMENTED;
425 flush_cache(load, (*load_end - load) * sizeof(ulong));
428 debug(" kernel loaded at 0x%08lx, end = 0x%08lx\n", load, *load_end);
429 bootstage_mark(BOOTSTAGE_ID_KERNEL_LOADED);
431 if (!no_overlap && (load < blob_end) && (*load_end > blob_start)) {
432 debug("images.os.start = 0x%lX, images.os.end = 0x%lx\n",
433 blob_start, blob_end);
434 debug("images.os.load = 0x%lx, load_end = 0x%lx\n", load,
437 return BOOTM_ERR_OVERLAP;
443 static int bootm_start_standalone(ulong iflag, int argc, char * const argv[])
446 int (*appl)(int, char * const []);
448 /* Don't start if "autostart" is set to "no" */
449 if (((s = getenv("autostart")) != NULL) && (strcmp(s, "no") == 0)) {
451 sprintf(buf, "%lX", images.os.image_len);
452 setenv("filesize", buf);
455 appl = (int (*)(int, char * const []))(ulong)ntohl(images.ep);
456 (*appl)(argc-1, &argv[1]);
460 /* we overload the cmd field with our state machine info instead of a
461 * function pointer */
462 static cmd_tbl_t cmd_bootm_sub[] = {
463 U_BOOT_CMD_MKENT(start, 0, 1, (void *)BOOTM_STATE_START, "", ""),
464 U_BOOT_CMD_MKENT(loados, 0, 1, (void *)BOOTM_STATE_LOADOS, "", ""),
465 #ifdef CONFIG_SYS_BOOT_RAMDISK_HIGH
466 U_BOOT_CMD_MKENT(ramdisk, 0, 1, (void *)BOOTM_STATE_RAMDISK, "", ""),
468 #ifdef CONFIG_OF_LIBFDT
469 U_BOOT_CMD_MKENT(fdt, 0, 1, (void *)BOOTM_STATE_FDT, "", ""),
471 U_BOOT_CMD_MKENT(cmdline, 0, 1, (void *)BOOTM_STATE_OS_CMDLINE, "", ""),
472 U_BOOT_CMD_MKENT(bdt, 0, 1, (void *)BOOTM_STATE_OS_BD_T, "", ""),
473 U_BOOT_CMD_MKENT(prep, 0, 1, (void *)BOOTM_STATE_OS_PREP, "", ""),
474 U_BOOT_CMD_MKENT(go, 0, 1, (void *)BOOTM_STATE_OS_GO, "", ""),
477 int do_bootm_subcommand(cmd_tbl_t *cmdtp, int flag, int argc,
485 c = find_cmd_tbl(argv[1], &cmd_bootm_sub[0], ARRAY_SIZE(cmd_bootm_sub));
488 state = (long)c->cmd;
490 /* treat start special since it resets the state machine */
491 if (state == BOOTM_STATE_START) {
494 return bootm_start(cmdtp, flag, argc, argv);
497 /* Unrecognized command */
498 return CMD_RET_USAGE;
501 if (images.state >= state) {
502 printf("Trying to execute a command out of order\n");
503 return CMD_RET_USAGE;
506 images.state |= state;
507 boot_fn = boot_os[images.os.os];
511 case BOOTM_STATE_START:
512 /* should never occur */
514 case BOOTM_STATE_LOADOS:
515 ret = bootm_load_os(images.os, &load_end, 0);
519 lmb_reserve(&images.lmb, images.os.load,
520 (load_end - images.os.load));
522 #ifdef CONFIG_SYS_BOOT_RAMDISK_HIGH
523 case BOOTM_STATE_RAMDISK:
525 ulong rd_len = images.rd_end - images.rd_start;
528 ret = boot_ramdisk_high(&images.lmb, images.rd_start,
529 rd_len, &images.initrd_start, &images.initrd_end);
533 sprintf(str, "%lx", images.initrd_start);
534 setenv("initrd_start", str);
535 sprintf(str, "%lx", images.initrd_end);
536 setenv("initrd_end", str);
540 #if defined(CONFIG_OF_LIBFDT)
541 case BOOTM_STATE_FDT:
543 boot_fdt_add_mem_rsv_regions(&images.lmb,
545 ret = boot_relocate_fdt(&images.lmb,
546 &images.ft_addr, &images.ft_len);
550 case BOOTM_STATE_OS_CMDLINE:
551 ret = boot_fn(BOOTM_STATE_OS_CMDLINE, argc, argv, &images);
553 printf("cmdline subcommand not supported\n");
555 case BOOTM_STATE_OS_BD_T:
556 ret = boot_fn(BOOTM_STATE_OS_BD_T, argc, argv, &images);
558 printf("bdt subcommand not supported\n");
560 case BOOTM_STATE_OS_PREP:
561 ret = boot_fn(BOOTM_STATE_OS_PREP, argc, argv, &images);
563 printf("prep subcommand not supported\n");
565 case BOOTM_STATE_OS_GO:
566 disable_interrupts();
568 boot_fn(BOOTM_STATE_OS_GO, argc, argv, &images);
575 /*******************************************************************/
576 /* bootm - boot application image from image in memory */
577 /*******************************************************************/
579 int do_bootm(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
585 #ifdef CONFIG_NEEDS_MANUAL_RELOC
586 static int relocated = 0;
588 /* relocate boot function table */
591 for (i = 0; i < ARRAY_SIZE(boot_os); i++)
592 if (boot_os[i] != NULL)
593 boot_os[i] += gd->reloc_off;
598 /* determine if we have a sub command */
602 simple_strtoul(argv[1], &endp, 16);
603 /* endp pointing to NULL means that argv[1] was just a
604 * valid number, pass it along to the normal bootm processing
606 * If endp is ':' or '#' assume a FIT identifier so pass
607 * along for normal processing.
609 * Right now we assume the first arg should never be '-'
611 if ((*endp != 0) && (*endp != ':') && (*endp != '#'))
612 return do_bootm_subcommand(cmdtp, flag, argc, argv);
615 if (bootm_start(cmdtp, flag, argc, argv))
619 * We have reached the point of no return: we are going to
620 * overwrite all exception vector code, so we cannot easily
621 * recover from any failures any more...
623 iflag = disable_interrupts();
625 #if defined(CONFIG_CMD_USB)
627 * turn off USB to prevent the host controller from writing to the
628 * SDRAM while Linux is booting. This could happen (at least for OHCI
629 * controller), because the HCCA (Host Controller Communication Area)
630 * lies within the SDRAM and the host controller writes continously to
631 * this area (as busmaster!). The HccaFrameNumber is for example
632 * updated every 1 ms within the HCCA structure in SDRAM! For more
633 * details see the OpenHCI specification.
638 ret = bootm_load_os(images.os, &load_end, 1);
641 if (ret == BOOTM_ERR_RESET)
642 do_reset(cmdtp, flag, argc, argv);
643 if (ret == BOOTM_ERR_OVERLAP) {
644 if (images.legacy_hdr_valid) {
646 hdr = &images.legacy_hdr_os_copy;
647 if (image_get_type(hdr) == IH_TYPE_MULTI)
648 puts("WARNING: legacy format multi "
652 puts("ERROR: new format image overwritten - "
653 "must RESET the board to recover\n");
654 bootstage_error(BOOTSTAGE_ID_OVERWRITTEN);
655 do_reset(cmdtp, flag, argc, argv);
658 if (ret == BOOTM_ERR_UNIMPLEMENTED) {
661 bootstage_error(BOOTSTAGE_ID_DECOMP_UNIMPL);
666 lmb_reserve(&images.lmb, images.os.load, (load_end - images.os.load));
668 if (images.os.type == IH_TYPE_STANDALONE) {
671 /* This may return when 'autostart' is 'no' */
672 bootm_start_standalone(iflag, argc, argv);
676 bootstage_mark(BOOTSTAGE_ID_CHECK_BOOT_OS);
678 #ifdef CONFIG_SILENT_CONSOLE
679 if (images.os.os == IH_OS_LINUX)
680 fixup_silent_linux();
683 boot_fn = boot_os[images.os.os];
685 if (boot_fn == NULL) {
688 printf("ERROR: booting os '%s' (%d) is not supported\n",
689 genimg_get_os_name(images.os.os), images.os.os);
690 bootstage_error(BOOTSTAGE_ID_CHECK_BOOT_OS);
696 boot_fn(0, argc, argv, &images);
698 bootstage_error(BOOTSTAGE_ID_BOOT_OS_RETURNED);
700 puts("\n## Control returned to monitor - resetting...\n");
702 do_reset(cmdtp, flag, argc, argv);
707 int bootm_maybe_autostart(cmd_tbl_t *cmdtp, const char *cmd)
709 const char *ep = getenv("autostart");
711 if (ep && !strcmp(ep, "yes")) {
713 local_args[0] = (char *)cmd;
714 local_args[1] = NULL;
715 printf("Automatic boot of image at addr 0x%08lX ...\n", load_addr);
716 return do_bootm(cmdtp, 0, 1, local_args);
723 * image_get_kernel - verify legacy format kernel image
724 * @img_addr: in RAM address of the legacy format image to be verified
725 * @verify: data CRC verification flag
727 * image_get_kernel() verifies legacy image integrity and returns pointer to
728 * legacy image header if image verification was completed successfully.
731 * pointer to a legacy image header if valid image was found
732 * otherwise return NULL
734 static image_header_t *image_get_kernel(ulong img_addr, int verify)
736 image_header_t *hdr = (image_header_t *)img_addr;
738 if (!image_check_magic(hdr)) {
739 puts("Bad Magic Number\n");
740 bootstage_error(BOOTSTAGE_ID_CHECK_MAGIC);
743 bootstage_mark(BOOTSTAGE_ID_CHECK_HEADER);
745 if (!image_check_hcrc(hdr)) {
746 puts("Bad Header Checksum\n");
747 bootstage_error(BOOTSTAGE_ID_CHECK_HEADER);
751 bootstage_mark(BOOTSTAGE_ID_CHECK_CHECKSUM);
752 image_print_contents(hdr);
755 puts(" Verifying Checksum ... ");
756 if (!image_check_dcrc(hdr)) {
757 printf("Bad Data CRC\n");
758 bootstage_error(BOOTSTAGE_ID_CHECK_CHECKSUM);
763 bootstage_mark(BOOTSTAGE_ID_CHECK_ARCH);
765 if (!image_check_target_arch(hdr)) {
766 printf("Unsupported Architecture 0x%x\n", image_get_arch(hdr));
767 bootstage_error(BOOTSTAGE_ID_CHECK_ARCH);
774 * fit_check_kernel - verify FIT format kernel subimage
775 * @fit_hdr: pointer to the FIT image header
776 * os_noffset: kernel subimage node offset within FIT image
777 * @verify: data CRC verification flag
779 * fit_check_kernel() verifies integrity of the kernel subimage and from
780 * specified FIT image.
786 #if defined(CONFIG_FIT)
787 static int fit_check_kernel(const void *fit, int os_noffset, int verify)
789 fit_image_print(fit, os_noffset, " ");
792 puts(" Verifying Hash Integrity ... ");
793 if (!fit_image_check_hashes(fit, os_noffset)) {
794 puts("Bad Data Hash\n");
795 bootstage_error(BOOTSTAGE_ID_FIT_CHECK_HASH);
800 bootstage_mark(BOOTSTAGE_ID_FIT_CHECK_ARCH);
802 if (!fit_image_check_target_arch(fit, os_noffset)) {
803 puts("Unsupported Architecture\n");
804 bootstage_error(BOOTSTAGE_ID_FIT_CHECK_ARCH);
808 bootstage_mark(BOOTSTAGE_ID_FIT_CHECK_KERNEL);
809 if (!fit_image_check_type(fit, os_noffset, IH_TYPE_KERNEL) &&
810 !fit_image_check_type(fit, os_noffset, IH_TYPE_KERNEL_NOLOAD)) {
811 puts("Not a kernel image\n");
812 bootstage_error(BOOTSTAGE_ID_FIT_CHECK_KERNEL);
816 bootstage_mark(BOOTSTAGE_ID_FIT_CHECKED);
819 #endif /* CONFIG_FIT */
822 * boot_get_kernel - find kernel image
823 * @os_data: pointer to a ulong variable, will hold os data start address
824 * @os_len: pointer to a ulong variable, will hold os data length
826 * boot_get_kernel() tries to find a kernel image, verifies its integrity
827 * and locates kernel data.
830 * pointer to image header if valid image was found, plus kernel start
831 * address and length, otherwise NULL
833 static void *boot_get_kernel(cmd_tbl_t *cmdtp, int flag, int argc,
834 char * const argv[], bootm_headers_t *images, ulong *os_data,
839 #if defined(CONFIG_FIT)
841 const char *fit_uname_config = NULL;
842 const char *fit_uname_kernel = NULL;
849 /* find out kernel image address */
851 img_addr = load_addr;
852 debug("* kernel: default image load address = 0x%08lx\n",
854 #if defined(CONFIG_FIT)
855 } else if (fit_parse_conf(argv[1], load_addr, &img_addr,
856 &fit_uname_config)) {
857 debug("* kernel: config '%s' from image at 0x%08lx\n",
858 fit_uname_config, img_addr);
859 } else if (fit_parse_subimage(argv[1], load_addr, &img_addr,
860 &fit_uname_kernel)) {
861 debug("* kernel: subimage '%s' from image at 0x%08lx\n",
862 fit_uname_kernel, img_addr);
865 img_addr = simple_strtoul(argv[1], NULL, 16);
866 debug("* kernel: cmdline image address = 0x%08lx\n", img_addr);
869 bootstage_mark(BOOTSTAGE_ID_CHECK_MAGIC);
871 /* copy from dataflash if needed */
872 img_addr = genimg_get_image(img_addr);
874 /* check image type, for FIT images get FIT kernel node */
875 *os_data = *os_len = 0;
876 switch (genimg_get_format((void *)img_addr)) {
877 case IMAGE_FORMAT_LEGACY:
878 printf("## Booting kernel from Legacy Image at %08lx ...\n",
880 hdr = image_get_kernel(img_addr, images->verify);
883 bootstage_mark(BOOTSTAGE_ID_CHECK_IMAGETYPE);
885 /* get os_data and os_len */
886 switch (image_get_type(hdr)) {
888 case IH_TYPE_KERNEL_NOLOAD:
889 *os_data = image_get_data(hdr);
890 *os_len = image_get_data_size(hdr);
893 image_multi_getimg(hdr, 0, os_data, os_len);
895 case IH_TYPE_STANDALONE:
896 *os_data = image_get_data(hdr);
897 *os_len = image_get_data_size(hdr);
900 printf("Wrong Image Type for %s command\n",
902 bootstage_error(BOOTSTAGE_ID_CHECK_IMAGETYPE);
907 * copy image header to allow for image overwrites during
908 * kernel decompression.
910 memmove(&images->legacy_hdr_os_copy, hdr,
911 sizeof(image_header_t));
913 /* save pointer to image header */
914 images->legacy_hdr_os = hdr;
916 images->legacy_hdr_valid = 1;
917 bootstage_mark(BOOTSTAGE_ID_DECOMP_IMAGE);
919 #if defined(CONFIG_FIT)
920 case IMAGE_FORMAT_FIT:
921 fit_hdr = (void *)img_addr;
922 printf("## Booting kernel from FIT Image at %08lx ...\n",
925 if (!fit_check_format(fit_hdr)) {
926 puts("Bad FIT kernel image format!\n");
927 bootstage_error(BOOTSTAGE_ID_FIT_FORMAT);
930 bootstage_mark(BOOTSTAGE_ID_FIT_FORMAT);
932 if (!fit_uname_kernel) {
934 * no kernel image node unit name, try to get config
935 * node first. If config unit node name is NULL
936 * fit_conf_get_node() will try to find default config
939 bootstage_mark(BOOTSTAGE_ID_FIT_NO_UNIT_NAME);
940 cfg_noffset = fit_conf_get_node(fit_hdr,
942 if (cfg_noffset < 0) {
943 bootstage_error(BOOTSTAGE_ID_FIT_NO_UNIT_NAME);
946 /* save configuration uname provided in the first
949 images->fit_uname_cfg = fdt_get_name(fit_hdr,
952 printf(" Using '%s' configuration\n",
953 images->fit_uname_cfg);
954 bootstage_mark(BOOTSTAGE_ID_FIT_CONFIG);
956 os_noffset = fit_conf_get_kernel_node(fit_hdr,
958 fit_uname_kernel = fit_get_name(fit_hdr, os_noffset,
961 /* get kernel component image node offset */
962 bootstage_mark(BOOTSTAGE_ID_FIT_UNIT_NAME);
963 os_noffset = fit_image_get_node(fit_hdr,
966 if (os_noffset < 0) {
967 bootstage_error(BOOTSTAGE_ID_FIT_CONFIG);
971 printf(" Trying '%s' kernel subimage\n", fit_uname_kernel);
973 bootstage_mark(BOOTSTAGE_ID_FIT_CHECK_SUBIMAGE);
974 if (!fit_check_kernel(fit_hdr, os_noffset, images->verify))
977 /* get kernel image data address and length */
978 if (fit_image_get_data(fit_hdr, os_noffset, &data, &len)) {
979 puts("Could not find kernel subimage data!\n");
980 bootstage_error(BOOTSTAGE_ID_FIT_KERNEL_INFO_ERR);
983 bootstage_mark(BOOTSTAGE_ID_FIT_KERNEL_INFO);
986 *os_data = (ulong)data;
987 images->fit_hdr_os = fit_hdr;
988 images->fit_uname_os = fit_uname_kernel;
989 images->fit_noffset_os = os_noffset;
993 printf("Wrong Image Format for %s command\n", cmdtp->name);
994 bootstage_error(BOOTSTAGE_ID_FIT_KERNEL_INFO);
998 debug(" kernel data at 0x%08lx, len = 0x%08lx (%ld)\n",
999 *os_data, *os_len, *os_len);
1001 return (void *)img_addr;
1005 bootm, CONFIG_SYS_MAXARGS, 1, do_bootm,
1006 "boot application image from memory",
1007 "[addr [arg ...]]\n - boot application image stored in memory\n"
1008 "\tpassing arguments 'arg ...'; when booting a Linux kernel,\n"
1009 "\t'arg' can be the address of an initrd image\n"
1010 #if defined(CONFIG_OF_LIBFDT)
1011 "\tWhen booting a Linux kernel which requires a flat device-tree\n"
1012 "\ta third argument is required which is the address of the\n"
1013 "\tdevice-tree blob. To boot that kernel without an initrd image,\n"
1014 "\tuse a '-' for the second argument. If you do not pass a third\n"
1015 "\ta bd_info struct will be passed instead\n"
1017 #if defined(CONFIG_FIT)
1018 "\t\nFor the new multi component uImage format (FIT) addresses\n"
1019 "\tmust be extened to include component or configuration unit name:\n"
1020 "\taddr:<subimg_uname> - direct component image specification\n"
1021 "\taddr#<conf_uname> - configuration specification\n"
1022 "\tUse iminfo command to get the list of existing component\n"
1023 "\timages and configurations.\n"
1025 "\nSub-commands to do part of the bootm sequence. The sub-commands "
1027 "issued in the order below (it's ok to not issue all sub-commands):\n"
1028 "\tstart [addr [arg ...]]\n"
1029 "\tloados - load OS image\n"
1030 #if defined(CONFIG_PPC) || defined(CONFIG_M68K) || defined(CONFIG_SPARC)
1031 "\tramdisk - relocate initrd, set env initrd_start/initrd_end\n"
1033 #if defined(CONFIG_OF_LIBFDT)
1034 "\tfdt - relocate flat device tree\n"
1036 "\tcmdline - OS specific command line processing/setup\n"
1037 "\tbdt - OS specific bd_t processing\n"
1038 "\tprep - OS specific prep before relocation or go\n"
1042 /*******************************************************************/
1043 /* bootd - boot default image */
1044 /*******************************************************************/
1045 #if defined(CONFIG_CMD_BOOTD)
1046 int do_bootd(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
1050 if (run_command(getenv("bootcmd"), flag) < 0)
1056 boot, 1, 1, do_bootd,
1057 "boot default, i.e., run 'bootcmd'",
1061 /* keep old command name "bootd" for backward compatibility */
1063 bootd, 1, 1, do_bootd,
1064 "boot default, i.e., run 'bootcmd'",
1071 /*******************************************************************/
1072 /* iminfo - print header info for a requested image */
1073 /*******************************************************************/
1074 #if defined(CONFIG_CMD_IMI)
1075 int do_iminfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
1082 return image_info(load_addr);
1085 for (arg = 1; arg < argc; ++arg) {
1086 addr = simple_strtoul(argv[arg], NULL, 16);
1087 if (image_info(addr) != 0)
1093 static int image_info(ulong addr)
1095 void *hdr = (void *)addr;
1097 printf("\n## Checking Image at %08lx ...\n", addr);
1099 switch (genimg_get_format(hdr)) {
1100 case IMAGE_FORMAT_LEGACY:
1101 puts(" Legacy image found\n");
1102 if (!image_check_magic(hdr)) {
1103 puts(" Bad Magic Number\n");
1107 if (!image_check_hcrc(hdr)) {
1108 puts(" Bad Header Checksum\n");
1112 image_print_contents(hdr);
1114 puts(" Verifying Checksum ... ");
1115 if (!image_check_dcrc(hdr)) {
1116 puts(" Bad Data CRC\n");
1121 #if defined(CONFIG_FIT)
1122 case IMAGE_FORMAT_FIT:
1123 puts(" FIT image found\n");
1125 if (!fit_check_format(hdr)) {
1126 puts("Bad FIT image format!\n");
1130 fit_print_contents(hdr);
1132 if (!fit_all_image_check_hashes(hdr)) {
1133 puts("Bad hash in FIT image!\n");
1140 puts("Unknown image format!\n");
1148 iminfo, CONFIG_SYS_MAXARGS, 1, do_iminfo,
1149 "print header information for application image",
1151 " - print header information for application image starting at\n"
1152 " address 'addr' in memory; this includes verification of the\n"
1153 " image contents (magic number, header and payload checksums)"
1158 /*******************************************************************/
1159 /* imls - list all images found in flash */
1160 /*******************************************************************/
1161 #if defined(CONFIG_CMD_IMLS)
1162 int do_imls(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
1168 for (i = 0, info = &flash_info[0];
1169 i < CONFIG_SYS_MAX_FLASH_BANKS; ++i, ++info) {
1171 if (info->flash_id == FLASH_UNKNOWN)
1173 for (j = 0; j < info->sector_count; ++j) {
1175 hdr = (void *)info->start[j];
1179 switch (genimg_get_format(hdr)) {
1180 case IMAGE_FORMAT_LEGACY:
1181 if (!image_check_hcrc(hdr))
1184 printf("Legacy Image at %08lX:\n", (ulong)hdr);
1185 image_print_contents(hdr);
1187 puts(" Verifying Checksum ... ");
1188 if (!image_check_dcrc(hdr)) {
1189 puts("Bad Data CRC\n");
1194 #if defined(CONFIG_FIT)
1195 case IMAGE_FORMAT_FIT:
1196 if (!fit_check_format(hdr))
1199 printf("FIT Image at %08lX:\n", (ulong)hdr);
1200 fit_print_contents(hdr);
1216 imls, 1, 1, do_imls,
1217 "list all images found in flash",
1219 " - Prints information about all images found at sector\n"
1220 " boundaries in flash."
1224 /*******************************************************************/
1225 /* helper routines */
1226 /*******************************************************************/
1227 #ifdef CONFIG_SILENT_CONSOLE
1228 static void fixup_silent_linux(void)
1230 char buf[256], *start, *end;
1231 char *cmdline = getenv("bootargs");
1233 /* Only fix cmdline when requested */
1234 if (!(gd->flags & GD_FLG_SILENT))
1237 debug("before silent fix-up: %s\n", cmdline);
1239 start = strstr(cmdline, "console=");
1241 end = strchr(start, ' ');
1242 strncpy(buf, cmdline, (start - cmdline + 8));
1244 strcpy(buf + (start - cmdline + 8), end);
1246 buf[start - cmdline + 8] = '\0';
1248 strcpy(buf, cmdline);
1249 strcat(buf, " console=");
1252 strcpy(buf, "console=");
1255 setenv("bootargs", buf);
1256 debug("after silent fix-up: %s\n", buf);
1258 #endif /* CONFIG_SILENT_CONSOLE */
1261 /*******************************************************************/
1262 /* OS booting routines */
1263 /*******************************************************************/
1265 #ifdef CONFIG_BOOTM_NETBSD
1266 static int do_bootm_netbsd(int flag, int argc, char * const argv[],
1267 bootm_headers_t *images)
1269 void (*loader)(bd_t *, image_header_t *, char *, char *);
1270 image_header_t *os_hdr, *hdr;
1271 ulong kernel_data, kernel_len;
1275 if ((flag != 0) && (flag != BOOTM_STATE_OS_GO))
1278 #if defined(CONFIG_FIT)
1279 if (!images->legacy_hdr_valid) {
1280 fit_unsupported_reset("NetBSD");
1284 hdr = images->legacy_hdr_os;
1287 * Booting a (NetBSD) kernel image
1289 * This process is pretty similar to a standalone application:
1290 * The (first part of an multi-) image must be a stage-2 loader,
1291 * which in turn is responsible for loading & invoking the actual
1292 * kernel. The only differences are the parameters being passed:
1293 * besides the board info strucure, the loader expects a command
1294 * line, the name of the console device, and (optionally) the
1295 * address of the original image header.
1298 if (image_check_type(&images->legacy_hdr_os_copy, IH_TYPE_MULTI)) {
1299 image_multi_getimg(hdr, 1, &kernel_data, &kernel_len);
1305 #if defined(CONFIG_8xx_CONS_SMC1)
1307 #elif defined(CONFIG_8xx_CONS_SMC2)
1309 #elif defined(CONFIG_8xx_CONS_SCC2)
1311 #elif defined(CONFIG_8xx_CONS_SCC3)
1319 for (i = 2, len = 0; i < argc; i += 1)
1320 len += strlen(argv[i]) + 1;
1321 cmdline = malloc(len);
1323 for (i = 2, len = 0; i < argc; i += 1) {
1325 cmdline[len++] = ' ';
1326 strcpy(&cmdline[len], argv[i]);
1327 len += strlen(argv[i]);
1329 } else if ((cmdline = getenv("bootargs")) == NULL) {
1333 loader = (void (*)(bd_t *, image_header_t *, char *, char *))images->ep;
1335 printf("## Transferring control to NetBSD stage-2 loader "
1336 "(at address %08lx) ...\n",
1339 bootstage_mark(BOOTSTAGE_ID_RUN_OS);
1342 * NetBSD Stage-2 Loader Parameters:
1343 * r3: ptr to board info data
1345 * r5: console device
1346 * r6: boot args string
1348 (*loader)(gd->bd, os_hdr, consdev, cmdline);
1352 #endif /* CONFIG_BOOTM_NETBSD*/
1354 #ifdef CONFIG_LYNXKDI
1355 static int do_bootm_lynxkdi(int flag, int argc, char * const argv[],
1356 bootm_headers_t *images)
1358 image_header_t *hdr = &images->legacy_hdr_os_copy;
1360 if ((flag != 0) && (flag != BOOTM_STATE_OS_GO))
1363 #if defined(CONFIG_FIT)
1364 if (!images->legacy_hdr_valid) {
1365 fit_unsupported_reset("Lynx");
1370 lynxkdi_boot((image_header_t *)hdr);
1374 #endif /* CONFIG_LYNXKDI */
1376 #ifdef CONFIG_BOOTM_RTEMS
1377 static int do_bootm_rtems(int flag, int argc, char * const argv[],
1378 bootm_headers_t *images)
1380 void (*entry_point)(bd_t *);
1382 if ((flag != 0) && (flag != BOOTM_STATE_OS_GO))
1385 #if defined(CONFIG_FIT)
1386 if (!images->legacy_hdr_valid) {
1387 fit_unsupported_reset("RTEMS");
1392 entry_point = (void (*)(bd_t *))images->ep;
1394 printf("## Transferring control to RTEMS (at address %08lx) ...\n",
1395 (ulong)entry_point);
1397 bootstage_mark(BOOTSTAGE_ID_RUN_OS);
1401 * r3: ptr to board info data
1403 (*entry_point)(gd->bd);
1407 #endif /* CONFIG_BOOTM_RTEMS */
1409 #if defined(CONFIG_BOOTM_OSE)
1410 static int do_bootm_ose(int flag, int argc, char * const argv[],
1411 bootm_headers_t *images)
1413 void (*entry_point)(void);
1415 if ((flag != 0) && (flag != BOOTM_STATE_OS_GO))
1418 #if defined(CONFIG_FIT)
1419 if (!images->legacy_hdr_valid) {
1420 fit_unsupported_reset("OSE");
1425 entry_point = (void (*)(void))images->ep;
1427 printf("## Transferring control to OSE (at address %08lx) ...\n",
1428 (ulong)entry_point);
1430 bootstage_mark(BOOTSTAGE_ID_RUN_OS);
1440 #endif /* CONFIG_BOOTM_OSE */
1442 #if defined(CONFIG_CMD_ELF)
1443 static int do_bootm_vxworks(int flag, int argc, char * const argv[],
1444 bootm_headers_t *images)
1448 if ((flag != 0) && (flag != BOOTM_STATE_OS_GO))
1451 #if defined(CONFIG_FIT)
1452 if (!images->legacy_hdr_valid) {
1453 fit_unsupported_reset("VxWorks");
1458 sprintf(str, "%lx", images->ep); /* write entry-point into string */
1459 setenv("loadaddr", str);
1460 do_bootvx(NULL, 0, 0, NULL);
1465 static int do_bootm_qnxelf(int flag, int argc, char * const argv[],
1466 bootm_headers_t *images)
1468 char *local_args[2];
1471 if ((flag != 0) && (flag != BOOTM_STATE_OS_GO))
1474 #if defined(CONFIG_FIT)
1475 if (!images->legacy_hdr_valid) {
1476 fit_unsupported_reset("QNX");
1481 sprintf(str, "%lx", images->ep); /* write entry-point into string */
1482 local_args[0] = argv[0];
1483 local_args[1] = str; /* and provide it via the arguments */
1484 do_bootelf(NULL, 0, 2, local_args);
1490 #ifdef CONFIG_INTEGRITY
1491 static int do_bootm_integrity(int flag, int argc, char * const argv[],
1492 bootm_headers_t *images)
1494 void (*entry_point)(void);
1496 if ((flag != 0) && (flag != BOOTM_STATE_OS_GO))
1499 #if defined(CONFIG_FIT)
1500 if (!images->legacy_hdr_valid) {
1501 fit_unsupported_reset("INTEGRITY");
1506 entry_point = (void (*)(void))images->ep;
1508 printf("## Transferring control to INTEGRITY (at address %08lx) ...\n",
1509 (ulong)entry_point);
1511 bootstage_mark(BOOTSTAGE_ID_RUN_OS);
1514 * INTEGRITY Parameters:
1523 #ifdef CONFIG_CMD_BOOTZ
1525 static int __bootz_setup(void *image, void **start, void **end)
1527 /* Please define bootz_setup() for your platform */
1529 puts("Your platform's zImage format isn't supported yet!\n");
1532 int bootz_setup(void *image, void **start, void **end)
1533 __attribute__((weak, alias("__bootz_setup")));
1536 * zImage booting support
1538 static int bootz_start(cmd_tbl_t *cmdtp, int flag, int argc,
1539 char * const argv[], bootm_headers_t *images)
1542 void *zi_start, *zi_end;
1544 memset(images, 0, sizeof(bootm_headers_t));
1546 boot_start_lmb(images);
1548 /* Setup Linux kernel zImage entry point */
1550 images->ep = load_addr;
1551 debug("* kernel: default image load address = 0x%08lx\n",
1554 images->ep = simple_strtoul(argv[1], NULL, 16);
1555 debug("* kernel: cmdline image address = 0x%08lx\n",
1559 ret = bootz_setup((void *)images->ep, &zi_start, &zi_end);
1563 lmb_reserve(&images->lmb, images->ep, zi_end - zi_start);
1566 ret = boot_get_ramdisk(argc, argv, images, IH_INITRD_ARCH,
1567 &images->rd_start, &images->rd_end);
1569 puts("Ramdisk image is corrupt or invalid\n");
1573 #if defined(CONFIG_OF_LIBFDT)
1574 /* find flattened device tree */
1575 ret = boot_get_fdt(flag, argc, argv, images,
1576 &images->ft_addr, &images->ft_len);
1578 puts("Could not find a valid device tree\n");
1582 set_working_fdt_addr(images->ft_addr);
1588 static int do_bootz(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
1591 bootm_headers_t images;
1593 if (bootz_start(cmdtp, flag, argc, argv, &images))
1597 * We have reached the point of no return: we are going to
1598 * overwrite all exception vector code, so we cannot easily
1599 * recover from any failures any more...
1601 iflag = disable_interrupts();
1603 #if defined(CONFIG_CMD_USB)
1605 * turn off USB to prevent the host controller from writing to the
1606 * SDRAM while Linux is booting. This could happen (at least for OHCI
1607 * controller), because the HCCA (Host Controller Communication Area)
1608 * lies within the SDRAM and the host controller writes continously to
1609 * this area (as busmaster!). The HccaFrameNumber is for example
1610 * updated every 1 ms within the HCCA structure in SDRAM! For more
1611 * details see the OpenHCI specification.
1616 #ifdef CONFIG_SILENT_CONSOLE
1617 fixup_silent_linux();
1621 do_bootm_linux(0, argc, argv, &images);
1623 puts("\n## Control returned to monitor - resetting...\n");
1625 do_reset(cmdtp, flag, argc, argv);
1631 bootz, CONFIG_SYS_MAXARGS, 1, do_bootz,
1632 "boot Linux zImage image from memory",
1633 "[addr [initrd[:size]] [fdt]]\n"
1634 " - boot Linux zImage stored in memory\n"
1635 "\tThe argument 'initrd' is optional and specifies the address\n"
1636 "\tof the initrd in memory. The optional argument ':size' allows\n"
1637 "\tspecifying the size of RAW initrd.\n"
1638 #if defined(CONFIG_OF_LIBFDT)
1639 "\tWhen booting a Linux kernel which requires a flat device-tree\n"
1640 "\ta third argument is required which is the address of the\n"
1641 "\tdevice-tree blob. To boot that kernel without an initrd image,\n"
1642 "\tuse a '-' for the second argument. If you do not pass a third\n"
1643 "\ta bd_info struct will be passed instead\n"
1646 #endif /* CONFIG_CMD_BOOTZ */