]> git.ipfire.org Git - people/ms/u-boot.git/blob - common/cmd_bootm.c
projects / people / ms / u-boot.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
common: Remove invalid endianess conversion
[people/ms/u-boot.git] / common / cmd_bootm.c
1 /*
2 * (C) Copyright 2000-2009
3 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
4 *
5 * SPDX-License-Identifier: GPL-2.0+
6 */
7
8
9 /*
10 * Boot support
11 */
12 #include <common.h>
13 #include <watchdog.h>
14 #include <command.h>
15 #include <image.h>
16 #include <malloc.h>
17 #include <u-boot/zlib.h>
18 #include <bzlib.h>
19 #include <environment.h>
20 #include <lmb.h>
21 #include <linux/ctype.h>
22 #include <asm/byteorder.h>
23 #include <asm/io.h>
24 #include <linux/compiler.h>
25
26 #if defined(CONFIG_BOOTM_VXWORKS) && \
27 (defined(CONFIG_PPC) || defined(CONFIG_ARM))
28 #include <vxworks.h>
29 #endif
30
31 #if defined(CONFIG_CMD_USB)
32 #include <usb.h>
33 #endif
34
35 #ifdef CONFIG_SYS_HUSH_PARSER
36 #include <hush.h>
37 #endif
38
39 #if defined(CONFIG_OF_LIBFDT)
40 #include <libfdt.h>
41 #include <fdt_support.h>
42 #endif
43
44 #ifdef CONFIG_LZMA
45 #include <lzma/LzmaTypes.h>
46 #include <lzma/LzmaDec.h>
47 #include <lzma/LzmaTools.h>
48 #endif /* CONFIG_LZMA */
49
50 #ifdef CONFIG_LZO
51 #include <linux/lzo.h>
52 #endif /* CONFIG_LZO */
53
54 DECLARE_GLOBAL_DATA_PTR;
55
56 #ifndef CONFIG_SYS_BOOTM_LEN
57 #define CONFIG_SYS_BOOTM_LEN 0x800000 /* use 8MByte as default max gunzip size */
58 #endif
59
60 #ifdef CONFIG_BZIP2
61 extern void bz_internal_error(int);
62 #endif
63
64 #if defined(CONFIG_CMD_IMI)
65 static int image_info(unsigned long addr);
66 #endif
67
68 #if defined(CONFIG_CMD_IMLS)
69 #include <flash.h>
70 #include <mtd/cfi_flash.h>
71 extern flash_info_t flash_info[]; /* info for FLASH chips */
72 #endif
73
74 #if defined(CONFIG_CMD_IMLS) || defined(CONFIG_CMD_IMLS_NAND)
75 static int do_imls(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
76 #endif
77
78 #include <linux/err.h>
79 #include <nand.h>
80
81 #if defined(CONFIG_SILENT_CONSOLE) && !defined(CONFIG_SILENT_U_BOOT_ONLY)
82 static void fixup_silent_linux(void);
83 #endif
84
85 static int do_bootm_standalone(int flag, int argc, char * const argv[],
86 bootm_headers_t *images);
87
88 static const void *boot_get_kernel(cmd_tbl_t *cmdtp, int flag, int argc,
89 char * const argv[], bootm_headers_t *images,
90 ulong *os_data, ulong *os_len);
91
92 /*
93 * Continue booting an OS image; caller already has:
94 * - copied image header to global variable `header'
95 * - checked header magic number, checksums (both header & image),
96 * - verified image architecture (PPC) and type (KERNEL or MULTI),
97 * - loaded (first part of) image to header load address,
98 * - disabled interrupts.
99 *
100 * @flag: Flags indicating what to do (BOOTM_STATE_...)
101 * @argc: Number of arguments. Note that the arguments are shifted down
102 * so that 0 is the first argument not processed by U-Boot, and
103 * argc is adjusted accordingly. This avoids confusion as to how
104 * many arguments are available for the OS.
105 * @images: Pointers to os/initrd/fdt
106 * @return 1 on error. On success the OS boots so this function does
107 * not return.
108 */
109 typedef int boot_os_fn(int flag, int argc, char * const argv[],
110 bootm_headers_t *images);
111
112 #ifdef CONFIG_BOOTM_LINUX
113 extern boot_os_fn do_bootm_linux;
114 #endif
115 #ifdef CONFIG_BOOTM_NETBSD
116 static boot_os_fn do_bootm_netbsd;
117 #endif
118 #if defined(CONFIG_LYNXKDI)
119 static boot_os_fn do_bootm_lynxkdi;
120 extern void lynxkdi_boot(image_header_t *);
121 #endif
122 #ifdef CONFIG_BOOTM_RTEMS
123 static boot_os_fn do_bootm_rtems;
124 #endif
125 #if defined(CONFIG_BOOTM_OSE)
126 static boot_os_fn do_bootm_ose;
127 #endif
128 #if defined(CONFIG_BOOTM_PLAN9)
129 static boot_os_fn do_bootm_plan9;
130 #endif
131 #if defined(CONFIG_BOOTM_VXWORKS) && \
132 (defined(CONFIG_PPC) || defined(CONFIG_ARM))
133 static boot_os_fn do_bootm_vxworks;
134 #endif
135 #if defined(CONFIG_CMD_ELF)
136 static boot_os_fn do_bootm_qnxelf;
137 int do_bootvx(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
138 int do_bootelf(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
139 #endif
140 #if defined(CONFIG_INTEGRITY)
141 static boot_os_fn do_bootm_integrity;
142 #endif
143
144 static boot_os_fn *boot_os[] = {
145 [IH_OS_U_BOOT] = do_bootm_standalone,
146 #ifdef CONFIG_BOOTM_LINUX
147 [IH_OS_LINUX] = do_bootm_linux,
148 #endif
149 #ifdef CONFIG_BOOTM_NETBSD
150 [IH_OS_NETBSD] = do_bootm_netbsd,
151 #endif
152 #ifdef CONFIG_LYNXKDI
153 [IH_OS_LYNXOS] = do_bootm_lynxkdi,
154 #endif
155 #ifdef CONFIG_BOOTM_RTEMS
156 [IH_OS_RTEMS] = do_bootm_rtems,
157 #endif
158 #if defined(CONFIG_BOOTM_OSE)
159 [IH_OS_OSE] = do_bootm_ose,
160 #endif
161 #if defined(CONFIG_BOOTM_PLAN9)
162 [IH_OS_PLAN9] = do_bootm_plan9,
163 #endif
164 #if defined(CONFIG_BOOTM_VXWORKS) && \
165 (defined(CONFIG_PPC) || defined(CONFIG_ARM))
166 [IH_OS_VXWORKS] = do_bootm_vxworks,
167 #endif
168 #if defined(CONFIG_CMD_ELF)
169 [IH_OS_QNX] = do_bootm_qnxelf,
170 #endif
171 #ifdef CONFIG_INTEGRITY
172 [IH_OS_INTEGRITY] = do_bootm_integrity,
173 #endif
174 };
175
176 bootm_headers_t images; /* pointers to os/initrd/fdt images */
177
178 /* Allow for arch specific config before we boot */
179 static void __arch_preboot_os(void)
180 {
181 /* please define platform specific arch_preboot_os() */
182 }
183 void arch_preboot_os(void) __attribute__((weak, alias("__arch_preboot_os")));
184
185 #define IH_INITRD_ARCH IH_ARCH_DEFAULT
186
187 #ifdef CONFIG_LMB
188 static void boot_start_lmb(bootm_headers_t *images)
189 {
190 ulong mem_start;
191 phys_size_t mem_size;
192
193 lmb_init(&images->lmb);
194
195 mem_start = getenv_bootm_low();
196 mem_size = getenv_bootm_size();
197
198 lmb_add(&images->lmb, (phys_addr_t)mem_start, mem_size);
199
200 arch_lmb_reserve(&images->lmb);
201 board_lmb_reserve(&images->lmb);
202 }
203 #else
204 #define lmb_reserve(lmb, base, size)
205 static inline void boot_start_lmb(bootm_headers_t *images) { }
206 #endif
207
208 static int bootm_start(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
209 {
210 memset((void *)&images, 0, sizeof(images));
211 images.verify = getenv_yesno("verify");
212
213 boot_start_lmb(&images);
214
215 bootstage_mark_name(BOOTSTAGE_ID_BOOTM_START, "bootm_start");
216 images.state = BOOTM_STATE_START;
217
218 return 0;
219 }
220
221 static int bootm_find_os(cmd_tbl_t *cmdtp, int flag, int argc,
222 char * const argv[])
223 {
224 const void *os_hdr;
225
226 /* get kernel image header, start address and length */
227 os_hdr = boot_get_kernel(cmdtp, flag, argc, argv,
228 &images, &images.os.image_start, &images.os.image_len);
229 if (images.os.image_len == 0) {
230 puts("ERROR: can't get kernel image!\n");
231 return 1;
232 }
233
234 /* get image parameters */
235 switch (genimg_get_format(os_hdr)) {
236 case IMAGE_FORMAT_LEGACY:
237 images.os.type = image_get_type(os_hdr);
238 images.os.comp = image_get_comp(os_hdr);
239 images.os.os = image_get_os(os_hdr);
240
241 images.os.end = image_get_image_end(os_hdr);
242 images.os.load = image_get_load(os_hdr);
243 break;
244 #if defined(CONFIG_FIT)
245 case IMAGE_FORMAT_FIT:
246 if (fit_image_get_type(images.fit_hdr_os,
247 images.fit_noffset_os, &images.os.type)) {
248 puts("Can't get image type!\n");
249 bootstage_error(BOOTSTAGE_ID_FIT_TYPE);
250 return 1;
251 }
252
253 if (fit_image_get_comp(images.fit_hdr_os,
254 images.fit_noffset_os, &images.os.comp)) {
255 puts("Can't get image compression!\n");
256 bootstage_error(BOOTSTAGE_ID_FIT_COMPRESSION);
257 return 1;
258 }
259
260 if (fit_image_get_os(images.fit_hdr_os,
261 images.fit_noffset_os, &images.os.os)) {
262 puts("Can't get image OS!\n");
263 bootstage_error(BOOTSTAGE_ID_FIT_OS);
264 return 1;
265 }
266
267 images.os.end = fit_get_end(images.fit_hdr_os);
268
269 if (fit_image_get_load(images.fit_hdr_os, images.fit_noffset_os,
270 &images.os.load)) {
271 puts("Can't get image load address!\n");
272 bootstage_error(BOOTSTAGE_ID_FIT_LOADADDR);
273 return 1;
274 }
275 break;
276 #endif
277 default:
278 puts("ERROR: unknown image format type!\n");
279 return 1;
280 }
281
282 /* find kernel entry point */
283 if (images.legacy_hdr_valid) {
284 images.ep = image_get_ep(&images.legacy_hdr_os_copy);
285 #if defined(CONFIG_FIT)
286 } else if (images.fit_uname_os) {
287 int ret;
288
289 ret = fit_image_get_entry(images.fit_hdr_os,
290 images.fit_noffset_os, &images.ep);
291 if (ret) {
292 puts("Can't get entry point property!\n");
293 return 1;
294 }
295 #endif
296 } else {
297 puts("Could not find kernel entry point!\n");
298 return 1;
299 }
300
301 if (images.os.type == IH_TYPE_KERNEL_NOLOAD) {
302 images.os.load = images.os.image_start;
303 images.ep += images.os.load;
304 }
305
306 images.os.start = (ulong)os_hdr;
307
308 return 0;
309 }
310
311 static int bootm_find_ramdisk(int flag, int argc, char * const argv[])
312 {
313 int ret;
314
315 /* find ramdisk */
316 ret = boot_get_ramdisk(argc, argv, &images, IH_INITRD_ARCH,
317 &images.rd_start, &images.rd_end);
318 if (ret) {
319 puts("Ramdisk image is corrupt or invalid\n");
320 return 1;
321 }
322
323 return 0;
324 }
325
326 #if defined(CONFIG_OF_LIBFDT)
327 static int bootm_find_fdt(int flag, int argc, char * const argv[])
328 {
329 int ret;
330
331 /* find flattened device tree */
332 ret = boot_get_fdt(flag, argc, argv, IH_ARCH_DEFAULT, &images,
333 &images.ft_addr, &images.ft_len);
334 if (ret) {
335 puts("Could not find a valid device tree\n");
336 return 1;
337 }
338
339 set_working_fdt_addr(images.ft_addr);
340
341 return 0;
342 }
343 #endif
344
345 static int bootm_find_other(cmd_tbl_t *cmdtp, int flag, int argc,
346 char * const argv[])
347 {
348 if (((images.os.type == IH_TYPE_KERNEL) ||
349 (images.os.type == IH_TYPE_KERNEL_NOLOAD) ||
350 (images.os.type == IH_TYPE_MULTI)) &&
351 (images.os.os == IH_OS_LINUX ||
352 images.os.os == IH_OS_VXWORKS)) {
353 if (bootm_find_ramdisk(flag, argc, argv))
354 return 1;
355
356 #if defined(CONFIG_OF_LIBFDT)
357 if (bootm_find_fdt(flag, argc, argv))
358 return 1;
359 #endif
360 }
361
362 return 0;
363 }
364
365 #define BOOTM_ERR_RESET -1
366 #define BOOTM_ERR_OVERLAP -2
367 #define BOOTM_ERR_UNIMPLEMENTED -3
368 static int bootm_load_os(bootm_headers_t *images, unsigned long *load_end,
369 int boot_progress)
370 {
371 image_info_t os = images->os;
372 uint8_t comp = os.comp;
373 ulong load = os.load;
374 ulong blob_start = os.start;
375 ulong blob_end = os.end;
376 ulong image_start = os.image_start;
377 ulong image_len = os.image_len;
378 __maybe_unused uint unc_len = CONFIG_SYS_BOOTM_LEN;
379 int no_overlap = 0;
380 void *load_buf, *image_buf;
381 #if defined(CONFIG_LZMA) || defined(CONFIG_LZO)
382 int ret;
383 #endif /* defined(CONFIG_LZMA) || defined(CONFIG_LZO) */
384
385 const char *type_name = genimg_get_type_name(os.type);
386
387 load_buf = map_sysmem(load, unc_len);
388 image_buf = map_sysmem(image_start, image_len);
389 switch (comp) {
390 case IH_COMP_NONE:
391 if (load == blob_start || load == image_start) {
392 printf(" XIP %s ... ", type_name);
393 no_overlap = 1;
394 } else {
395 printf(" Loading %s ... ", type_name);
396 memmove_wd(load_buf, image_buf, image_len, CHUNKSZ);
397 }
398 *load_end = load + image_len;
399 break;
400 #ifdef CONFIG_GZIP
401 case IH_COMP_GZIP:
402 printf(" Uncompressing %s ... ", type_name);
403 if (gunzip(load_buf, unc_len, image_buf, &image_len) != 0) {
404 puts("GUNZIP: uncompress, out-of-mem or overwrite "
405 "error - must RESET board to recover\n");
406 if (boot_progress)
407 bootstage_error(BOOTSTAGE_ID_DECOMP_IMAGE);
408 return BOOTM_ERR_RESET;
409 }
410
411 *load_end = load + image_len;
412 break;
413 #endif /* CONFIG_GZIP */
414 #ifdef CONFIG_BZIP2
415 case IH_COMP_BZIP2:
416 printf(" Uncompressing %s ... ", type_name);
417 /*
418 * If we've got less than 4 MB of malloc() space,
419 * use slower decompression algorithm which requires
420 * at most 2300 KB of memory.
421 */
422 int i = BZ2_bzBuffToBuffDecompress(load_buf, &unc_len,
423 image_buf, image_len,
424 CONFIG_SYS_MALLOC_LEN < (4096 * 1024), 0);
425 if (i != BZ_OK) {
426 printf("BUNZIP2: uncompress or overwrite error %d "
427 "- must RESET board to recover\n", i);
428 if (boot_progress)
429 bootstage_error(BOOTSTAGE_ID_DECOMP_IMAGE);
430 return BOOTM_ERR_RESET;
431 }
432
433 *load_end = load + unc_len;
434 break;
435 #endif /* CONFIG_BZIP2 */
436 #ifdef CONFIG_LZMA
437 case IH_COMP_LZMA: {
438 SizeT lzma_len = unc_len;
439 printf(" Uncompressing %s ... ", type_name);
440
441 ret = lzmaBuffToBuffDecompress(load_buf, &lzma_len,
442 image_buf, image_len);
443 unc_len = lzma_len;
444 if (ret != SZ_OK) {
445 printf("LZMA: uncompress or overwrite error %d "
446 "- must RESET board to recover\n", ret);
447 bootstage_error(BOOTSTAGE_ID_DECOMP_IMAGE);
448 return BOOTM_ERR_RESET;
449 }
450 *load_end = load + unc_len;
451 break;
452 }
453 #endif /* CONFIG_LZMA */
454 #ifdef CONFIG_LZO
455 case IH_COMP_LZO: {
456 size_t size;
457
458 printf(" Uncompressing %s ... ", type_name);
459
460 ret = lzop_decompress(image_buf, image_len, load_buf, &size);
461 if (ret != LZO_E_OK) {
462 printf("LZO: uncompress or overwrite error %d "
463 "- must RESET board to recover\n", ret);
464 if (boot_progress)
465 bootstage_error(BOOTSTAGE_ID_DECOMP_IMAGE);
466 return BOOTM_ERR_RESET;
467 }
468
469 *load_end = load + size;
470 break;
471 }
472 #endif /* CONFIG_LZO */
473 default:
474 printf("Unimplemented compression type %d\n", comp);
475 return BOOTM_ERR_UNIMPLEMENTED;
476 }
477
478 flush_cache(load, (*load_end - load) * sizeof(ulong));
479
480 puts("OK\n");
481 debug(" kernel loaded at 0x%08lx, end = 0x%08lx\n", load, *load_end);
482 bootstage_mark(BOOTSTAGE_ID_KERNEL_LOADED);
483
484 if (!no_overlap && (load < blob_end) && (*load_end > blob_start)) {
485 debug("images.os.start = 0x%lX, images.os.end = 0x%lx\n",
486 blob_start, blob_end);
487 debug("images.os.load = 0x%lx, load_end = 0x%lx\n", load,
488 *load_end);
489
490 /* Check what type of image this is. */
491 if (images->legacy_hdr_valid) {
492 if (image_get_type(&images->legacy_hdr_os_copy)
493 == IH_TYPE_MULTI)
494 puts("WARNING: legacy format multi component image overwritten\n");
495 return BOOTM_ERR_OVERLAP;
496 } else {
497 puts("ERROR: new format image overwritten - must RESET the board to recover\n");
498 bootstage_error(BOOTSTAGE_ID_OVERWRITTEN);
499 return BOOTM_ERR_RESET;
500 }
501 }
502
503 return 0;
504 }
505
506 static int do_bootm_standalone(int flag, int argc, char * const argv[],
507 bootm_headers_t *images)
508 {
509 char *s;
510 int (*appl)(int, char * const []);
511
512 /* Don't start if "autostart" is set to "no" */
513 if (((s = getenv("autostart")) != NULL) && (strcmp(s, "no") == 0)) {
514 setenv_hex("filesize", images->os.image_len);
515 return 0;
516 }
517 appl = (int (*)(int, char * const []))images->ep;
518 appl(argc, argv);
519 return 0;
520 }
521
522 /* we overload the cmd field with our state machine info instead of a
523 * function pointer */
524 static cmd_tbl_t cmd_bootm_sub[] = {
525 U_BOOT_CMD_MKENT(start, 0, 1, (void *)BOOTM_STATE_START, "", ""),
526 U_BOOT_CMD_MKENT(loados, 0, 1, (void *)BOOTM_STATE_LOADOS, "", ""),
527 #ifdef CONFIG_SYS_BOOT_RAMDISK_HIGH
528 U_BOOT_CMD_MKENT(ramdisk, 0, 1, (void *)BOOTM_STATE_RAMDISK, "", ""),
529 #endif
530 #ifdef CONFIG_OF_LIBFDT
531 U_BOOT_CMD_MKENT(fdt, 0, 1, (void *)BOOTM_STATE_FDT, "", ""),
532 #endif
533 U_BOOT_CMD_MKENT(cmdline, 0, 1, (void *)BOOTM_STATE_OS_CMDLINE, "", ""),
534 U_BOOT_CMD_MKENT(bdt, 0, 1, (void *)BOOTM_STATE_OS_BD_T, "", ""),
535 U_BOOT_CMD_MKENT(prep, 0, 1, (void *)BOOTM_STATE_OS_PREP, "", ""),
536 U_BOOT_CMD_MKENT(fake, 0, 1, (void *)BOOTM_STATE_OS_FAKE_GO, "", ""),
537 U_BOOT_CMD_MKENT(go, 0, 1, (void *)BOOTM_STATE_OS_GO, "", ""),
538 };
539
540 static int boot_selected_os(int argc, char * const argv[], int state,
541 bootm_headers_t *images, boot_os_fn *boot_fn)
542 {
543 arch_preboot_os();
544 boot_fn(state, argc, argv, images);
545
546 /* Stand-alone may return when 'autostart' is 'no' */
547 if (images->os.type == IH_TYPE_STANDALONE ||
548 state == BOOTM_STATE_OS_FAKE_GO) /* We expect to return */
549 return 0;
550 bootstage_error(BOOTSTAGE_ID_BOOT_OS_RETURNED);
551 #ifdef DEBUG
552 puts("\n## Control returned to monitor - resetting...\n");
553 #endif
554 return BOOTM_ERR_RESET;
555 }
556
557 /**
558 * bootm_disable_interrupts() - Disable interrupts in preparation for load/boot
559 *
560 * @return interrupt flag (0 if interrupts were disabled, non-zero if they were
561 * enabled)
562 */
563 static ulong bootm_disable_interrupts(void)
564 {
565 ulong iflag;
566
567 /*
568 * We have reached the point of no return: we are going to
569 * overwrite all exception vector code, so we cannot easily
570 * recover from any failures any more...
571 */
572 iflag = disable_interrupts();
573 #ifdef CONFIG_NETCONSOLE
574 /* Stop the ethernet stack if NetConsole could have left it up */
575 eth_halt();
576 eth_unregister(eth_get_dev());
577 #endif
578
579 #if defined(CONFIG_CMD_USB)
580 /*
581 * turn off USB to prevent the host controller from writing to the
582 * SDRAM while Linux is booting. This could happen (at least for OHCI
583 * controller), because the HCCA (Host Controller Communication Area)
584 * lies within the SDRAM and the host controller writes continously to
585 * this area (as busmaster!). The HccaFrameNumber is for example
586 * updated every 1 ms within the HCCA structure in SDRAM! For more
587 * details see the OpenHCI specification.
588 */
589 usb_stop();
590 #endif
591 return iflag;
592 }
593
594 /**
595 * Execute selected states of the bootm command.
596 *
597 * Note the arguments to this state must be the first argument, Any 'bootm'
598 * or sub-command arguments must have already been taken.
599 *
600 * Note that if states contains more than one flag it MUST contain
601 * BOOTM_STATE_START, since this handles and consumes the command line args.
602 *
603 * Also note that aside from boot_os_fn functions and bootm_load_os no other
604 * functions we store the return value of in 'ret' may use a negative return
605 * value, without special handling.
606 *
607 * @param cmdtp Pointer to bootm command table entry
608 * @param flag Command flags (CMD_FLAG_...)
609 * @param argc Number of subcommand arguments (0 = no arguments)
610 * @param argv Arguments
611 * @param states Mask containing states to run (BOOTM_STATE_...)
612 * @param images Image header information
613 * @param boot_progress 1 to show boot progress, 0 to not do this
614 * @return 0 if ok, something else on error. Some errors will cause this
615 * function to perform a reboot! If states contains BOOTM_STATE_OS_GO
616 * then the intent is to boot an OS, so this function will not return
617 * unless the image type is standalone.
618 */
619 static int do_bootm_states(cmd_tbl_t *cmdtp, int flag, int argc,
620 char * const argv[], int states, bootm_headers_t *images,
621 int boot_progress)
622 {
623 boot_os_fn *boot_fn;
624 ulong iflag = 0;
625 int ret = 0, need_boot_fn;
626
627 images->state |= states;
628
629 /*
630 * Work through the states and see how far we get. We stop on
631 * any error.
632 */
633 if (states & BOOTM_STATE_START)
634 ret = bootm_start(cmdtp, flag, argc, argv);
635
636 if (!ret && (states & BOOTM_STATE_FINDOS))
637 ret = bootm_find_os(cmdtp, flag, argc, argv);
638
639 if (!ret && (states & BOOTM_STATE_FINDOTHER)) {
640 ret = bootm_find_other(cmdtp, flag, argc, argv);
641 argc = 0; /* consume the args */
642 }
643
644 /* Load the OS */
645 if (!ret && (states & BOOTM_STATE_LOADOS)) {
646 ulong load_end;
647
648 iflag = bootm_disable_interrupts();
649 ret = bootm_load_os(images, &load_end, 0);
650 if (ret == 0)
651 lmb_reserve(&images->lmb, images->os.load,
652 (load_end - images->os.load));
653 else if (ret && ret != BOOTM_ERR_OVERLAP)
654 goto err;
655 else if (ret == BOOTM_ERR_OVERLAP)
656 ret = 0;
657 #if defined(CONFIG_SILENT_CONSOLE) && !defined(CONFIG_SILENT_U_BOOT_ONLY)
658 if (images->os.os == IH_OS_LINUX)
659 fixup_silent_linux();
660 #endif
661 }
662
663 /* Relocate the ramdisk */
664 #ifdef CONFIG_SYS_BOOT_RAMDISK_HIGH
665 if (!ret && (states & BOOTM_STATE_RAMDISK)) {
666 ulong rd_len = images->rd_end - images->rd_start;
667
668 ret = boot_ramdisk_high(&images->lmb, images->rd_start,
669 rd_len, &images->initrd_start, &images->initrd_end);
670 if (!ret) {
671 setenv_hex("initrd_start", images->initrd_start);
672 setenv_hex("initrd_end", images->initrd_end);
673 }
674 }
675 #endif
676 #if defined(CONFIG_OF_LIBFDT) && defined(CONFIG_LMB)
677 if (!ret && (states & BOOTM_STATE_FDT)) {
678 boot_fdt_add_mem_rsv_regions(&images->lmb, images->ft_addr);
679 ret = boot_relocate_fdt(&images->lmb, &images->ft_addr,
680 &images->ft_len);
681 }
682 #endif
683
684 /* From now on, we need the OS boot function */
685 if (ret)
686 return ret;
687 boot_fn = boot_os[images->os.os];
688 need_boot_fn = states & (BOOTM_STATE_OS_CMDLINE |
689 BOOTM_STATE_OS_BD_T | BOOTM_STATE_OS_PREP |
690 BOOTM_STATE_OS_FAKE_GO | BOOTM_STATE_OS_GO);
691 if (boot_fn == NULL && need_boot_fn) {
692 if (iflag)
693 enable_interrupts();
694 printf("ERROR: booting os '%s' (%d) is not supported\n",
695 genimg_get_os_name(images->os.os), images->os.os);
696 bootstage_error(BOOTSTAGE_ID_CHECK_BOOT_OS);
697 return 1;
698 }
699
700 /* Call various other states that are not generally used */
701 if (!ret && (states & BOOTM_STATE_OS_CMDLINE))
702 ret = boot_fn(BOOTM_STATE_OS_CMDLINE, argc, argv, images);
703 if (!ret && (states & BOOTM_STATE_OS_BD_T))
704 ret = boot_fn(BOOTM_STATE_OS_BD_T, argc, argv, images);
705 if (!ret && (states & BOOTM_STATE_OS_PREP))
706 ret = boot_fn(BOOTM_STATE_OS_PREP, argc, argv, images);
707
708 #ifdef CONFIG_TRACE
709 /* Pretend to run the OS, then run a user command */
710 if (!ret && (states & BOOTM_STATE_OS_FAKE_GO)) {
711 char *cmd_list = getenv("fakegocmd");
712
713 ret = boot_selected_os(argc, argv, BOOTM_STATE_OS_FAKE_GO,
714 images, boot_fn);
715 if (!ret && cmd_list)
716 ret = run_command_list(cmd_list, -1, flag);
717 }
718 #endif
719
720 /* Check for unsupported subcommand. */
721 if (ret) {
722 puts("subcommand not supported\n");
723 return ret;
724 }
725
726 /* Now run the OS! We hope this doesn't return */
727 if (!ret && (states & BOOTM_STATE_OS_GO))
728 ret = boot_selected_os(argc, argv, BOOTM_STATE_OS_GO,
729 images, boot_fn);
730
731 /* Deal with any fallout */
732 err:
733 if (iflag)
734 enable_interrupts();
735
736 if (ret == BOOTM_ERR_UNIMPLEMENTED)
737 bootstage_error(BOOTSTAGE_ID_DECOMP_UNIMPL);
738 else if (ret == BOOTM_ERR_RESET)
739 do_reset(cmdtp, flag, argc, argv);
740
741 return ret;
742 }
743
744 static int do_bootm_subcommand(cmd_tbl_t *cmdtp, int flag, int argc,
745 char * const argv[])
746 {
747 int ret = 0;
748 long state;
749 cmd_tbl_t *c;
750
751 c = find_cmd_tbl(argv[0], &cmd_bootm_sub[0], ARRAY_SIZE(cmd_bootm_sub));
752 argc--; argv++;
753
754 if (c) {
755 state = (long)c->cmd;
756 if (state == BOOTM_STATE_START)
757 state |= BOOTM_STATE_FINDOS | BOOTM_STATE_FINDOTHER;
758 } else {
759 /* Unrecognized command */
760 return CMD_RET_USAGE;
761 }
762
763 if (state != BOOTM_STATE_START && images.state >= state) {
764 printf("Trying to execute a command out of order\n");
765 return CMD_RET_USAGE;
766 }
767
768 ret = do_bootm_states(cmdtp, flag, argc, argv, state, &images, 0);
769
770 return ret;
771 }
772
773 /*******************************************************************/
774 /* bootm - boot application image from image in memory */
775 /*******************************************************************/
776
777 int do_bootm(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
778 {
779 #ifdef CONFIG_NEEDS_MANUAL_RELOC
780 static int relocated = 0;
781
782 if (!relocated) {
783 int i;
784
785 /* relocate boot function table */
786 for (i = 0; i < ARRAY_SIZE(boot_os); i++)
787 if (boot_os[i] != NULL)
788 boot_os[i] += gd->reloc_off;
789
790 /* relocate names of sub-command table */
791 for (i = 0; i < ARRAY_SIZE(cmd_bootm_sub); i++)
792 cmd_bootm_sub[i].name += gd->reloc_off;
793
794 relocated = 1;
795 }
796 #endif
797
798 /* determine if we have a sub command */
799 argc--; argv++;
800 if (argc > 0) {
801 char *endp;
802
803 simple_strtoul(argv[0], &endp, 16);
804 /* endp pointing to NULL means that argv[0] was just a
805 * valid number, pass it along to the normal bootm processing
806 *
807 * If endp is ':' or '#' assume a FIT identifier so pass
808 * along for normal processing.
809 *
810 * Right now we assume the first arg should never be '-'
811 */
812 if ((*endp != 0) && (*endp != ':') && (*endp != '#'))
813 return do_bootm_subcommand(cmdtp, flag, argc, argv);
814 }
815
816 return do_bootm_states(cmdtp, flag, argc, argv, BOOTM_STATE_START |
817 BOOTM_STATE_FINDOS | BOOTM_STATE_FINDOTHER |
818 BOOTM_STATE_LOADOS |
819 #if defined(CONFIG_PPC) || defined(CONFIG_MIPS)
820 BOOTM_STATE_OS_CMDLINE |
821 #endif
822 BOOTM_STATE_OS_PREP | BOOTM_STATE_OS_FAKE_GO |
823 BOOTM_STATE_OS_GO, &images, 1);
824 }
825
826 int bootm_maybe_autostart(cmd_tbl_t *cmdtp, const char *cmd)
827 {
828 const char *ep = getenv("autostart");
829
830 if (ep && !strcmp(ep, "yes")) {
831 char *local_args[2];
832 local_args[0] = (char *)cmd;
833 local_args[1] = NULL;
834 printf("Automatic boot of image at addr 0x%08lX ...\n", load_addr);
835 return do_bootm(cmdtp, 0, 1, local_args);
836 }
837
838 return 0;
839 }
840
841 /**
842 * image_get_kernel - verify legacy format kernel image
843 * @img_addr: in RAM address of the legacy format image to be verified
844 * @verify: data CRC verification flag
845 *
846 * image_get_kernel() verifies legacy image integrity and returns pointer to
847 * legacy image header if image verification was completed successfully.
848 *
849 * returns:
850 * pointer to a legacy image header if valid image was found
851 * otherwise return NULL
852 */
853 static image_header_t *image_get_kernel(ulong img_addr, int verify)
854 {
855 image_header_t *hdr = (image_header_t *)img_addr;
856
857 if (!image_check_magic(hdr)) {
858 puts("Bad Magic Number\n");
859 bootstage_error(BOOTSTAGE_ID_CHECK_MAGIC);
860 return NULL;
861 }
862 bootstage_mark(BOOTSTAGE_ID_CHECK_HEADER);
863
864 if (!image_check_hcrc(hdr)) {
865 puts("Bad Header Checksum\n");
866 bootstage_error(BOOTSTAGE_ID_CHECK_HEADER);
867 return NULL;
868 }
869
870 bootstage_mark(BOOTSTAGE_ID_CHECK_CHECKSUM);
871 image_print_contents(hdr);
872
873 if (verify) {
874 puts(" Verifying Checksum ... ");
875 if (!image_check_dcrc(hdr)) {
876 printf("Bad Data CRC\n");
877 bootstage_error(BOOTSTAGE_ID_CHECK_CHECKSUM);
878 return NULL;
879 }
880 puts("OK\n");
881 }
882 bootstage_mark(BOOTSTAGE_ID_CHECK_ARCH);
883
884 if (!image_check_target_arch(hdr)) {
885 printf("Unsupported Architecture 0x%x\n", image_get_arch(hdr));
886 bootstage_error(BOOTSTAGE_ID_CHECK_ARCH);
887 return NULL;
888 }
889 return hdr;
890 }
891
892 /**
893 * boot_get_kernel - find kernel image
894 * @os_data: pointer to a ulong variable, will hold os data start address
895 * @os_len: pointer to a ulong variable, will hold os data length
896 *
897 * boot_get_kernel() tries to find a kernel image, verifies its integrity
898 * and locates kernel data.
899 *
900 * returns:
901 * pointer to image header if valid image was found, plus kernel start
902 * address and length, otherwise NULL
903 */
904 static const void *boot_get_kernel(cmd_tbl_t *cmdtp, int flag, int argc,
905 char * const argv[], bootm_headers_t *images, ulong *os_data,
906 ulong *os_len)
907 {
908 image_header_t *hdr;
909 ulong img_addr;
910 const void *buf;
911 #if defined(CONFIG_FIT)
912 const char *fit_uname_config = NULL;
913 const char *fit_uname_kernel = NULL;
914 int os_noffset;
915 #endif
916
917 /* find out kernel image address */
918 if (argc < 1) {
919 img_addr = load_addr;
920 debug("* kernel: default image load address = 0x%08lx\n",
921 load_addr);
922 #if defined(CONFIG_FIT)
923 } else if (fit_parse_conf(argv[0], load_addr, &img_addr,
924 &fit_uname_config)) {
925 debug("* kernel: config '%s' from image at 0x%08lx\n",
926 fit_uname_config, img_addr);
927 } else if (fit_parse_subimage(argv[0], load_addr, &img_addr,
928 &fit_uname_kernel)) {
929 debug("* kernel: subimage '%s' from image at 0x%08lx\n",
930 fit_uname_kernel, img_addr);
931 #endif
932 } else {
933 img_addr = simple_strtoul(argv[0], NULL, 16);
934 debug("* kernel: cmdline image address = 0x%08lx\n", img_addr);
935 }
936
937 bootstage_mark(BOOTSTAGE_ID_CHECK_MAGIC);
938
939 /* copy from dataflash if needed */
940 img_addr = genimg_get_image(img_addr);
941
942 /* check image type, for FIT images get FIT kernel node */
943 *os_data = *os_len = 0;
944 buf = map_sysmem(img_addr, 0);
945 switch (genimg_get_format(buf)) {
946 case IMAGE_FORMAT_LEGACY:
947 printf("## Booting kernel from Legacy Image at %08lx ...\n",
948 img_addr);
949 hdr = image_get_kernel(img_addr, images->verify);
950 if (!hdr)
951 return NULL;
952 bootstage_mark(BOOTSTAGE_ID_CHECK_IMAGETYPE);
953
954 /* get os_data and os_len */
955 switch (image_get_type(hdr)) {
956 case IH_TYPE_KERNEL:
957 case IH_TYPE_KERNEL_NOLOAD:
958 *os_data = image_get_data(hdr);
959 *os_len = image_get_data_size(hdr);
960 break;
961 case IH_TYPE_MULTI:
962 image_multi_getimg(hdr, 0, os_data, os_len);
963 break;
964 case IH_TYPE_STANDALONE:
965 *os_data = image_get_data(hdr);
966 *os_len = image_get_data_size(hdr);
967 break;
968 default:
969 printf("Wrong Image Type for %s command\n",
970 cmdtp->name);
971 bootstage_error(BOOTSTAGE_ID_CHECK_IMAGETYPE);
972 return NULL;
973 }
974
975 /*
976 * copy image header to allow for image overwrites during
977 * kernel decompression.
978 */
979 memmove(&images->legacy_hdr_os_copy, hdr,
980 sizeof(image_header_t));
981
982 /* save pointer to image header */
983 images->legacy_hdr_os = hdr;
984
985 images->legacy_hdr_valid = 1;
986 bootstage_mark(BOOTSTAGE_ID_DECOMP_IMAGE);
987 break;
988 #if defined(CONFIG_FIT)
989 case IMAGE_FORMAT_FIT:
990 os_noffset = fit_image_load(images, FIT_KERNEL_PROP,
991 img_addr,
992 &fit_uname_kernel, &fit_uname_config,
993 IH_ARCH_DEFAULT, IH_TYPE_KERNEL,
994 BOOTSTAGE_ID_FIT_KERNEL_START,
995 FIT_LOAD_IGNORED, os_data, os_len);
996 if (os_noffset < 0)
997 return NULL;
998
999 images->fit_hdr_os = map_sysmem(img_addr, 0);
1000 images->fit_uname_os = fit_uname_kernel;
1001 images->fit_uname_cfg = fit_uname_config;
1002 images->fit_noffset_os = os_noffset;
1003 break;
1004 #endif
1005 default:
1006 printf("Wrong Image Format for %s command\n", cmdtp->name);
1007 bootstage_error(BOOTSTAGE_ID_FIT_KERNEL_INFO);
1008 return NULL;
1009 }
1010
1011 debug(" kernel data at 0x%08lx, len = 0x%08lx (%ld)\n",
1012 *os_data, *os_len, *os_len);
1013
1014 return buf;
1015 }
1016
1017 #ifdef CONFIG_SYS_LONGHELP
1018 static char bootm_help_text[] =
1019 "[addr [arg ...]]\n - boot application image stored in memory\n"
1020 "\tpassing arguments 'arg ...'; when booting a Linux kernel,\n"
1021 "\t'arg' can be the address of an initrd image\n"
1022 #if defined(CONFIG_OF_LIBFDT)
1023 "\tWhen booting a Linux kernel which requires a flat device-tree\n"
1024 "\ta third argument is required which is the address of the\n"
1025 "\tdevice-tree blob. To boot that kernel without an initrd image,\n"
1026 "\tuse a '-' for the second argument. If you do not pass a third\n"
1027 "\ta bd_info struct will be passed instead\n"
1028 #endif
1029 #if defined(CONFIG_FIT)
1030 "\t\nFor the new multi component uImage format (FIT) addresses\n"
1031 "\tmust be extened to include component or configuration unit name:\n"
1032 "\taddr:<subimg_uname> - direct component image specification\n"
1033 "\taddr#<conf_uname> - configuration specification\n"
1034 "\tUse iminfo command to get the list of existing component\n"
1035 "\timages and configurations.\n"
1036 #endif
1037 "\nSub-commands to do part of the bootm sequence. The sub-commands "
1038 "must be\n"
1039 "issued in the order below (it's ok to not issue all sub-commands):\n"
1040 "\tstart [addr [arg ...]]\n"
1041 "\tloados - load OS image\n"
1042 #if defined(CONFIG_SYS_BOOT_RAMDISK_HIGH)
1043 "\tramdisk - relocate initrd, set env initrd_start/initrd_end\n"
1044 #endif
1045 #if defined(CONFIG_OF_LIBFDT)
1046 "\tfdt - relocate flat device tree\n"
1047 #endif
1048 "\tcmdline - OS specific command line processing/setup\n"
1049 "\tbdt - OS specific bd_t processing\n"
1050 "\tprep - OS specific prep before relocation or go\n"
1051 "\tgo - start OS";
1052 #endif
1053
1054 U_BOOT_CMD(
1055 bootm, CONFIG_SYS_MAXARGS, 1, do_bootm,
1056 "boot application image from memory", bootm_help_text
1057 );
1058
1059 /*******************************************************************/
1060 /* bootd - boot default image */
1061 /*******************************************************************/
1062 #if defined(CONFIG_CMD_BOOTD)
1063 int do_bootd(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
1064 {
1065 int rcode = 0;
1066
1067 if (run_command(getenv("bootcmd"), flag) < 0)
1068 rcode = 1;
1069 return rcode;
1070 }
1071
1072 U_BOOT_CMD(
1073 boot, 1, 1, do_bootd,
1074 "boot default, i.e., run 'bootcmd'",
1075 ""
1076 );
1077
1078 /* keep old command name "bootd" for backward compatibility */
1079 U_BOOT_CMD(
1080 bootd, 1, 1, do_bootd,
1081 "boot default, i.e., run 'bootcmd'",
1082 ""
1083 );
1084
1085 #endif
1086
1087
1088 /*******************************************************************/
1089 /* iminfo - print header info for a requested image */
1090 /*******************************************************************/
1091 #if defined(CONFIG_CMD_IMI)
1092 static int do_iminfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
1093 {
1094 int arg;
1095 ulong addr;
1096 int rcode = 0;
1097
1098 if (argc < 2) {
1099 return image_info(load_addr);
1100 }
1101
1102 for (arg = 1; arg < argc; ++arg) {
1103 addr = simple_strtoul(argv[arg], NULL, 16);
1104 if (image_info(addr) != 0)
1105 rcode = 1;
1106 }
1107 return rcode;
1108 }
1109
1110 static int image_info(ulong addr)
1111 {
1112 void *hdr = (void *)addr;
1113
1114 printf("\n## Checking Image at %08lx ...\n", addr);
1115
1116 switch (genimg_get_format(hdr)) {
1117 case IMAGE_FORMAT_LEGACY:
1118 puts(" Legacy image found\n");
1119 if (!image_check_magic(hdr)) {
1120 puts(" Bad Magic Number\n");
1121 return 1;
1122 }
1123
1124 if (!image_check_hcrc(hdr)) {
1125 puts(" Bad Header Checksum\n");
1126 return 1;
1127 }
1128
1129 image_print_contents(hdr);
1130
1131 puts(" Verifying Checksum ... ");
1132 if (!image_check_dcrc(hdr)) {
1133 puts(" Bad Data CRC\n");
1134 return 1;
1135 }
1136 puts("OK\n");
1137 return 0;
1138 #if defined(CONFIG_FIT)
1139 case IMAGE_FORMAT_FIT:
1140 puts(" FIT image found\n");
1141
1142 if (!fit_check_format(hdr)) {
1143 puts("Bad FIT image format!\n");
1144 return 1;
1145 }
1146
1147 fit_print_contents(hdr);
1148
1149 if (!fit_all_image_verify(hdr)) {
1150 puts("Bad hash in FIT image!\n");
1151 return 1;
1152 }
1153
1154 return 0;
1155 #endif
1156 default:
1157 puts("Unknown image format!\n");
1158 break;
1159 }
1160
1161 return 1;
1162 }
1163
1164 U_BOOT_CMD(
1165 iminfo, CONFIG_SYS_MAXARGS, 1, do_iminfo,
1166 "print header information for application image",
1167 "addr [addr ...]\n"
1168 " - print header information for application image starting at\n"
1169 " address 'addr' in memory; this includes verification of the\n"
1170 " image contents (magic number, header and payload checksums)"
1171 );
1172 #endif
1173
1174
1175 /*******************************************************************/
1176 /* imls - list all images found in flash */
1177 /*******************************************************************/
1178 #if defined(CONFIG_CMD_IMLS)
1179 static int do_imls_nor(void)
1180 {
1181 flash_info_t *info;
1182 int i, j;
1183 void *hdr;
1184
1185 for (i = 0, info = &flash_info[0];
1186 i < CONFIG_SYS_MAX_FLASH_BANKS; ++i, ++info) {
1187
1188 if (info->flash_id == FLASH_UNKNOWN)
1189 goto next_bank;
1190 for (j = 0; j < info->sector_count; ++j) {
1191
1192 hdr = (void *)info->start[j];
1193 if (!hdr)
1194 goto next_sector;
1195
1196 switch (genimg_get_format(hdr)) {
1197 case IMAGE_FORMAT_LEGACY:
1198 if (!image_check_hcrc(hdr))
1199 goto next_sector;
1200
1201 printf("Legacy Image at %08lX:\n", (ulong)hdr);
1202 image_print_contents(hdr);
1203
1204 puts(" Verifying Checksum ... ");
1205 if (!image_check_dcrc(hdr)) {
1206 puts("Bad Data CRC\n");
1207 } else {
1208 puts("OK\n");
1209 }
1210 break;
1211 #if defined(CONFIG_FIT)
1212 case IMAGE_FORMAT_FIT:
1213 if (!fit_check_format(hdr))
1214 goto next_sector;
1215
1216 printf("FIT Image at %08lX:\n", (ulong)hdr);
1217 fit_print_contents(hdr);
1218 break;
1219 #endif
1220 default:
1221 goto next_sector;
1222 }
1223
1224 next_sector: ;
1225 }
1226 next_bank: ;
1227 }
1228 return 0;
1229 }
1230 #endif
1231
1232 #if defined(CONFIG_CMD_IMLS_NAND)
1233 static int nand_imls_legacyimage(nand_info_t *nand, int nand_dev, loff_t off,
1234 size_t len)
1235 {
1236 void *imgdata;
1237 int ret;
1238
1239 imgdata = malloc(len);
1240 if (!imgdata) {
1241 printf("May be a Legacy Image at NAND device %d offset %08llX:\n",
1242 nand_dev, off);
1243 printf(" Low memory(cannot allocate memory for image)\n");
1244 return -ENOMEM;
1245 }
1246
1247 ret = nand_read_skip_bad(nand, off, &len,
1248 imgdata);
1249 if (ret < 0 && ret != -EUCLEAN) {
1250 free(imgdata);
1251 return ret;
1252 }
1253
1254 if (!image_check_hcrc(imgdata)) {
1255 free(imgdata);
1256 return 0;
1257 }
1258
1259 printf("Legacy Image at NAND device %d offset %08llX:\n",
1260 nand_dev, off);
1261 image_print_contents(imgdata);
1262
1263 puts(" Verifying Checksum ... ");
1264 if (!image_check_dcrc(imgdata))
1265 puts("Bad Data CRC\n");
1266 else
1267 puts("OK\n");
1268
1269 free(imgdata);
1270
1271 return 0;
1272 }
1273
1274 static int nand_imls_fitimage(nand_info_t *nand, int nand_dev, loff_t off,
1275 size_t len)
1276 {
1277 void *imgdata;
1278 int ret;
1279
1280 imgdata = malloc(len);
1281 if (!imgdata) {
1282 printf("May be a FIT Image at NAND device %d offset %08llX:\n",
1283 nand_dev, off);
1284 printf(" Low memory(cannot allocate memory for image)\n");
1285 return -ENOMEM;
1286 }
1287
1288 ret = nand_read_skip_bad(nand, off, &len,
1289 imgdata);
1290 if (ret < 0 && ret != -EUCLEAN) {
1291 free(imgdata);
1292 return ret;
1293 }
1294
1295 if (!fit_check_format(imgdata)) {
1296 free(imgdata);
1297 return 0;
1298 }
1299
1300 printf("FIT Image at NAND device %d offset %08llX:\n", nand_dev, off);
1301
1302 fit_print_contents(imgdata);
1303 free(imgdata);
1304
1305 return 0;
1306 }
1307
1308 static int do_imls_nand(void)
1309 {
1310 nand_info_t *nand;
1311 int nand_dev = nand_curr_device;
1312 size_t len;
1313 loff_t off;
1314 u32 buffer[16];
1315
1316 if (nand_dev < 0 || nand_dev >= CONFIG_SYS_MAX_NAND_DEVICE) {
1317 puts("\nNo NAND devices available\n");
1318 return -ENODEV;
1319 }
1320
1321 printf("\n");
1322
1323 for (nand_dev = 0; nand_dev < CONFIG_SYS_MAX_NAND_DEVICE; nand_dev++) {
1324 nand = &nand_info[nand_dev];
1325 if (!nand->name || !nand->size)
1326 continue;
1327
1328 for (off = 0; off < nand->size; off += nand->erasesize) {
1329 const image_header_t *header;
1330 int ret;
1331
1332 if (nand_block_isbad(nand, off))
1333 continue;
1334
1335 len = sizeof(buffer);
1336
1337 ret = nand_read(nand, off, &len, (u8 *)buffer);
1338 if (ret < 0 && ret != -EUCLEAN) {
1339 printf("NAND read error %d at offset %08llX\n",
1340 ret, off);
1341 continue;
1342 }
1343
1344 switch (genimg_get_format(buffer)) {
1345 case IMAGE_FORMAT_LEGACY:
1346 header = (const image_header_t *)buffer;
1347
1348 len = image_get_image_size(header);
1349 nand_imls_legacyimage(nand, nand_dev, off, len);
1350 break;
1351 #if defined(CONFIG_FIT)
1352 case IMAGE_FORMAT_FIT:
1353 len = fit_get_size(buffer);
1354 nand_imls_fitimage(nand, nand_dev, off, len);
1355 break;
1356 #endif
1357 }
1358 }
1359 }
1360
1361 return 0;
1362 }
1363 #endif
1364
1365 #if defined(CONFIG_CMD_IMLS) || defined(CONFIG_CMD_IMLS_NAND)
1366 static int do_imls(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
1367 {
1368 int ret_nor = 0, ret_nand = 0;
1369
1370 #if defined(CONFIG_CMD_IMLS)
1371 ret_nor = do_imls_nor();
1372 #endif
1373
1374 #if defined(CONFIG_CMD_IMLS_NAND)
1375 ret_nand = do_imls_nand();
1376 #endif
1377
1378 if (ret_nor)
1379 return ret_nor;
1380
1381 if (ret_nand)
1382 return ret_nand;
1383
1384 return (0);
1385 }
1386
1387 U_BOOT_CMD(
1388 imls, 1, 1, do_imls,
1389 "list all images found in flash",
1390 "\n"
1391 " - Prints information about all images found at sector/block\n"
1392 " boundaries in nor/nand flash."
1393 );
1394 #endif
1395
1396 /*******************************************************************/
1397 /* helper routines */
1398 /*******************************************************************/
1399 #if defined(CONFIG_SILENT_CONSOLE) && !defined(CONFIG_SILENT_U_BOOT_ONLY)
1400
1401 #define CONSOLE_ARG "console="
1402 #define CONSOLE_ARG_LEN (sizeof(CONSOLE_ARG) - 1)
1403
1404 static void fixup_silent_linux(void)
1405 {
1406 char *buf;
1407 const char *env_val;
1408 char *cmdline = getenv("bootargs");
1409 int want_silent;
1410
1411 /*
1412 * Only fix cmdline when requested. The environment variable can be:
1413 *
1414 * no - we never fixup
1415 * yes - we always fixup
1416 * unset - we rely on the console silent flag
1417 */
1418 want_silent = getenv_yesno("silent_linux");
1419 if (want_silent == 0)
1420 return;
1421 else if (want_silent == -1 && !(gd->flags & GD_FLG_SILENT))
1422 return;
1423
1424 debug("before silent fix-up: %s\n", cmdline);
1425 if (cmdline && (cmdline[0] != '\0')) {
1426 char *start = strstr(cmdline, CONSOLE_ARG);
1427
1428 /* Allocate space for maximum possible new command line */
1429 buf = malloc(strlen(cmdline) + 1 + CONSOLE_ARG_LEN + 1);
1430 if (!buf) {
1431 debug("%s: out of memory\n", __func__);
1432 return;
1433 }
1434
1435 if (start) {
1436 char *end = strchr(start, ' ');
1437 int num_start_bytes = start - cmdline + CONSOLE_ARG_LEN;
1438
1439 strncpy(buf, cmdline, num_start_bytes);
1440 if (end)
1441 strcpy(buf + num_start_bytes, end);
1442 else
1443 buf[num_start_bytes] = '\0';
1444 } else {
1445 sprintf(buf, "%s %s", cmdline, CONSOLE_ARG);
1446 }
1447 env_val = buf;
1448 } else {
1449 buf = NULL;
1450 env_val = CONSOLE_ARG;
1451 }
1452
1453 setenv("bootargs", env_val);
1454 debug("after silent fix-up: %s\n", env_val);
1455 free(buf);
1456 }
1457 #endif /* CONFIG_SILENT_CONSOLE */
1458
1459 #if defined(CONFIG_BOOTM_NETBSD) || defined(CONFIG_BOOTM_PLAN9)
1460 static void copy_args(char *dest, int argc, char * const argv[], char delim)
1461 {
1462 int i;
1463
1464 for (i = 0; i < argc; i++) {
1465 if (i > 0)
1466 *dest++ = delim;
1467 strcpy(dest, argv[i]);
1468 dest += strlen(argv[i]);
1469 }
1470 }
1471 #endif
1472
1473 /*******************************************************************/
1474 /* OS booting routines */
1475 /*******************************************************************/
1476
1477 #ifdef CONFIG_BOOTM_NETBSD
1478 static int do_bootm_netbsd(int flag, int argc, char * const argv[],
1479 bootm_headers_t *images)
1480 {
1481 void (*loader)(bd_t *, image_header_t *, char *, char *);
1482 image_header_t *os_hdr, *hdr;
1483 ulong kernel_data, kernel_len;
1484 char *consdev;
1485 char *cmdline;
1486
1487 if (flag != BOOTM_STATE_OS_GO)
1488 return 0;
1489
1490 #if defined(CONFIG_FIT)
1491 if (!images->legacy_hdr_valid) {
1492 fit_unsupported_reset("NetBSD");
1493 return 1;
1494 }
1495 #endif
1496 hdr = images->legacy_hdr_os;
1497
1498 /*
1499 * Booting a (NetBSD) kernel image
1500 *
1501 * This process is pretty similar to a standalone application:
1502 * The (first part of an multi-) image must be a stage-2 loader,
1503 * which in turn is responsible for loading & invoking the actual
1504 * kernel. The only differences are the parameters being passed:
1505 * besides the board info strucure, the loader expects a command
1506 * line, the name of the console device, and (optionally) the
1507 * address of the original image header.
1508 */
1509 os_hdr = NULL;
1510 if (image_check_type(&images->legacy_hdr_os_copy, IH_TYPE_MULTI)) {
1511 image_multi_getimg(hdr, 1, &kernel_data, &kernel_len);
1512 if (kernel_len)
1513 os_hdr = hdr;
1514 }
1515
1516 consdev = "";
1517 #if defined(CONFIG_8xx_CONS_SMC1)
1518 consdev = "smc1";
1519 #elif defined(CONFIG_8xx_CONS_SMC2)
1520 consdev = "smc2";
1521 #elif defined(CONFIG_8xx_CONS_SCC2)
1522 consdev = "scc2";
1523 #elif defined(CONFIG_8xx_CONS_SCC3)
1524 consdev = "scc3";
1525 #endif
1526
1527 if (argc > 0) {
1528 ulong len;
1529 int i;
1530
1531 for (i = 0, len = 0; i < argc; i += 1)
1532 len += strlen(argv[i]) + 1;
1533 cmdline = malloc(len);
1534 copy_args(cmdline, argc, argv, ' ');
1535 } else if ((cmdline = getenv("bootargs")) == NULL) {
1536 cmdline = "";
1537 }
1538
1539 loader = (void (*)(bd_t *, image_header_t *, char *, char *))images->ep;
1540
1541 printf("## Transferring control to NetBSD stage-2 loader "
1542 "(at address %08lx) ...\n",
1543 (ulong)loader);
1544
1545 bootstage_mark(BOOTSTAGE_ID_RUN_OS);
1546
1547 /*
1548 * NetBSD Stage-2 Loader Parameters:
1549 * arg[0]: pointer to board info data
1550 * arg[1]: image load address
1551 * arg[2]: char pointer to the console device to use
1552 * arg[3]: char pointer to the boot arguments
1553 */
1554 (*loader)(gd->bd, os_hdr, consdev, cmdline);
1555
1556 return 1;
1557 }
1558 #endif /* CONFIG_BOOTM_NETBSD*/
1559
1560 #ifdef CONFIG_LYNXKDI
1561 static int do_bootm_lynxkdi(int flag, int argc, char * const argv[],
1562 bootm_headers_t *images)
1563 {
1564 image_header_t *hdr = &images->legacy_hdr_os_copy;
1565
1566 if (flag != BOOTM_STATE_OS_GO)
1567 return 0;
1568
1569 #if defined(CONFIG_FIT)
1570 if (!images->legacy_hdr_valid) {
1571 fit_unsupported_reset("Lynx");
1572 return 1;
1573 }
1574 #endif
1575
1576 lynxkdi_boot((image_header_t *)hdr);
1577
1578 return 1;
1579 }
1580 #endif /* CONFIG_LYNXKDI */
1581
1582 #ifdef CONFIG_BOOTM_RTEMS
1583 static int do_bootm_rtems(int flag, int argc, char * const argv[],
1584 bootm_headers_t *images)
1585 {
1586 void (*entry_point)(bd_t *);
1587
1588 if (flag != BOOTM_STATE_OS_GO)
1589 return 0;
1590
1591 #if defined(CONFIG_FIT)
1592 if (!images->legacy_hdr_valid) {
1593 fit_unsupported_reset("RTEMS");
1594 return 1;
1595 }
1596 #endif
1597
1598 entry_point = (void (*)(bd_t *))images->ep;
1599
1600 printf("## Transferring control to RTEMS (at address %08lx) ...\n",
1601 (ulong)entry_point);
1602
1603 bootstage_mark(BOOTSTAGE_ID_RUN_OS);
1604
1605 /*
1606 * RTEMS Parameters:
1607 * r3: ptr to board info data
1608 */
1609 (*entry_point)(gd->bd);
1610
1611 return 1;
1612 }
1613 #endif /* CONFIG_BOOTM_RTEMS */
1614
1615 #if defined(CONFIG_BOOTM_OSE)
1616 static int do_bootm_ose(int flag, int argc, char * const argv[],
1617 bootm_headers_t *images)
1618 {
1619 void (*entry_point)(void);
1620
1621 if (flag != BOOTM_STATE_OS_GO)
1622 return 0;
1623
1624 #if defined(CONFIG_FIT)
1625 if (!images->legacy_hdr_valid) {
1626 fit_unsupported_reset("OSE");
1627 return 1;
1628 }
1629 #endif
1630
1631 entry_point = (void (*)(void))images->ep;
1632
1633 printf("## Transferring control to OSE (at address %08lx) ...\n",
1634 (ulong)entry_point);
1635
1636 bootstage_mark(BOOTSTAGE_ID_RUN_OS);
1637
1638 /*
1639 * OSE Parameters:
1640 * None
1641 */
1642 (*entry_point)();
1643
1644 return 1;
1645 }
1646 #endif /* CONFIG_BOOTM_OSE */
1647
1648 #if defined(CONFIG_BOOTM_PLAN9)
1649 static int do_bootm_plan9(int flag, int argc, char * const argv[],
1650 bootm_headers_t *images)
1651 {
1652 void (*entry_point)(void);
1653 char *s;
1654
1655 if (flag != BOOTM_STATE_OS_GO)
1656 return 0;
1657
1658 #if defined(CONFIG_FIT)
1659 if (!images->legacy_hdr_valid) {
1660 fit_unsupported_reset("Plan 9");
1661 return 1;
1662 }
1663 #endif
1664
1665 /* See README.plan9 */
1666 s = getenv("confaddr");
1667 if (s != NULL) {
1668 char *confaddr = (char *)simple_strtoul(s, NULL, 16);
1669
1670 if (argc > 0) {
1671 copy_args(confaddr, argc, argv, '\n');
1672 } else {
1673 s = getenv("bootargs");
1674 if (s != NULL)
1675 strcpy(confaddr, s);
1676 }
1677 }
1678
1679 entry_point = (void (*)(void))images->ep;
1680
1681 printf("## Transferring control to Plan 9 (at address %08lx) ...\n",
1682 (ulong)entry_point);
1683
1684 bootstage_mark(BOOTSTAGE_ID_RUN_OS);
1685
1686 /*
1687 * Plan 9 Parameters:
1688 * None
1689 */
1690 (*entry_point)();
1691
1692 return 1;
1693 }
1694 #endif /* CONFIG_BOOTM_PLAN9 */
1695
1696 #if defined(CONFIG_BOOTM_VXWORKS) && \
1697 (defined(CONFIG_PPC) || defined(CONFIG_ARM))
1698
1699 void do_bootvx_fdt(bootm_headers_t *images)
1700 {
1701 #if defined(CONFIG_OF_LIBFDT)
1702 int ret;
1703 char *bootline;
1704 ulong of_size = images->ft_len;
1705 char **of_flat_tree = &images->ft_addr;
1706 struct lmb *lmb = &images->lmb;
1707
1708 if (*of_flat_tree) {
1709 boot_fdt_add_mem_rsv_regions(lmb, *of_flat_tree);
1710
1711 ret = boot_relocate_fdt(lmb, of_flat_tree, &of_size);
1712 if (ret)
1713 return;
1714
1715 ret = fdt_add_subnode(*of_flat_tree, 0, "chosen");
1716 if ((ret >= 0 || ret == -FDT_ERR_EXISTS)) {
1717 bootline = getenv("bootargs");
1718 if (bootline) {
1719 ret = fdt_find_and_setprop(*of_flat_tree,
1720 "/chosen", "bootargs",
1721 bootline,
1722 strlen(bootline) + 1, 1);
1723 if (ret < 0) {
1724 printf("## ERROR: %s : %s\n", __func__,
1725 fdt_strerror(ret));
1726 return;
1727 }
1728 }
1729 } else {
1730 printf("## ERROR: %s : %s\n", __func__,
1731 fdt_strerror(ret));
1732 return;
1733 }
1734 }
1735 #endif
1736
1737 boot_prep_vxworks(images);
1738
1739 bootstage_mark(BOOTSTAGE_ID_RUN_OS);
1740
1741 #if defined(CONFIG_OF_LIBFDT)
1742 printf("## Starting vxWorks at 0x%08lx, device tree at 0x%08lx ...\n",
1743 (ulong)images->ep, (ulong)*of_flat_tree);
1744 #else
1745 printf("## Starting vxWorks at 0x%08lx\n", (ulong)images->ep);
1746 #endif
1747
1748 boot_jump_vxworks(images);
1749
1750 puts("## vxWorks terminated\n");
1751 }
1752
1753 static int do_bootm_vxworks(int flag, int argc, char * const argv[],
1754 bootm_headers_t *images)
1755 {
1756 if (flag != BOOTM_STATE_OS_GO)
1757 return 0;
1758
1759 #if defined(CONFIG_FIT)
1760 if (!images->legacy_hdr_valid) {
1761 fit_unsupported_reset("VxWorks");
1762 return 1;
1763 }
1764 #endif
1765
1766 do_bootvx_fdt(images);
1767
1768 return 1;
1769 }
1770 #endif
1771
1772 #if defined(CONFIG_CMD_ELF)
1773 static int do_bootm_qnxelf(int flag, int argc, char * const argv[],
1774 bootm_headers_t *images)
1775 {
1776 char *local_args[2];
1777 char str[16];
1778
1779 if (flag != BOOTM_STATE_OS_GO)
1780 return 0;
1781
1782 #if defined(CONFIG_FIT)
1783 if (!images->legacy_hdr_valid) {
1784 fit_unsupported_reset("QNX");
1785 return 1;
1786 }
1787 #endif
1788
1789 sprintf(str, "%lx", images->ep); /* write entry-point into string */
1790 local_args[0] = argv[0];
1791 local_args[1] = str; /* and provide it via the arguments */
1792 do_bootelf(NULL, 0, 2, local_args);
1793
1794 return 1;
1795 }
1796 #endif
1797
1798 #ifdef CONFIG_INTEGRITY
1799 static int do_bootm_integrity(int flag, int argc, char * const argv[],
1800 bootm_headers_t *images)
1801 {
1802 void (*entry_point)(void);
1803
1804 if (flag != BOOTM_STATE_OS_GO)
1805 return 0;
1806
1807 #if defined(CONFIG_FIT)
1808 if (!images->legacy_hdr_valid) {
1809 fit_unsupported_reset("INTEGRITY");
1810 return 1;
1811 }
1812 #endif
1813
1814 entry_point = (void (*)(void))images->ep;
1815
1816 printf("## Transferring control to INTEGRITY (at address %08lx) ...\n",
1817 (ulong)entry_point);
1818
1819 bootstage_mark(BOOTSTAGE_ID_RUN_OS);
1820
1821 /*
1822 * INTEGRITY Parameters:
1823 * None
1824 */
1825 (*entry_point)();
1826
1827 return 1;
1828 }
1829 #endif
1830
1831 #ifdef CONFIG_CMD_BOOTZ
1832
1833 int __weak bootz_setup(ulong image, ulong *start, ulong *end)
1834 {
1835 /* Please define bootz_setup() for your platform */
1836
1837 puts("Your platform's zImage format isn't supported yet!\n");
1838 return -1;
1839 }
1840
1841 /*
1842 * zImage booting support
1843 */
1844 static int bootz_start(cmd_tbl_t *cmdtp, int flag, int argc,
1845 char * const argv[], bootm_headers_t *images)
1846 {
1847 int ret;
1848 ulong zi_start, zi_end;
1849
1850 ret = do_bootm_states(cmdtp, flag, argc, argv, BOOTM_STATE_START,
1851 images, 1);
1852
1853 /* Setup Linux kernel zImage entry point */
1854 if (!argc) {
1855 images->ep = load_addr;
1856 debug("* kernel: default image load address = 0x%08lx\n",
1857 load_addr);
1858 } else {
1859 images->ep = simple_strtoul(argv[0], NULL, 16);
1860 debug("* kernel: cmdline image address = 0x%08lx\n",
1861 images->ep);
1862 }
1863
1864 ret = bootz_setup(images->ep, &zi_start, &zi_end);
1865 if (ret != 0)
1866 return 1;
1867
1868 lmb_reserve(&images->lmb, images->ep, zi_end - zi_start);
1869
1870 /*
1871 * Handle the BOOTM_STATE_FINDOTHER state ourselves as we do not
1872 * have a header that provide this informaiton.
1873 */
1874 if (bootm_find_ramdisk(flag, argc, argv))
1875 return 1;
1876
1877 #if defined(CONFIG_OF_LIBFDT)
1878 if (bootm_find_fdt(flag, argc, argv))
1879 return 1;
1880 #endif
1881
1882 return 0;
1883 }
1884
1885 int do_bootz(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
1886 {
1887 int ret;
1888
1889 /* Consume 'bootz' */
1890 argc--; argv++;
1891
1892 if (bootz_start(cmdtp, flag, argc, argv, &images))
1893 return 1;
1894
1895 /*
1896 * We are doing the BOOTM_STATE_LOADOS state ourselves, so must
1897 * disable interrupts ourselves
1898 */
1899 bootm_disable_interrupts();
1900
1901 images.os.os = IH_OS_LINUX;
1902 ret = do_bootm_states(cmdtp, flag, argc, argv,
1903 BOOTM_STATE_OS_PREP | BOOTM_STATE_OS_FAKE_GO |
1904 BOOTM_STATE_OS_GO,
1905 &images, 1);
1906
1907 return ret;
1908 }
1909
1910 #ifdef CONFIG_SYS_LONGHELP
1911 static char bootz_help_text[] =
1912 "[addr [initrd[:size]] [fdt]]\n"
1913 " - boot Linux zImage stored in memory\n"
1914 "\tThe argument 'initrd' is optional and specifies the address\n"
1915 "\tof the initrd in memory. The optional argument ':size' allows\n"
1916 "\tspecifying the size of RAW initrd.\n"
1917 #if defined(CONFIG_OF_LIBFDT)
1918 "\tWhen booting a Linux kernel which requires a flat device-tree\n"
1919 "\ta third argument is required which is the address of the\n"
1920 "\tdevice-tree blob. To boot that kernel without an initrd image,\n"
1921 "\tuse a '-' for the second argument. If you do not pass a third\n"
1922 "\ta bd_info struct will be passed instead\n"
1923 #endif
1924 "";
1925 #endif
1926
1927 U_BOOT_CMD(
1928 bootz, CONFIG_SYS_MAXARGS, 1, do_bootz,
1929 "boot Linux zImage image from memory", bootz_help_text
1930 );
1931 #endif /* CONFIG_CMD_BOOTZ */
"Das U-Boot" Source Tree