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 const void *boot_get_kernel(cmd_tbl_t *cmdtp, int flag, int argc,
97 char * const argv[], bootm_headers_t *images,
98 ulong *os_data, ulong *os_len);
101 * Continue booting an OS image; caller already has:
102 * - copied image header to global variable `header'
103 * - checked header magic number, checksums (both header & image),
104 * - verified image architecture (PPC) and type (KERNEL or MULTI),
105 * - loaded (first part of) image to header load address,
106 * - disabled interrupts.
108 * @flag: Command flags (CMD_FLAG_...)
109 * @argc: Number of arguments. Note that the arguments are shifted down
110 * so that 0 is the first argument not processed by U-Boot, and
111 * argc is adjusted accordingly. This avoids confusion as to how
112 * many arguments are available for the OS.
113 * @images: Pointers to os/initrd/fdt
114 * @return 1 on error. On success the OS boots so this function does
117 typedef int boot_os_fn(int flag, int argc, char * const argv[],
118 bootm_headers_t *images);
120 #ifdef CONFIG_BOOTM_LINUX
121 extern boot_os_fn do_bootm_linux;
123 #ifdef CONFIG_BOOTM_NETBSD
124 static boot_os_fn do_bootm_netbsd;
126 #if defined(CONFIG_LYNXKDI)
127 static boot_os_fn do_bootm_lynxkdi;
128 extern void lynxkdi_boot(image_header_t *);
130 #ifdef CONFIG_BOOTM_RTEMS
131 static boot_os_fn do_bootm_rtems;
133 #if defined(CONFIG_BOOTM_OSE)
134 static boot_os_fn do_bootm_ose;
136 #if defined(CONFIG_BOOTM_PLAN9)
137 static boot_os_fn do_bootm_plan9;
139 #if defined(CONFIG_CMD_ELF)
140 static boot_os_fn do_bootm_vxworks;
141 static boot_os_fn do_bootm_qnxelf;
142 int do_bootvx(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
143 int do_bootelf(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
145 #if defined(CONFIG_INTEGRITY)
146 static boot_os_fn do_bootm_integrity;
149 static boot_os_fn *boot_os[] = {
150 #ifdef CONFIG_BOOTM_LINUX
151 [IH_OS_LINUX] = do_bootm_linux,
153 #ifdef CONFIG_BOOTM_NETBSD
154 [IH_OS_NETBSD] = do_bootm_netbsd,
156 #ifdef CONFIG_LYNXKDI
157 [IH_OS_LYNXOS] = do_bootm_lynxkdi,
159 #ifdef CONFIG_BOOTM_RTEMS
160 [IH_OS_RTEMS] = do_bootm_rtems,
162 #if defined(CONFIG_BOOTM_OSE)
163 [IH_OS_OSE] = do_bootm_ose,
165 #if defined(CONFIG_BOOTM_PLAN9)
166 [IH_OS_PLAN9] = do_bootm_plan9,
168 #if defined(CONFIG_CMD_ELF)
169 [IH_OS_VXWORKS] = do_bootm_vxworks,
170 [IH_OS_QNX] = do_bootm_qnxelf,
172 #ifdef CONFIG_INTEGRITY
173 [IH_OS_INTEGRITY] = do_bootm_integrity,
177 bootm_headers_t images; /* pointers to os/initrd/fdt images */
179 /* Allow for arch specific config before we boot */
180 static void __arch_preboot_os(void)
182 /* please define platform specific arch_preboot_os() */
184 void arch_preboot_os(void) __attribute__((weak, alias("__arch_preboot_os")));
186 #define IH_INITRD_ARCH IH_ARCH_DEFAULT
189 static void boot_start_lmb(bootm_headers_t *images)
192 phys_size_t mem_size;
194 lmb_init(&images->lmb);
196 mem_start = getenv_bootm_low();
197 mem_size = getenv_bootm_size();
199 lmb_add(&images->lmb, (phys_addr_t)mem_start, mem_size);
201 arch_lmb_reserve(&images->lmb);
202 board_lmb_reserve(&images->lmb);
205 #define lmb_reserve(lmb, base, size)
206 static inline void boot_start_lmb(bootm_headers_t *images) { }
209 static int bootm_start(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
214 memset((void *)&images, 0, sizeof(images));
215 images.verify = getenv_yesno("verify");
217 boot_start_lmb(&images);
219 bootstage_mark_name(BOOTSTAGE_ID_BOOTM_START, "bootm_start");
221 /* get kernel image header, start address and length */
222 os_hdr = boot_get_kernel(cmdtp, flag, argc, argv,
223 &images, &images.os.image_start, &images.os.image_len);
224 if (images.os.image_len == 0) {
225 puts("ERROR: can't get kernel image!\n");
229 /* get image parameters */
230 switch (genimg_get_format(os_hdr)) {
231 case IMAGE_FORMAT_LEGACY:
232 images.os.type = image_get_type(os_hdr);
233 images.os.comp = image_get_comp(os_hdr);
234 images.os.os = image_get_os(os_hdr);
236 images.os.end = image_get_image_end(os_hdr);
237 images.os.load = image_get_load(os_hdr);
239 #if defined(CONFIG_FIT)
240 case IMAGE_FORMAT_FIT:
241 if (fit_image_get_type(images.fit_hdr_os,
242 images.fit_noffset_os, &images.os.type)) {
243 puts("Can't get image type!\n");
244 bootstage_error(BOOTSTAGE_ID_FIT_TYPE);
248 if (fit_image_get_comp(images.fit_hdr_os,
249 images.fit_noffset_os, &images.os.comp)) {
250 puts("Can't get image compression!\n");
251 bootstage_error(BOOTSTAGE_ID_FIT_COMPRESSION);
255 if (fit_image_get_os(images.fit_hdr_os,
256 images.fit_noffset_os, &images.os.os)) {
257 puts("Can't get image OS!\n");
258 bootstage_error(BOOTSTAGE_ID_FIT_OS);
262 images.os.end = fit_get_end(images.fit_hdr_os);
264 if (fit_image_get_load(images.fit_hdr_os, images.fit_noffset_os,
266 puts("Can't get image load address!\n");
267 bootstage_error(BOOTSTAGE_ID_FIT_LOADADDR);
273 puts("ERROR: unknown image format type!\n");
277 /* find kernel entry point */
278 if (images.legacy_hdr_valid) {
279 images.ep = image_get_ep(&images.legacy_hdr_os_copy);
280 #if defined(CONFIG_FIT)
281 } else if (images.fit_uname_os) {
282 ret = fit_image_get_entry(images.fit_hdr_os,
283 images.fit_noffset_os, &images.ep);
285 puts("Can't get entry point property!\n");
290 puts("Could not find kernel entry point!\n");
294 if (images.os.type == IH_TYPE_KERNEL_NOLOAD) {
295 images.os.load = images.os.image_start;
296 images.ep += images.os.load;
299 if (((images.os.type == IH_TYPE_KERNEL) ||
300 (images.os.type == IH_TYPE_KERNEL_NOLOAD) ||
301 (images.os.type == IH_TYPE_MULTI)) &&
302 (images.os.os == IH_OS_LINUX)) {
304 ret = boot_get_ramdisk(argc, argv, &images, IH_INITRD_ARCH,
305 &images.rd_start, &images.rd_end);
307 puts("Ramdisk image is corrupt or invalid\n");
311 #if defined(CONFIG_OF_LIBFDT)
312 /* find flattened device tree */
313 ret = boot_get_fdt(flag, argc, argv, IH_ARCH_DEFAULT, &images,
314 &images.ft_addr, &images.ft_len);
316 puts("Could not find a valid device tree\n");
320 set_working_fdt_addr(images.ft_addr);
324 images.os.start = (ulong)os_hdr;
325 images.state = BOOTM_STATE_START;
330 #define BOOTM_ERR_RESET -1
331 #define BOOTM_ERR_OVERLAP -2
332 #define BOOTM_ERR_UNIMPLEMENTED -3
333 static int bootm_load_os(image_info_t os, ulong *load_end, int boot_progress)
335 uint8_t comp = os.comp;
336 ulong load = os.load;
337 ulong blob_start = os.start;
338 ulong blob_end = os.end;
339 ulong image_start = os.image_start;
340 ulong image_len = os.image_len;
341 __maybe_unused uint unc_len = CONFIG_SYS_BOOTM_LEN;
343 void *load_buf, *image_buf;
344 #if defined(CONFIG_LZMA) || defined(CONFIG_LZO)
346 #endif /* defined(CONFIG_LZMA) || defined(CONFIG_LZO) */
348 const char *type_name = genimg_get_type_name(os.type);
350 load_buf = map_sysmem(load, image_len);
351 image_buf = map_sysmem(image_start, image_len);
354 if (load == blob_start || load == image_start) {
355 printf(" XIP %s ... ", type_name);
358 printf(" Loading %s ... ", type_name);
359 memmove_wd(load_buf, image_buf, image_len, CHUNKSZ);
361 *load_end = load + image_len;
366 printf(" Uncompressing %s ... ", type_name);
367 if (gunzip(load_buf, unc_len, image_buf, &image_len) != 0) {
368 puts("GUNZIP: uncompress, out-of-mem or overwrite "
369 "error - must RESET board to recover\n");
371 bootstage_error(BOOTSTAGE_ID_DECOMP_IMAGE);
372 return BOOTM_ERR_RESET;
375 *load_end = load + image_len;
377 #endif /* CONFIG_GZIP */
380 printf(" Uncompressing %s ... ", type_name);
382 * If we've got less than 4 MB of malloc() space,
383 * use slower decompression algorithm which requires
384 * at most 2300 KB of memory.
386 int i = BZ2_bzBuffToBuffDecompress(load_buf, &unc_len,
387 image_buf, image_len,
388 CONFIG_SYS_MALLOC_LEN < (4096 * 1024), 0);
390 printf("BUNZIP2: uncompress or overwrite error %d "
391 "- must RESET board to recover\n", i);
393 bootstage_error(BOOTSTAGE_ID_DECOMP_IMAGE);
394 return BOOTM_ERR_RESET;
397 *load_end = load + unc_len;
399 #endif /* CONFIG_BZIP2 */
402 SizeT lzma_len = unc_len;
403 printf(" Uncompressing %s ... ", type_name);
405 ret = lzmaBuffToBuffDecompress(load_buf, &lzma_len,
406 image_buf, image_len);
409 printf("LZMA: uncompress or overwrite error %d "
410 "- must RESET board to recover\n", ret);
411 bootstage_error(BOOTSTAGE_ID_DECOMP_IMAGE);
412 return BOOTM_ERR_RESET;
414 *load_end = load + unc_len;
417 #endif /* CONFIG_LZMA */
420 printf(" Uncompressing %s ... ", type_name);
422 ret = lzop_decompress(image_buf, image_len, load_buf,
424 if (ret != LZO_E_OK) {
425 printf("LZO: uncompress or overwrite error %d "
426 "- must RESET board to recover\n", ret);
428 bootstage_error(BOOTSTAGE_ID_DECOMP_IMAGE);
429 return BOOTM_ERR_RESET;
432 *load_end = load + unc_len;
434 #endif /* CONFIG_LZO */
436 printf("Unimplemented compression type %d\n", comp);
437 return BOOTM_ERR_UNIMPLEMENTED;
440 flush_cache(load, (*load_end - load) * sizeof(ulong));
443 debug(" kernel loaded at 0x%08lx, end = 0x%08lx\n", load, *load_end);
444 bootstage_mark(BOOTSTAGE_ID_KERNEL_LOADED);
446 if (!no_overlap && (load < blob_end) && (*load_end > blob_start)) {
447 debug("images.os.start = 0x%lX, images.os.end = 0x%lx\n",
448 blob_start, blob_end);
449 debug("images.os.load = 0x%lx, load_end = 0x%lx\n", load,
452 return BOOTM_ERR_OVERLAP;
458 static int bootm_start_standalone(ulong iflag, int argc, char * const argv[])
461 int (*appl)(int, char * const []);
463 /* Don't start if "autostart" is set to "no" */
464 if (((s = getenv("autostart")) != NULL) && (strcmp(s, "no") == 0)) {
465 setenv_hex("filesize", images.os.image_len);
468 appl = (int (*)(int, char * const []))(ulong)ntohl(images.ep);
473 /* we overload the cmd field with our state machine info instead of a
474 * function pointer */
475 static cmd_tbl_t cmd_bootm_sub[] = {
476 U_BOOT_CMD_MKENT(start, 0, 1, (void *)BOOTM_STATE_START, "", ""),
477 U_BOOT_CMD_MKENT(loados, 0, 1, (void *)BOOTM_STATE_LOADOS, "", ""),
478 #ifdef CONFIG_SYS_BOOT_RAMDISK_HIGH
479 U_BOOT_CMD_MKENT(ramdisk, 0, 1, (void *)BOOTM_STATE_RAMDISK, "", ""),
481 #ifdef CONFIG_OF_LIBFDT
482 U_BOOT_CMD_MKENT(fdt, 0, 1, (void *)BOOTM_STATE_FDT, "", ""),
484 U_BOOT_CMD_MKENT(cmdline, 0, 1, (void *)BOOTM_STATE_OS_CMDLINE, "", ""),
485 U_BOOT_CMD_MKENT(bdt, 0, 1, (void *)BOOTM_STATE_OS_BD_T, "", ""),
486 U_BOOT_CMD_MKENT(prep, 0, 1, (void *)BOOTM_STATE_OS_PREP, "", ""),
487 U_BOOT_CMD_MKENT(go, 0, 1, (void *)BOOTM_STATE_OS_GO, "", ""),
490 static int do_bootm_subcommand(cmd_tbl_t *cmdtp, int flag, int argc,
498 c = find_cmd_tbl(argv[0], &cmd_bootm_sub[0], ARRAY_SIZE(cmd_bootm_sub));
502 state = (long)c->cmd;
504 /* treat start special since it resets the state machine */
505 if (state == BOOTM_STATE_START)
506 return bootm_start(cmdtp, flag, argc, argv);
508 /* Unrecognized command */
509 return CMD_RET_USAGE;
512 if (images.state < BOOTM_STATE_START ||
513 images.state >= state) {
514 printf("Trying to execute a command out of order\n");
515 return CMD_RET_USAGE;
518 images.state |= state;
519 boot_fn = boot_os[images.os.os];
523 case BOOTM_STATE_START:
524 /* should never occur */
526 case BOOTM_STATE_LOADOS:
527 ret = bootm_load_os(images.os, &load_end, 0);
531 lmb_reserve(&images.lmb, images.os.load,
532 (load_end - images.os.load));
534 #ifdef CONFIG_SYS_BOOT_RAMDISK_HIGH
535 case BOOTM_STATE_RAMDISK:
537 ulong rd_len = images.rd_end - images.rd_start;
539 ret = boot_ramdisk_high(&images.lmb, images.rd_start,
540 rd_len, &images.initrd_start, &images.initrd_end);
544 setenv_hex("initrd_start", images.initrd_start);
545 setenv_hex("initrd_end", images.initrd_end);
549 #if defined(CONFIG_OF_LIBFDT) && defined(CONFIG_LMB)
550 case BOOTM_STATE_FDT:
552 boot_fdt_add_mem_rsv_regions(&images.lmb,
554 ret = boot_relocate_fdt(&images.lmb,
555 &images.ft_addr, &images.ft_len);
559 case BOOTM_STATE_OS_CMDLINE:
560 ret = boot_fn(BOOTM_STATE_OS_CMDLINE, argc, argv, &images);
562 printf("cmdline subcommand not supported\n");
564 case BOOTM_STATE_OS_BD_T:
565 ret = boot_fn(BOOTM_STATE_OS_BD_T, argc, argv, &images);
567 printf("bdt subcommand not supported\n");
569 case BOOTM_STATE_OS_PREP:
570 ret = boot_fn(BOOTM_STATE_OS_PREP, argc, argv, &images);
572 printf("prep subcommand not supported\n");
574 case BOOTM_STATE_OS_GO:
575 disable_interrupts();
576 #ifdef CONFIG_NETCONSOLE
578 * Stop the ethernet stack if NetConsole could have
584 boot_fn(BOOTM_STATE_OS_GO, argc, argv, &images);
591 /*******************************************************************/
592 /* bootm - boot application image from image in memory */
593 /*******************************************************************/
595 int do_bootm(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
601 #ifdef CONFIG_NEEDS_MANUAL_RELOC
602 static int relocated = 0;
607 /* relocate boot function table */
608 for (i = 0; i < ARRAY_SIZE(boot_os); i++)
609 if (boot_os[i] != NULL)
610 boot_os[i] += gd->reloc_off;
612 /* relocate names of sub-command table */
613 for (i = 0; i < ARRAY_SIZE(cmd_bootm_sub); i++)
614 cmd_bootm_sub[i].name += gd->reloc_off;
620 /* determine if we have a sub command */
625 simple_strtoul(argv[0], &endp, 16);
626 /* endp pointing to NULL means that argv[0] was just a
627 * valid number, pass it along to the normal bootm processing
629 * If endp is ':' or '#' assume a FIT identifier so pass
630 * along for normal processing.
632 * Right now we assume the first arg should never be '-'
634 if ((*endp != 0) && (*endp != ':') && (*endp != '#'))
635 return do_bootm_subcommand(cmdtp, flag, argc, argv);
638 if (bootm_start(cmdtp, flag, argc, argv))
642 * We have reached the point of no return: we are going to
643 * overwrite all exception vector code, so we cannot easily
644 * recover from any failures any more...
646 iflag = disable_interrupts();
648 #ifdef CONFIG_NETCONSOLE
649 /* Stop the ethernet stack if NetConsole could have left it up */
653 #if defined(CONFIG_CMD_USB)
655 * turn off USB to prevent the host controller from writing to the
656 * SDRAM while Linux is booting. This could happen (at least for OHCI
657 * controller), because the HCCA (Host Controller Communication Area)
658 * lies within the SDRAM and the host controller writes continously to
659 * this area (as busmaster!). The HccaFrameNumber is for example
660 * updated every 1 ms within the HCCA structure in SDRAM! For more
661 * details see the OpenHCI specification.
666 ret = bootm_load_os(images.os, &load_end, 1);
669 if (ret == BOOTM_ERR_RESET)
670 do_reset(cmdtp, flag, argc, argv);
671 if (ret == BOOTM_ERR_OVERLAP) {
672 if (images.legacy_hdr_valid) {
674 hdr = &images.legacy_hdr_os_copy;
675 if (image_get_type(hdr) == IH_TYPE_MULTI)
676 puts("WARNING: legacy format multi "
680 puts("ERROR: new format image overwritten - "
681 "must RESET the board to recover\n");
682 bootstage_error(BOOTSTAGE_ID_OVERWRITTEN);
683 do_reset(cmdtp, flag, argc, argv);
686 if (ret == BOOTM_ERR_UNIMPLEMENTED) {
689 bootstage_error(BOOTSTAGE_ID_DECOMP_UNIMPL);
694 lmb_reserve(&images.lmb, images.os.load, (load_end - images.os.load));
696 if (images.os.type == IH_TYPE_STANDALONE) {
699 /* This may return when 'autostart' is 'no' */
700 bootm_start_standalone(iflag, argc, argv);
704 bootstage_mark(BOOTSTAGE_ID_CHECK_BOOT_OS);
706 #if defined(CONFIG_SILENT_CONSOLE) && !defined(CONFIG_SILENT_U_BOOT_ONLY)
707 if (images.os.os == IH_OS_LINUX)
708 fixup_silent_linux();
711 boot_fn = boot_os[images.os.os];
713 if (boot_fn == NULL) {
716 printf("ERROR: booting os '%s' (%d) is not supported\n",
717 genimg_get_os_name(images.os.os), images.os.os);
718 bootstage_error(BOOTSTAGE_ID_CHECK_BOOT_OS);
724 boot_fn(0, argc, argv, &images);
726 bootstage_error(BOOTSTAGE_ID_BOOT_OS_RETURNED);
728 puts("\n## Control returned to monitor - resetting...\n");
730 do_reset(cmdtp, flag, argc, argv);
735 int bootm_maybe_autostart(cmd_tbl_t *cmdtp, const char *cmd)
737 const char *ep = getenv("autostart");
739 if (ep && !strcmp(ep, "yes")) {
741 local_args[0] = (char *)cmd;
742 local_args[1] = NULL;
743 printf("Automatic boot of image at addr 0x%08lX ...\n", load_addr);
744 return do_bootm(cmdtp, 0, 1, local_args);
751 * image_get_kernel - verify legacy format kernel image
752 * @img_addr: in RAM address of the legacy format image to be verified
753 * @verify: data CRC verification flag
755 * image_get_kernel() verifies legacy image integrity and returns pointer to
756 * legacy image header if image verification was completed successfully.
759 * pointer to a legacy image header if valid image was found
760 * otherwise return NULL
762 static image_header_t *image_get_kernel(ulong img_addr, int verify)
764 image_header_t *hdr = (image_header_t *)img_addr;
766 if (!image_check_magic(hdr)) {
767 puts("Bad Magic Number\n");
768 bootstage_error(BOOTSTAGE_ID_CHECK_MAGIC);
771 bootstage_mark(BOOTSTAGE_ID_CHECK_HEADER);
773 if (!image_check_hcrc(hdr)) {
774 puts("Bad Header Checksum\n");
775 bootstage_error(BOOTSTAGE_ID_CHECK_HEADER);
779 bootstage_mark(BOOTSTAGE_ID_CHECK_CHECKSUM);
780 image_print_contents(hdr);
783 puts(" Verifying Checksum ... ");
784 if (!image_check_dcrc(hdr)) {
785 printf("Bad Data CRC\n");
786 bootstage_error(BOOTSTAGE_ID_CHECK_CHECKSUM);
791 bootstage_mark(BOOTSTAGE_ID_CHECK_ARCH);
793 if (!image_check_target_arch(hdr)) {
794 printf("Unsupported Architecture 0x%x\n", image_get_arch(hdr));
795 bootstage_error(BOOTSTAGE_ID_CHECK_ARCH);
802 * boot_get_kernel - find kernel image
803 * @os_data: pointer to a ulong variable, will hold os data start address
804 * @os_len: pointer to a ulong variable, will hold os data length
806 * boot_get_kernel() tries to find a kernel image, verifies its integrity
807 * and locates kernel data.
810 * pointer to image header if valid image was found, plus kernel start
811 * address and length, otherwise NULL
813 static const void *boot_get_kernel(cmd_tbl_t *cmdtp, int flag, int argc,
814 char * const argv[], bootm_headers_t *images, ulong *os_data,
820 #if defined(CONFIG_FIT)
821 const char *fit_uname_config = NULL;
822 const char *fit_uname_kernel = NULL;
826 /* find out kernel image address */
828 img_addr = load_addr;
829 debug("* kernel: default image load address = 0x%08lx\n",
831 #if defined(CONFIG_FIT)
832 } else if (fit_parse_conf(argv[0], load_addr, &img_addr,
833 &fit_uname_config)) {
834 debug("* kernel: config '%s' from image at 0x%08lx\n",
835 fit_uname_config, img_addr);
836 } else if (fit_parse_subimage(argv[0], load_addr, &img_addr,
837 &fit_uname_kernel)) {
838 debug("* kernel: subimage '%s' from image at 0x%08lx\n",
839 fit_uname_kernel, img_addr);
842 img_addr = simple_strtoul(argv[0], NULL, 16);
843 debug("* kernel: cmdline image address = 0x%08lx\n", img_addr);
846 bootstage_mark(BOOTSTAGE_ID_CHECK_MAGIC);
848 /* copy from dataflash if needed */
849 img_addr = genimg_get_image(img_addr);
851 /* check image type, for FIT images get FIT kernel node */
852 *os_data = *os_len = 0;
853 buf = map_sysmem(img_addr, 0);
854 switch (genimg_get_format(buf)) {
855 case IMAGE_FORMAT_LEGACY:
856 printf("## Booting kernel from Legacy Image at %08lx ...\n",
858 hdr = image_get_kernel(img_addr, images->verify);
861 bootstage_mark(BOOTSTAGE_ID_CHECK_IMAGETYPE);
863 /* get os_data and os_len */
864 switch (image_get_type(hdr)) {
866 case IH_TYPE_KERNEL_NOLOAD:
867 *os_data = image_get_data(hdr);
868 *os_len = image_get_data_size(hdr);
871 image_multi_getimg(hdr, 0, os_data, os_len);
873 case IH_TYPE_STANDALONE:
874 *os_data = image_get_data(hdr);
875 *os_len = image_get_data_size(hdr);
878 printf("Wrong Image Type for %s command\n",
880 bootstage_error(BOOTSTAGE_ID_CHECK_IMAGETYPE);
885 * copy image header to allow for image overwrites during
886 * kernel decompression.
888 memmove(&images->legacy_hdr_os_copy, hdr,
889 sizeof(image_header_t));
891 /* save pointer to image header */
892 images->legacy_hdr_os = hdr;
894 images->legacy_hdr_valid = 1;
895 bootstage_mark(BOOTSTAGE_ID_DECOMP_IMAGE);
897 #if defined(CONFIG_FIT)
898 case IMAGE_FORMAT_FIT:
899 os_noffset = fit_image_load(images, FIT_KERNEL_PROP,
901 &fit_uname_kernel, fit_uname_config,
902 IH_ARCH_DEFAULT, IH_TYPE_KERNEL,
903 BOOTSTAGE_ID_FIT_KERNEL_START,
904 FIT_LOAD_IGNORED, os_data, os_len);
908 images->fit_hdr_os = map_sysmem(img_addr, 0);
909 images->fit_uname_os = fit_uname_kernel;
910 images->fit_noffset_os = os_noffset;
914 printf("Wrong Image Format for %s command\n", cmdtp->name);
915 bootstage_error(BOOTSTAGE_ID_FIT_KERNEL_INFO);
919 debug(" kernel data at 0x%08lx, len = 0x%08lx (%ld)\n",
920 *os_data, *os_len, *os_len);
925 #ifdef CONFIG_SYS_LONGHELP
926 static char bootm_help_text[] =
927 "[addr [arg ...]]\n - boot application image stored in memory\n"
928 "\tpassing arguments 'arg ...'; when booting a Linux kernel,\n"
929 "\t'arg' can be the address of an initrd image\n"
930 #if defined(CONFIG_OF_LIBFDT)
931 "\tWhen booting a Linux kernel which requires a flat device-tree\n"
932 "\ta third argument is required which is the address of the\n"
933 "\tdevice-tree blob. To boot that kernel without an initrd image,\n"
934 "\tuse a '-' for the second argument. If you do not pass a third\n"
935 "\ta bd_info struct will be passed instead\n"
937 #if defined(CONFIG_FIT)
938 "\t\nFor the new multi component uImage format (FIT) addresses\n"
939 "\tmust be extened to include component or configuration unit name:\n"
940 "\taddr:<subimg_uname> - direct component image specification\n"
941 "\taddr#<conf_uname> - configuration specification\n"
942 "\tUse iminfo command to get the list of existing component\n"
943 "\timages and configurations.\n"
945 "\nSub-commands to do part of the bootm sequence. The sub-commands "
947 "issued in the order below (it's ok to not issue all sub-commands):\n"
948 "\tstart [addr [arg ...]]\n"
949 "\tloados - load OS image\n"
950 #if defined(CONFIG_SYS_BOOT_RAMDISK_HIGH)
951 "\tramdisk - relocate initrd, set env initrd_start/initrd_end\n"
953 #if defined(CONFIG_OF_LIBFDT)
954 "\tfdt - relocate flat device tree\n"
956 "\tcmdline - OS specific command line processing/setup\n"
957 "\tbdt - OS specific bd_t processing\n"
958 "\tprep - OS specific prep before relocation or go\n"
963 bootm, CONFIG_SYS_MAXARGS, 1, do_bootm,
964 "boot application image from memory", bootm_help_text
967 /*******************************************************************/
968 /* bootd - boot default image */
969 /*******************************************************************/
970 #if defined(CONFIG_CMD_BOOTD)
971 int do_bootd(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
975 if (run_command(getenv("bootcmd"), flag) < 0)
981 boot, 1, 1, do_bootd,
982 "boot default, i.e., run 'bootcmd'",
986 /* keep old command name "bootd" for backward compatibility */
988 bootd, 1, 1, do_bootd,
989 "boot default, i.e., run 'bootcmd'",
996 /*******************************************************************/
997 /* iminfo - print header info for a requested image */
998 /*******************************************************************/
999 #if defined(CONFIG_CMD_IMI)
1000 static int do_iminfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
1007 return image_info(load_addr);
1010 for (arg = 1; arg < argc; ++arg) {
1011 addr = simple_strtoul(argv[arg], NULL, 16);
1012 if (image_info(addr) != 0)
1018 static int image_info(ulong addr)
1020 void *hdr = (void *)addr;
1022 printf("\n## Checking Image at %08lx ...\n", addr);
1024 switch (genimg_get_format(hdr)) {
1025 case IMAGE_FORMAT_LEGACY:
1026 puts(" Legacy image found\n");
1027 if (!image_check_magic(hdr)) {
1028 puts(" Bad Magic Number\n");
1032 if (!image_check_hcrc(hdr)) {
1033 puts(" Bad Header Checksum\n");
1037 image_print_contents(hdr);
1039 puts(" Verifying Checksum ... ");
1040 if (!image_check_dcrc(hdr)) {
1041 puts(" Bad Data CRC\n");
1046 #if defined(CONFIG_FIT)
1047 case IMAGE_FORMAT_FIT:
1048 puts(" FIT image found\n");
1050 if (!fit_check_format(hdr)) {
1051 puts("Bad FIT image format!\n");
1055 fit_print_contents(hdr);
1057 if (!fit_all_image_verify(hdr)) {
1058 puts("Bad hash in FIT image!\n");
1065 puts("Unknown image format!\n");
1073 iminfo, CONFIG_SYS_MAXARGS, 1, do_iminfo,
1074 "print header information for application image",
1076 " - print header information for application image starting at\n"
1077 " address 'addr' in memory; this includes verification of the\n"
1078 " image contents (magic number, header and payload checksums)"
1083 /*******************************************************************/
1084 /* imls - list all images found in flash */
1085 /*******************************************************************/
1086 #if defined(CONFIG_CMD_IMLS)
1087 static int do_imls_nor(void)
1093 for (i = 0, info = &flash_info[0];
1094 i < CONFIG_SYS_MAX_FLASH_BANKS; ++i, ++info) {
1096 if (info->flash_id == FLASH_UNKNOWN)
1098 for (j = 0; j < info->sector_count; ++j) {
1100 hdr = (void *)info->start[j];
1104 switch (genimg_get_format(hdr)) {
1105 case IMAGE_FORMAT_LEGACY:
1106 if (!image_check_hcrc(hdr))
1109 printf("Legacy Image at %08lX:\n", (ulong)hdr);
1110 image_print_contents(hdr);
1112 puts(" Verifying Checksum ... ");
1113 if (!image_check_dcrc(hdr)) {
1114 puts("Bad Data CRC\n");
1119 #if defined(CONFIG_FIT)
1120 case IMAGE_FORMAT_FIT:
1121 if (!fit_check_format(hdr))
1124 printf("FIT Image at %08lX:\n", (ulong)hdr);
1125 fit_print_contents(hdr);
1140 #if defined(CONFIG_CMD_IMLS_NAND)
1141 static int nand_imls_legacyimage(nand_info_t *nand, int nand_dev, loff_t off,
1147 imgdata = malloc(len);
1149 printf("May be a Legacy Image at NAND device %d offset %08llX:\n",
1151 printf(" Low memory(cannot allocate memory for image)\n");
1155 ret = nand_read_skip_bad(nand, off, &len,
1157 if (ret < 0 && ret != -EUCLEAN) {
1162 if (!image_check_hcrc(imgdata)) {
1167 printf("Legacy Image at NAND device %d offset %08llX:\n",
1169 image_print_contents(imgdata);
1171 puts(" Verifying Checksum ... ");
1172 if (!image_check_dcrc(imgdata))
1173 puts("Bad Data CRC\n");
1182 static int nand_imls_fitimage(nand_info_t *nand, int nand_dev, loff_t off,
1188 imgdata = malloc(len);
1190 printf("May be a FIT Image at NAND device %d offset %08llX:\n",
1192 printf(" Low memory(cannot allocate memory for image)\n");
1196 ret = nand_read_skip_bad(nand, off, &len,
1198 if (ret < 0 && ret != -EUCLEAN) {
1203 if (!fit_check_format(imgdata)) {
1208 printf("FIT Image at NAND device %d offset %08llX:\n", nand_dev, off);
1210 fit_print_contents(imgdata);
1216 static int do_imls_nand(void)
1219 int nand_dev = nand_curr_device;
1224 if (nand_dev < 0 || nand_dev >= CONFIG_SYS_MAX_NAND_DEVICE) {
1225 puts("\nNo NAND devices available\n");
1231 for (nand_dev = 0; nand_dev < CONFIG_SYS_MAX_NAND_DEVICE; nand_dev++) {
1232 nand = &nand_info[nand_dev];
1233 if (!nand->name || !nand->size)
1236 for (off = 0; off < nand->size; off += nand->erasesize) {
1237 const image_header_t *header;
1240 if (nand_block_isbad(nand, off))
1243 len = sizeof(buffer);
1245 ret = nand_read(nand, off, &len, (u8 *)buffer);
1246 if (ret < 0 && ret != -EUCLEAN) {
1247 printf("NAND read error %d at offset %08llX\n",
1252 switch (genimg_get_format(buffer)) {
1253 case IMAGE_FORMAT_LEGACY:
1254 header = (const image_header_t *)buffer;
1256 len = image_get_image_size(header);
1257 nand_imls_legacyimage(nand, nand_dev, off, len);
1259 #if defined(CONFIG_FIT)
1260 case IMAGE_FORMAT_FIT:
1261 len = fit_get_size(buffer);
1262 nand_imls_fitimage(nand, nand_dev, off, len);
1273 #if defined(CONFIG_CMD_IMLS) || defined(CONFIG_CMD_IMLS_NAND)
1274 static int do_imls(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
1276 int ret_nor = 0, ret_nand = 0;
1278 #if defined(CONFIG_CMD_IMLS)
1279 ret_nor = do_imls_nor();
1282 #if defined(CONFIG_CMD_IMLS_NAND)
1283 ret_nand = do_imls_nand();
1296 imls, 1, 1, do_imls,
1297 "list all images found in flash",
1299 " - Prints information about all images found at sector/block\n"
1300 " boundaries in nor/nand flash."
1304 /*******************************************************************/
1305 /* helper routines */
1306 /*******************************************************************/
1307 #if defined(CONFIG_SILENT_CONSOLE) && !defined(CONFIG_SILENT_U_BOOT_ONLY)
1309 #define CONSOLE_ARG "console="
1310 #define CONSOLE_ARG_LEN (sizeof(CONSOLE_ARG) - 1)
1312 static void fixup_silent_linux(void)
1315 const char *env_val;
1316 char *cmdline = getenv("bootargs");
1318 /* Only fix cmdline when requested */
1319 if (!(gd->flags & GD_FLG_SILENT))
1322 debug("before silent fix-up: %s\n", cmdline);
1323 if (cmdline && (cmdline[0] != '\0')) {
1324 char *start = strstr(cmdline, CONSOLE_ARG);
1326 /* Allocate space for maximum possible new command line */
1327 buf = malloc(strlen(cmdline) + 1 + CONSOLE_ARG_LEN + 1);
1329 debug("%s: out of memory\n", __func__);
1334 char *end = strchr(start, ' ');
1335 int num_start_bytes = start - cmdline + CONSOLE_ARG_LEN;
1337 strncpy(buf, cmdline, num_start_bytes);
1339 strcpy(buf + num_start_bytes, end);
1341 buf[num_start_bytes] = '\0';
1343 sprintf(buf, "%s %s", cmdline, CONSOLE_ARG);
1348 env_val = CONSOLE_ARG;
1351 setenv("bootargs", env_val);
1352 debug("after silent fix-up: %s\n", env_val);
1355 #endif /* CONFIG_SILENT_CONSOLE */
1358 /*******************************************************************/
1359 /* OS booting routines */
1360 /*******************************************************************/
1362 #ifdef CONFIG_BOOTM_NETBSD
1363 static int do_bootm_netbsd(int flag, int argc, char * const argv[],
1364 bootm_headers_t *images)
1366 void (*loader)(bd_t *, image_header_t *, char *, char *);
1367 image_header_t *os_hdr, *hdr;
1368 ulong kernel_data, kernel_len;
1372 if ((flag != 0) && (flag != BOOTM_STATE_OS_GO))
1375 #if defined(CONFIG_FIT)
1376 if (!images->legacy_hdr_valid) {
1377 fit_unsupported_reset("NetBSD");
1381 hdr = images->legacy_hdr_os;
1384 * Booting a (NetBSD) kernel image
1386 * This process is pretty similar to a standalone application:
1387 * The (first part of an multi-) image must be a stage-2 loader,
1388 * which in turn is responsible for loading & invoking the actual
1389 * kernel. The only differences are the parameters being passed:
1390 * besides the board info strucure, the loader expects a command
1391 * line, the name of the console device, and (optionally) the
1392 * address of the original image header.
1395 if (image_check_type(&images->legacy_hdr_os_copy, IH_TYPE_MULTI)) {
1396 image_multi_getimg(hdr, 1, &kernel_data, &kernel_len);
1402 #if defined(CONFIG_8xx_CONS_SMC1)
1404 #elif defined(CONFIG_8xx_CONS_SMC2)
1406 #elif defined(CONFIG_8xx_CONS_SCC2)
1408 #elif defined(CONFIG_8xx_CONS_SCC3)
1416 for (i = 0, len = 0; i < argc; i += 1)
1417 len += strlen(argv[i]) + 1;
1418 cmdline = malloc(len);
1420 for (i = 0, len = 0; i < argc; i += 1) {
1422 cmdline[len++] = ' ';
1423 strcpy(&cmdline[len], argv[i]);
1424 len += strlen(argv[i]);
1426 } else if ((cmdline = getenv("bootargs")) == NULL) {
1430 loader = (void (*)(bd_t *, image_header_t *, char *, char *))images->ep;
1432 printf("## Transferring control to NetBSD stage-2 loader "
1433 "(at address %08lx) ...\n",
1436 bootstage_mark(BOOTSTAGE_ID_RUN_OS);
1439 * NetBSD Stage-2 Loader Parameters:
1440 * r3: ptr to board info data
1442 * r5: console device
1443 * r6: boot args string
1445 (*loader)(gd->bd, os_hdr, consdev, cmdline);
1449 #endif /* CONFIG_BOOTM_NETBSD*/
1451 #ifdef CONFIG_LYNXKDI
1452 static int do_bootm_lynxkdi(int flag, int argc, char * const argv[],
1453 bootm_headers_t *images)
1455 image_header_t *hdr = &images->legacy_hdr_os_copy;
1457 if ((flag != 0) && (flag != BOOTM_STATE_OS_GO))
1460 #if defined(CONFIG_FIT)
1461 if (!images->legacy_hdr_valid) {
1462 fit_unsupported_reset("Lynx");
1467 lynxkdi_boot((image_header_t *)hdr);
1471 #endif /* CONFIG_LYNXKDI */
1473 #ifdef CONFIG_BOOTM_RTEMS
1474 static int do_bootm_rtems(int flag, int argc, char * const argv[],
1475 bootm_headers_t *images)
1477 void (*entry_point)(bd_t *);
1479 if ((flag != 0) && (flag != BOOTM_STATE_OS_GO))
1482 #if defined(CONFIG_FIT)
1483 if (!images->legacy_hdr_valid) {
1484 fit_unsupported_reset("RTEMS");
1489 entry_point = (void (*)(bd_t *))images->ep;
1491 printf("## Transferring control to RTEMS (at address %08lx) ...\n",
1492 (ulong)entry_point);
1494 bootstage_mark(BOOTSTAGE_ID_RUN_OS);
1498 * r3: ptr to board info data
1500 (*entry_point)(gd->bd);
1504 #endif /* CONFIG_BOOTM_RTEMS */
1506 #if defined(CONFIG_BOOTM_OSE)
1507 static int do_bootm_ose(int flag, int argc, char * const argv[],
1508 bootm_headers_t *images)
1510 void (*entry_point)(void);
1512 if ((flag != 0) && (flag != BOOTM_STATE_OS_GO))
1515 #if defined(CONFIG_FIT)
1516 if (!images->legacy_hdr_valid) {
1517 fit_unsupported_reset("OSE");
1522 entry_point = (void (*)(void))images->ep;
1524 printf("## Transferring control to OSE (at address %08lx) ...\n",
1525 (ulong)entry_point);
1527 bootstage_mark(BOOTSTAGE_ID_RUN_OS);
1537 #endif /* CONFIG_BOOTM_OSE */
1539 #if defined(CONFIG_BOOTM_PLAN9)
1540 static int do_bootm_plan9(int flag, int argc, char * const argv[],
1541 bootm_headers_t *images)
1543 void (*entry_point)(void);
1545 if ((flag != 0) && (flag != BOOTM_STATE_OS_GO))
1548 #if defined(CONFIG_FIT)
1549 if (!images->legacy_hdr_valid) {
1550 fit_unsupported_reset("Plan 9");
1555 entry_point = (void (*)(void))images->ep;
1557 printf("## Transferring control to Plan 9 (at address %08lx) ...\n",
1558 (ulong)entry_point);
1560 bootstage_mark(BOOTSTAGE_ID_RUN_OS);
1563 * Plan 9 Parameters:
1570 #endif /* CONFIG_BOOTM_PLAN9 */
1572 #if defined(CONFIG_CMD_ELF)
1573 static int do_bootm_vxworks(int flag, int argc, char * const argv[],
1574 bootm_headers_t *images)
1578 if ((flag != 0) && (flag != BOOTM_STATE_OS_GO))
1581 #if defined(CONFIG_FIT)
1582 if (!images->legacy_hdr_valid) {
1583 fit_unsupported_reset("VxWorks");
1588 sprintf(str, "%lx", images->ep); /* write entry-point into string */
1589 setenv("loadaddr", str);
1590 do_bootvx(NULL, 0, 0, NULL);
1595 static int do_bootm_qnxelf(int flag, int argc, char * const argv[],
1596 bootm_headers_t *images)
1598 char *local_args[2];
1601 if ((flag != 0) && (flag != BOOTM_STATE_OS_GO))
1604 #if defined(CONFIG_FIT)
1605 if (!images->legacy_hdr_valid) {
1606 fit_unsupported_reset("QNX");
1611 sprintf(str, "%lx", images->ep); /* write entry-point into string */
1612 local_args[0] = argv[0];
1613 local_args[1] = str; /* and provide it via the arguments */
1614 do_bootelf(NULL, 0, 2, local_args);
1620 #ifdef CONFIG_INTEGRITY
1621 static int do_bootm_integrity(int flag, int argc, char * const argv[],
1622 bootm_headers_t *images)
1624 void (*entry_point)(void);
1626 if ((flag != 0) && (flag != BOOTM_STATE_OS_GO))
1629 #if defined(CONFIG_FIT)
1630 if (!images->legacy_hdr_valid) {
1631 fit_unsupported_reset("INTEGRITY");
1636 entry_point = (void (*)(void))images->ep;
1638 printf("## Transferring control to INTEGRITY (at address %08lx) ...\n",
1639 (ulong)entry_point);
1641 bootstage_mark(BOOTSTAGE_ID_RUN_OS);
1644 * INTEGRITY Parameters:
1653 #ifdef CONFIG_CMD_BOOTZ
1655 static int __bootz_setup(void *image, void **start, void **end)
1657 /* Please define bootz_setup() for your platform */
1659 puts("Your platform's zImage format isn't supported yet!\n");
1662 int bootz_setup(void *image, void **start, void **end)
1663 __attribute__((weak, alias("__bootz_setup")));
1666 * zImage booting support
1668 static int bootz_start(cmd_tbl_t *cmdtp, int flag, int argc,
1669 char * const argv[], bootm_headers_t *images)
1672 void *zi_start, *zi_end;
1674 memset(images, 0, sizeof(bootm_headers_t));
1676 boot_start_lmb(images);
1678 /* Setup Linux kernel zImage entry point */
1680 images->ep = load_addr;
1681 debug("* kernel: default image load address = 0x%08lx\n",
1684 images->ep = simple_strtoul(argv[1], NULL, 16);
1685 debug("* kernel: cmdline image address = 0x%08lx\n",
1689 ret = bootz_setup((void *)images->ep, &zi_start, &zi_end);
1693 lmb_reserve(&images->lmb, images->ep, zi_end - zi_start);
1696 ret = boot_get_ramdisk(argc, argv, images, IH_INITRD_ARCH,
1697 &images->rd_start, &images->rd_end);
1699 puts("Ramdisk image is corrupt or invalid\n");
1703 #if defined(CONFIG_OF_LIBFDT)
1704 /* find flattened device tree */
1705 ret = boot_get_fdt(flag, argc, argv, IH_ARCH_DEFAULT, images,
1706 &images->ft_addr, &images->ft_len);
1708 puts("Could not find a valid device tree\n");
1712 set_working_fdt_addr(images->ft_addr);
1718 int do_bootz(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
1720 bootm_headers_t images;
1722 if (bootz_start(cmdtp, flag, argc, argv, &images))
1726 * We have reached the point of no return: we are going to
1727 * overwrite all exception vector code, so we cannot easily
1728 * recover from any failures any more...
1730 disable_interrupts();
1732 #ifdef CONFIG_NETCONSOLE
1733 /* Stop the ethernet stack if NetConsole could have left it up */
1737 #if defined(CONFIG_CMD_USB)
1739 * turn off USB to prevent the host controller from writing to the
1740 * SDRAM while Linux is booting. This could happen (at least for OHCI
1741 * controller), because the HCCA (Host Controller Communication Area)
1742 * lies within the SDRAM and the host controller writes continously to
1743 * this area (as busmaster!). The HccaFrameNumber is for example
1744 * updated every 1 ms within the HCCA structure in SDRAM! For more
1745 * details see the OpenHCI specification.
1750 #if defined(CONFIG_SILENT_CONSOLE) && !defined(CONFIG_SILENT_U_BOOT_ONLY)
1751 fixup_silent_linux();
1755 do_bootm_linux(0, argc, argv, &images);
1757 puts("\n## Control returned to monitor - resetting...\n");
1759 do_reset(cmdtp, flag, argc, argv);
1764 #ifdef CONFIG_SYS_LONGHELP
1765 static char bootz_help_text[] =
1766 "[addr [initrd[:size]] [fdt]]\n"
1767 " - boot Linux zImage stored in memory\n"
1768 "\tThe argument 'initrd' is optional and specifies the address\n"
1769 "\tof the initrd in memory. The optional argument ':size' allows\n"
1770 "\tspecifying the size of RAW initrd.\n"
1771 #if defined(CONFIG_OF_LIBFDT)
1772 "\tWhen booting a Linux kernel which requires a flat device-tree\n"
1773 "\ta third argument is required which is the address of the\n"
1774 "\tdevice-tree blob. To boot that kernel without an initrd image,\n"
1775 "\tuse a '-' for the second argument. If you do not pass a third\n"
1776 "\ta bd_info struct will be passed instead\n"
1782 bootz, CONFIG_SYS_MAXARGS, 1, do_bootz,
1783 "boot Linux zImage image from memory", bootz_help_text
1785 #endif /* CONFIG_CMD_BOOTZ */