Merge branch 'master' of git://www.denx.de/git/u-boot into new-image
[platform/kernel/u-boot.git] / common / cmd_bootm.c
1 /*
2  * (C) Copyright 2000-2006
3  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
4  *
5  * See file CREDITS for list of people who contributed to this
6  * project.
7  *
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.
12  *
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.
17  *
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,
21  * MA 02111-1307 USA
22  */
23
24 #define DEBUG
25
26 /*
27  * Boot support
28  */
29 #include <common.h>
30 #include <watchdog.h>
31 #include <command.h>
32 #include <image.h>
33 #include <malloc.h>
34 #include <zlib.h>
35 #include <bzlib.h>
36 #include <environment.h>
37 #include <lmb.h>
38 #include <asm/byteorder.h>
39
40 #ifdef CFG_HUSH_PARSER
41 #include <hush.h>
42 #endif
43
44 DECLARE_GLOBAL_DATA_PTR;
45
46 extern int gunzip (void *dst, int dstlen, unsigned char *src, unsigned long *lenp);
47 #ifndef CFG_BOOTM_LEN
48 #define CFG_BOOTM_LEN   0x800000        /* use 8MByte as default max gunzip size */
49 #endif
50
51 #ifdef CONFIG_BZIP2
52 extern void bz_internal_error(int);
53 #endif
54
55 #if defined(CONFIG_CMD_IMI)
56 static int image_info (unsigned long addr);
57 #endif
58
59 #if defined(CONFIG_CMD_IMLS)
60 #include <flash.h>
61 extern flash_info_t flash_info[]; /* info for FLASH chips */
62 static int do_imls (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]);
63 #endif
64
65 #ifdef CONFIG_SILENT_CONSOLE
66 static void fixup_silent_linux (void);
67 #endif
68
69 static image_header_t *image_get_kernel (ulong img_addr, int verify);
70 #if defined(CONFIG_FIT)
71 static int fit_check_kernel (const void *fit, int os_noffset, int verify);
72 #endif
73
74 static void *boot_get_kernel (cmd_tbl_t *cmdtp, int flag,int argc, char *argv[],
75                 bootm_headers_t *images, ulong *os_data, ulong *os_len);
76 extern int do_reset (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]);
77
78 /*
79  *  Continue booting an OS image; caller already has:
80  *  - copied image header to global variable `header'
81  *  - checked header magic number, checksums (both header & image),
82  *  - verified image architecture (PPC) and type (KERNEL or MULTI),
83  *  - loaded (first part of) image to header load address,
84  *  - disabled interrupts.
85  */
86 typedef void boot_os_fn (cmd_tbl_t *cmdtp, int flag,
87                         int argc, char *argv[],
88                         bootm_headers_t *images); /* pointers to os/initrd/fdt */
89
90 extern boot_os_fn do_bootm_linux;
91 static boot_os_fn do_bootm_netbsd;
92 #if defined(CONFIG_LYNXKDI)
93 static boot_os_fn do_bootm_lynxkdi;
94 extern void lynxkdi_boot (image_header_t *);
95 #endif
96 static boot_os_fn do_bootm_rtems;
97 #if defined(CONFIG_CMD_ELF)
98 static boot_os_fn do_bootm_vxworks;
99 static boot_os_fn do_bootm_qnxelf;
100 int do_bootvx (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]);
101 int do_bootelf (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]);
102 #endif
103 #if defined(CONFIG_ARTOS) && defined(CONFIG_PPC)
104 extern uchar (*env_get_char)(int); /* Returns a character from the environment */
105 static boot_os_fn do_bootm_artos;
106 #endif
107
108 ulong load_addr = CFG_LOAD_ADDR;        /* Default Load Address */
109 static bootm_headers_t images;          /* pointers to os/initrd/fdt images */
110
111 void __board_lmb_reserve(struct lmb *lmb)
112 {
113         /* please define platform specific board_lmb_reserve() */
114 }
115 void board_lmb_reserve(struct lmb *lmb) __attribute__((weak, alias("__board_lmb_reserve")));
116
117
118 /*******************************************************************/
119 /* bootm - boot application image from image in memory */
120 /*******************************************************************/
121 int do_bootm (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
122 {
123         ulong           iflag;
124         const char      *type_name;
125         uint            unc_len = CFG_BOOTM_LEN;
126         uint8_t         comp, type, os;
127
128         void            *os_hdr;
129         ulong           os_data, os_len;
130         ulong           image_start, image_end;
131         ulong           load_start, load_end;
132         ulong           mem_start, mem_size;
133
134         struct lmb lmb;
135
136         memset ((void *)&images, 0, sizeof (images));
137         images.verify = getenv_verify();
138         images.autostart = getenv_autostart();
139         images.lmb = &lmb;
140
141         lmb_init(&lmb);
142
143         mem_start = getenv_bootm_low();
144         mem_size = getenv_bootm_size();
145
146         lmb_add(&lmb, mem_start, mem_size);
147
148         board_lmb_reserve(&lmb);
149
150         /* get kernel image header, start address and length */
151         os_hdr = boot_get_kernel (cmdtp, flag, argc, argv,
152                         &images, &os_data, &os_len);
153         if (os_len == 0) {
154                 puts ("ERROR: can't get kernel image!\n");
155                 return 1;
156         }
157
158         /* get image parameters */
159         switch (genimg_get_format (os_hdr)) {
160         case IMAGE_FORMAT_LEGACY:
161                 type = image_get_type (os_hdr);
162                 comp = image_get_comp (os_hdr);
163                 os = image_get_os (os_hdr);
164
165                 image_end = image_get_image_end (os_hdr);
166                 load_start = image_get_load (os_hdr);
167                 break;
168 #if defined(CONFIG_FIT)
169         case IMAGE_FORMAT_FIT:
170                 if (fit_image_get_type (images.fit_hdr_os,
171                                         images.fit_noffset_os, &type)) {
172                         puts ("Can't get image type!\n");
173                         show_boot_progress (-109);
174                         return 1;
175                 }
176
177                 if (fit_image_get_comp (images.fit_hdr_os,
178                                         images.fit_noffset_os, &comp)) {
179                         puts ("Can't get image compression!\n");
180                         show_boot_progress (-110);
181                         return 1;
182                 }
183
184                 if (fit_image_get_os (images.fit_hdr_os,
185                                         images.fit_noffset_os, &os)) {
186                         puts ("Can't get image OS!\n");
187                         show_boot_progress (-111);
188                         return 1;
189                 }
190
191                 image_end = fit_get_end (images.fit_hdr_os);
192
193                 if (fit_image_get_load (images.fit_hdr_os, images.fit_noffset_os,
194                                         &load_start)) {
195                         puts ("Can't get image load address!\n");
196                         show_boot_progress (-112);
197                         return 1;
198                 }
199                 break;
200 #endif
201         default:
202                 puts ("ERROR: unknown image format type!\n");
203                 return 1;
204         }
205
206         image_start = (ulong)os_hdr;
207         load_end = 0;
208         type_name = genimg_get_type_name (type);
209
210         /*
211          * We have reached the point of no return: we are going to
212          * overwrite all exception vector code, so we cannot easily
213          * recover from any failures any more...
214          */
215         iflag = disable_interrupts();
216
217 #ifdef CONFIG_AMIGAONEG3SE
218         /*
219          * We've possible left the caches enabled during
220          * bios emulation, so turn them off again
221          */
222         icache_disable();
223         invalidate_l1_instruction_cache();
224         flush_data_cache();
225         dcache_disable();
226 #endif
227
228         switch (comp) {
229         case IH_COMP_NONE:
230                 if (load_start == (ulong)os_hdr) {
231                         printf ("   XIP %s ... ", type_name);
232                 } else {
233                         printf ("   Loading %s ... ", type_name);
234
235                         memmove_wd ((void *)load_start,
236                                    (void *)os_data, os_len, CHUNKSZ);
237
238                         load_end = load_start + os_len;
239                         puts("OK\n");
240                 }
241                 break;
242         case IH_COMP_GZIP:
243                 printf ("   Uncompressing %s ... ", type_name);
244                 if (gunzip ((void *)load_start, unc_len,
245                                         (uchar *)os_data, &os_len) != 0) {
246                         puts ("GUNZIP: uncompress or overwrite error "
247                                 "- must RESET board to recover\n");
248                         show_boot_progress (-6);
249                         do_reset (cmdtp, flag, argc, argv);
250                 }
251
252                 load_end = load_start + os_len;
253                 break;
254 #ifdef CONFIG_BZIP2
255         case IH_COMP_BZIP2:
256                 printf ("   Uncompressing %s ... ", type_name);
257                 /*
258                  * If we've got less than 4 MB of malloc() space,
259                  * use slower decompression algorithm which requires
260                  * at most 2300 KB of memory.
261                  */
262                 int i = BZ2_bzBuffToBuffDecompress ((char*)load_start,
263                                         &unc_len, (char *)os_data, os_len,
264                                         CFG_MALLOC_LEN < (4096 * 1024), 0);
265                 if (i != BZ_OK) {
266                         printf ("BUNZIP2: uncompress or overwrite error %d "
267                                 "- must RESET board to recover\n", i);
268                         show_boot_progress (-6);
269                         do_reset (cmdtp, flag, argc, argv);
270                 }
271
272                 load_end = load_start + unc_len;
273                 break;
274 #endif /* CONFIG_BZIP2 */
275         default:
276                 if (iflag)
277                         enable_interrupts();
278                 printf ("Unimplemented compression type %d\n", comp);
279                 show_boot_progress (-7);
280                 return 1;
281         }
282         puts ("OK\n");
283         debug ("   kernel loaded at 0x%08lx, end = 0x%08lx\n", load_start, load_end);
284         show_boot_progress (7);
285
286         if ((load_start < image_end) && (load_end > image_start)) {
287                 debug ("image_start = 0x%lX, image_end = 0x%lx\n", image_start, image_end);
288                 debug ("load_start = 0x%lx, load_end = 0x%lx\n", load_start, load_end);
289
290                 puts ("ERROR: image overwritten - must RESET the board to recover.\n");
291                 show_boot_progress (-113);
292                 do_reset (cmdtp, flag, argc, argv);
293         }
294
295         show_boot_progress (8);
296
297         lmb_reserve(&lmb, load_start, (load_end - load_start));
298
299         switch (os) {
300         default:                        /* handled by (original) Linux case */
301         case IH_OS_LINUX:
302 #ifdef CONFIG_SILENT_CONSOLE
303             fixup_silent_linux();
304 #endif
305             do_bootm_linux (cmdtp, flag, argc, argv, &images);
306             break;
307
308         case IH_OS_NETBSD:
309             do_bootm_netbsd (cmdtp, flag, argc, argv, &images);
310             break;
311
312 #ifdef CONFIG_LYNXKDI
313         case IH_OS_LYNXOS:
314             do_bootm_lynxkdi (cmdtp, flag, argc, argv, &images);
315             break;
316 #endif
317
318         case IH_OS_RTEMS:
319             do_bootm_rtems (cmdtp, flag, argc, argv, &images);
320             break;
321
322 #if defined(CONFIG_CMD_ELF)
323         case IH_OS_VXWORKS:
324             do_bootm_vxworks (cmdtp, flag, argc, argv, &images);
325             break;
326
327         case IH_OS_QNX:
328             do_bootm_qnxelf (cmdtp, flag, argc, argv, &images);
329             break;
330 #endif
331
332 #ifdef CONFIG_ARTOS
333         case IH_OS_ARTOS:
334             do_bootm_artos (cmdtp, flag, argc, argv, &images);
335             break;
336 #endif
337         }
338
339         show_boot_progress (-9);
340 #ifdef DEBUG
341         puts ("\n## Control returned to monitor - resetting...\n");
342         if (images.autostart)
343                 do_reset (cmdtp, flag, argc, argv);
344 #endif
345         if (!images.autostart && iflag)
346                 enable_interrupts();
347
348         return 1;
349 }
350
351 /**
352  * image_get_kernel - verify legacy format kernel image
353  * @img_addr: in RAM address of the legacy format image to be verified
354  * @verify: data CRC verification flag
355  *
356  * image_get_kernel() verifies legacy image integrity and returns pointer to
357  * legacy image header if image verification was completed successfully.
358  *
359  * returns:
360  *     pointer to a legacy image header if valid image was found
361  *     otherwise return NULL
362  */
363 static image_header_t *image_get_kernel (ulong img_addr, int verify)
364 {
365         image_header_t *hdr = (image_header_t *)img_addr;
366
367         if (!image_check_magic(hdr)) {
368                 puts ("Bad Magic Number\n");
369                 show_boot_progress (-1);
370                 return NULL;
371         }
372         show_boot_progress (2);
373
374         if (!image_check_hcrc (hdr)) {
375                 puts ("Bad Header Checksum\n");
376                 show_boot_progress (-2);
377                 return NULL;
378         }
379
380         show_boot_progress (3);
381         image_print_contents (hdr);
382
383         if (verify) {
384                 puts ("   Verifying Checksum ... ");
385                 if (!image_check_dcrc (hdr)) {
386                         printf ("Bad Data CRC\n");
387                         show_boot_progress (-3);
388                         return NULL;
389                 }
390                 puts ("OK\n");
391         }
392         show_boot_progress (4);
393
394         if (!image_check_target_arch (hdr)) {
395                 printf ("Unsupported Architecture 0x%x\n", image_get_arch (hdr));
396                 show_boot_progress (-4);
397                 return NULL;
398         }
399         return hdr;
400 }
401
402 /**
403  * fit_check_kernel - verify FIT format kernel subimage
404  * @fit_hdr: pointer to the FIT image header
405  * os_noffset: kernel subimage node offset within FIT image
406  * @verify: data CRC verification flag
407  *
408  * fit_check_kernel() verifies integrity of the kernel subimage and from
409  * specified FIT image.
410  *
411  * returns:
412  *     1, on success
413  *     0, on failure
414  */
415 #if defined (CONFIG_FIT)
416 static int fit_check_kernel (const void *fit, int os_noffset, int verify)
417 {
418         fit_image_print (fit, os_noffset, "   ");
419
420         if (verify) {
421                 puts ("   Verifying Hash Integrity ... ");
422                 if (!fit_image_check_hashes (fit, os_noffset)) {
423                         puts ("Bad Data Hash\n");
424                         show_boot_progress (-104);
425                         return 0;
426                 }
427                 puts ("OK\n");
428         }
429         show_boot_progress (105);
430
431         if (!fit_image_check_target_arch (fit, os_noffset)) {
432                 puts ("Unsupported Architecture\n");
433                 show_boot_progress (-105);
434                 return 0;
435         }
436
437         show_boot_progress (106);
438         if (!fit_image_check_type (fit, os_noffset, IH_TYPE_KERNEL)) {
439                 puts ("Not a kernel image\n");
440                 show_boot_progress (-106);
441                 return 0;
442         }
443
444         show_boot_progress (107);
445         return 1;
446 }
447 #endif /* CONFIG_FIT */
448
449 /**
450  * boot_get_kernel - find kernel image
451  * @os_data: pointer to a ulong variable, will hold os data start address
452  * @os_len: pointer to a ulong variable, will hold os data length
453  *
454  * boot_get_kernel() tries to find a kernel image, verifies its integrity
455  * and locates kernel data.
456  *
457  * returns:
458  *     pointer to image header if valid image was found, plus kernel start
459  *     address and length, otherwise NULL
460  */
461 static void *boot_get_kernel (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[],
462                 bootm_headers_t *images, ulong *os_data, ulong *os_len)
463 {
464         image_header_t  *hdr;
465         ulong           img_addr;
466 #if defined(CONFIG_FIT)
467         void            *fit_hdr;
468         const char      *fit_uname_config = NULL;
469         const char      *fit_uname_kernel = NULL;
470         const void      *data;
471         size_t          len;
472         int             cfg_noffset;
473         int             os_noffset;
474 #endif
475
476         /* find out kernel image address */
477         if (argc < 2) {
478                 img_addr = load_addr;
479                 debug ("*  kernel: default image load address = 0x%08lx\n",
480                                 load_addr);
481 #if defined(CONFIG_FIT)
482         } else if (fit_parse_conf (argv[1], load_addr, &img_addr,
483                                                         &fit_uname_config)) {
484                 debug ("*  kernel: config '%s' from image at 0x%08lx\n",
485                                 fit_uname_config, img_addr);
486         } else if (fit_parse_subimage (argv[1], load_addr, &img_addr,
487                                                         &fit_uname_kernel)) {
488                 debug ("*  kernel: subimage '%s' from image at 0x%08lx\n",
489                                 fit_uname_kernel, img_addr);
490 #endif
491         } else {
492                 img_addr = simple_strtoul(argv[1], NULL, 16);
493                 debug ("*  kernel: cmdline image address = 0x%08lx\n", img_addr);
494         }
495
496         show_boot_progress (1);
497
498         /* copy from dataflash if needed */
499         img_addr = genimg_get_image (img_addr);
500
501         /* check image type, for FIT images get FIT kernel node */
502         *os_data = *os_len = 0;
503         switch (genimg_get_format ((void *)img_addr)) {
504         case IMAGE_FORMAT_LEGACY:
505                 printf ("## Booting kernel from Legacy Image at %08lx ...\n",
506                                 img_addr);
507                 hdr = image_get_kernel (img_addr, images->verify);
508                 if (!hdr)
509                         return NULL;
510                 show_boot_progress (5);
511
512                 /* get os_data and os_len */
513                 switch (image_get_type (hdr)) {
514                 case IH_TYPE_KERNEL:
515                         *os_data = image_get_data (hdr);
516                         *os_len = image_get_data_size (hdr);
517                         break;
518                 case IH_TYPE_MULTI:
519                         image_multi_getimg (hdr, 0, os_data, os_len);
520                         break;
521                 default:
522                         printf ("Wrong Image Type for %s command\n", cmdtp->name);
523                         show_boot_progress (-5);
524                         return NULL;
525                 }
526                 images->legacy_hdr_os = hdr;
527                 images->legacy_hdr_valid = 1;
528
529                 show_boot_progress (6);
530                 break;
531 #if defined(CONFIG_FIT)
532         case IMAGE_FORMAT_FIT:
533                 fit_hdr = (void *)img_addr;
534                 printf ("## Booting kernel from FIT Image at %08lx ...\n",
535                                 img_addr);
536
537                 if (!fit_check_format (fit_hdr)) {
538                         puts ("Bad FIT kernel image format!\n");
539                         show_boot_progress (-100);
540                         return NULL;
541                 }
542                 show_boot_progress (100);
543
544                 if (!fit_uname_kernel) {
545                         /*
546                          * no kernel image node unit name, try to get config
547                          * node first. If config unit node name is NULL
548                          * fit_conf_get_node() will try to find default config node
549                          */
550                         show_boot_progress (101);
551                         cfg_noffset = fit_conf_get_node (fit_hdr, fit_uname_config);
552                         if (cfg_noffset < 0) {
553                                 show_boot_progress (-101);
554                                 return NULL;
555                         }
556                         /* save configuration uname provided in the first
557                          * bootm argument
558                          */
559                         images->fit_uname_cfg = fdt_get_name (fit_hdr, cfg_noffset, NULL);
560                         printf ("   Using '%s' configuration\n", images->fit_uname_cfg);
561                         show_boot_progress (103);
562
563                         os_noffset = fit_conf_get_kernel_node (fit_hdr, cfg_noffset);
564                         fit_uname_kernel = fit_get_name (fit_hdr, os_noffset, NULL);
565                 } else {
566                         /* get kernel component image node offset */
567                         show_boot_progress (102);
568                         os_noffset = fit_image_get_node (fit_hdr, fit_uname_kernel);
569                 }
570                 if (os_noffset < 0) {
571                         show_boot_progress (-103);
572                         return NULL;
573                 }
574
575                 printf ("   Trying '%s' kernel subimage\n", fit_uname_kernel);
576
577                 show_boot_progress (104);
578                 if (!fit_check_kernel (fit_hdr, os_noffset, images->verify))
579                         return NULL;
580
581                 /* get kernel image data address and length */
582                 if (fit_image_get_data (fit_hdr, os_noffset, &data, &len)) {
583                         puts ("Could not find kernel subimage data!\n");
584                         show_boot_progress (-107);
585                         return NULL;
586                 }
587                 show_boot_progress (108);
588
589                 *os_len = len;
590                 *os_data = (ulong)data;
591                 images->fit_hdr_os = fit_hdr;
592                 images->fit_uname_os = fit_uname_kernel;
593                 images->fit_noffset_os = os_noffset;
594                 break;
595 #endif
596         default:
597                 printf ("Wrong Image Format for %s command\n", cmdtp->name);
598                 show_boot_progress (-108);
599                 return NULL;
600         }
601
602         debug ("   kernel data at 0x%08lx, len = 0x%08lx (%d)\n",
603                         *os_data, *os_len, *os_len);
604
605         return (void *)img_addr;
606 }
607
608 U_BOOT_CMD(
609         bootm,  CFG_MAXARGS,    1,      do_bootm,
610         "bootm   - boot application image from memory\n",
611         "[addr [arg ...]]\n    - boot application image stored in memory\n"
612         "\tpassing arguments 'arg ...'; when booting a Linux kernel,\n"
613         "\t'arg' can be the address of an initrd image\n"
614 #if defined(CONFIG_OF_LIBFDT)
615         "\tWhen booting a Linux kernel which requires a flat device-tree\n"
616         "\ta third argument is required which is the address of the\n"
617         "\tdevice-tree blob. To boot that kernel without an initrd image,\n"
618         "\tuse a '-' for the second argument. If you do not pass a third\n"
619         "\ta bd_info struct will be passed instead\n"
620 #endif
621 #if defined(CONFIG_FIT)
622         "\t\nFor the new multi component uImage format (FIT) addresses\n"
623         "\tmust be extened to include component or configuration unit name:\n"
624         "\taddr:<subimg_uname> - direct component image specification\n"
625         "\taddr#<conf_uname>   - configuration specification\n"
626         "\tUse iminfo command to get the list of existing component\n"
627         "\timages and configurations.\n"
628 #endif
629 );
630
631 /*******************************************************************/
632 /* bootd - boot default image */
633 /*******************************************************************/
634 #if defined(CONFIG_CMD_BOOTD)
635 int do_bootd (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
636 {
637         int rcode = 0;
638
639 #ifndef CFG_HUSH_PARSER
640         if (run_command (getenv ("bootcmd"), flag) < 0)
641                 rcode = 1;
642 #else
643         if (parse_string_outer (getenv ("bootcmd"),
644                         FLAG_PARSE_SEMICOLON | FLAG_EXIT_FROM_LOOP) != 0)
645                 rcode = 1;
646 #endif
647         return rcode;
648 }
649
650 U_BOOT_CMD(
651         boot,   1,      1,      do_bootd,
652         "boot    - boot default, i.e., run 'bootcmd'\n",
653         NULL
654 );
655
656 /* keep old command name "bootd" for backward compatibility */
657 U_BOOT_CMD(
658         bootd, 1,       1,      do_bootd,
659         "bootd   - boot default, i.e., run 'bootcmd'\n",
660         NULL
661 );
662
663 #endif
664
665
666 /*******************************************************************/
667 /* iminfo - print header info for a requested image */
668 /*******************************************************************/
669 #if defined(CONFIG_CMD_IMI)
670 int do_iminfo (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
671 {
672         int     arg;
673         ulong   addr;
674         int     rcode = 0;
675
676         if (argc < 2) {
677                 return image_info (load_addr);
678         }
679
680         for (arg = 1; arg < argc; ++arg) {
681                 addr = simple_strtoul (argv[arg], NULL, 16);
682                 if (image_info (addr) != 0)
683                         rcode = 1;
684         }
685         return rcode;
686 }
687
688 static int image_info (ulong addr)
689 {
690         void *hdr = (void *)addr;
691
692         printf ("\n## Checking Image at %08lx ...\n", addr);
693
694         switch (genimg_get_format (hdr)) {
695         case IMAGE_FORMAT_LEGACY:
696                 puts ("   Legacy image found\n");
697                 if (!image_check_magic (hdr)) {
698                         puts ("   Bad Magic Number\n");
699                         return 1;
700                 }
701
702                 if (!image_check_hcrc (hdr)) {
703                         puts ("   Bad Header Checksum\n");
704                         return 1;
705                 }
706
707                 image_print_contents (hdr);
708
709                 puts ("   Verifying Checksum ... ");
710                 if (!image_check_dcrc (hdr)) {
711                         puts ("   Bad Data CRC\n");
712                         return 1;
713                 }
714                 puts ("OK\n");
715                 return 0;
716 #if defined(CONFIG_FIT)
717         case IMAGE_FORMAT_FIT:
718                 puts ("   FIT image found\n");
719
720                 if (!fit_check_format (hdr)) {
721                         puts ("Bad FIT image format!\n");
722                         return 1;
723                 }
724
725                 fit_print_contents (hdr);
726                 return 0;
727 #endif
728         default:
729                 puts ("Unknown image format!\n");
730                 break;
731         }
732
733         return 1;
734 }
735
736 U_BOOT_CMD(
737         iminfo, CFG_MAXARGS,    1,      do_iminfo,
738         "iminfo  - print header information for application image\n",
739         "addr [addr ...]\n"
740         "    - print header information for application image starting at\n"
741         "      address 'addr' in memory; this includes verification of the\n"
742         "      image contents (magic number, header and payload checksums)\n"
743 );
744 #endif
745
746
747 /*******************************************************************/
748 /* imls - list all images found in flash */
749 /*******************************************************************/
750 #if defined(CONFIG_CMD_IMLS)
751 int do_imls (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
752 {
753         flash_info_t *info;
754         int i, j;
755         void *hdr;
756
757         for (i = 0, info = &flash_info[0];
758                 i < CFG_MAX_FLASH_BANKS; ++i, ++info) {
759
760                 if (info->flash_id == FLASH_UNKNOWN)
761                         goto next_bank;
762                 for (j = 0; j < info->sector_count; ++j) {
763
764                         hdr = (void *)info->start[j];
765                         if (!hdr)
766                                 goto next_sector;
767
768                         switch (genimg_get_format (hdr)) {
769                         case IMAGE_FORMAT_LEGACY:
770                                 if (!image_check_hcrc (hdr))
771                                         goto next_sector;
772
773                                 printf ("Legacy Image at %08lX:\n", (ulong)hdr);
774                                 image_print_contents (hdr);
775
776                                 puts ("   Verifying Checksum ... ");
777                                 if (!image_check_dcrc (hdr)) {
778                                         puts ("Bad Data CRC\n");
779                                 } else {
780                                         puts ("OK\n");
781                                 }
782                                 break;
783 #if defined(CONFIG_FIT)
784                         case IMAGE_FORMAT_FIT:
785                                 if (!fit_check_format (hdr))
786                                         goto next_sector;
787
788                                 printf ("FIT Image at %08lX:\n", (ulong)hdr);
789                                 fit_print_contents (hdr);
790                                 break;
791 #endif
792                         default:
793                                 goto next_sector;
794                         }
795
796 next_sector:            ;
797                 }
798 next_bank:      ;
799         }
800
801         return (0);
802 }
803
804 U_BOOT_CMD(
805         imls,   1,              1,      do_imls,
806         "imls    - list all images found in flash\n",
807         "\n"
808         "    - Prints information about all images found at sector\n"
809         "      boundaries in flash.\n"
810 );
811 #endif
812
813 /*******************************************************************/
814 /* helper routines */
815 /*******************************************************************/
816 #ifdef CONFIG_SILENT_CONSOLE
817 static void fixup_silent_linux ()
818 {
819         char buf[256], *start, *end;
820         char *cmdline = getenv ("bootargs");
821
822         /* Only fix cmdline when requested */
823         if (!(gd->flags & GD_FLG_SILENT))
824                 return;
825
826         debug ("before silent fix-up: %s\n", cmdline);
827         if (cmdline) {
828                 if ((start = strstr (cmdline, "console=")) != NULL) {
829                         end = strchr (start, ' ');
830                         strncpy (buf, cmdline, (start - cmdline + 8));
831                         if (end)
832                                 strcpy (buf + (start - cmdline + 8), end);
833                         else
834                                 buf[start - cmdline + 8] = '\0';
835                 } else {
836                         strcpy (buf, cmdline);
837                         strcat (buf, " console=");
838                 }
839         } else {
840                 strcpy (buf, "console=");
841         }
842
843         setenv ("bootargs", buf);
844         debug ("after silent fix-up: %s\n", buf);
845 }
846 #endif /* CONFIG_SILENT_CONSOLE */
847
848
849 /*******************************************************************/
850 /* OS booting routines */
851 /*******************************************************************/
852
853 static void do_bootm_netbsd (cmd_tbl_t *cmdtp, int flag,
854                             int argc, char *argv[],
855                             bootm_headers_t *images)
856 {
857         void (*loader)(bd_t *, image_header_t *, char *, char *);
858         image_header_t *os_hdr, *hdr;
859         ulong kernel_data, kernel_len;
860         char *consdev;
861         char *cmdline;
862
863 #if defined(CONFIG_FIT)
864         if (!images->legacy_hdr_valid) {
865                 fit_unsupported_reset ("NetBSD");
866                 do_reset (cmdtp, flag, argc, argv);
867         }
868 #endif
869         hdr = images->legacy_hdr_os;
870
871         /*
872          * Booting a (NetBSD) kernel image
873          *
874          * This process is pretty similar to a standalone application:
875          * The (first part of an multi-) image must be a stage-2 loader,
876          * which in turn is responsible for loading & invoking the actual
877          * kernel.  The only differences are the parameters being passed:
878          * besides the board info strucure, the loader expects a command
879          * line, the name of the console device, and (optionally) the
880          * address of the original image header.
881          */
882         os_hdr = NULL;
883         if (image_check_type (hdr, IH_TYPE_MULTI)) {
884                 image_multi_getimg (hdr, 1, &kernel_data, &kernel_len);
885                 if (kernel_len)
886                         os_hdr = hdr;
887         }
888
889         consdev = "";
890 #if   defined (CONFIG_8xx_CONS_SMC1)
891         consdev = "smc1";
892 #elif defined (CONFIG_8xx_CONS_SMC2)
893         consdev = "smc2";
894 #elif defined (CONFIG_8xx_CONS_SCC2)
895         consdev = "scc2";
896 #elif defined (CONFIG_8xx_CONS_SCC3)
897         consdev = "scc3";
898 #endif
899
900         if (argc > 2) {
901                 ulong len;
902                 int   i;
903
904                 for (i = 2, len = 0; i < argc; i += 1)
905                         len += strlen (argv[i]) + 1;
906                 cmdline = malloc (len);
907
908                 for (i = 2, len = 0; i < argc; i += 1) {
909                         if (i > 2)
910                                 cmdline[len++] = ' ';
911                         strcpy (&cmdline[len], argv[i]);
912                         len += strlen (argv[i]);
913                 }
914         } else if ((cmdline = getenv ("bootargs")) == NULL) {
915                 cmdline = "";
916         }
917
918         loader = (void (*)(bd_t *, image_header_t *, char *, char *))image_get_ep (hdr);
919
920         printf ("## Transferring control to NetBSD stage-2 loader (at address %08lx) ...\n",
921                 (ulong)loader);
922
923         show_boot_progress (15);
924
925         /*
926          * NetBSD Stage-2 Loader Parameters:
927          *   r3: ptr to board info data
928          *   r4: image address
929          *   r5: console device
930          *   r6: boot args string
931          */
932         (*loader) (gd->bd, os_hdr, consdev, cmdline);
933 }
934
935 #ifdef CONFIG_LYNXKDI
936 static void do_bootm_lynxkdi (cmd_tbl_t *cmdtp, int flag,
937                              int argc, char *argv[],
938                              bootm_headers_t *images)
939 {
940         image_header_t *hdr = images->legacy_hdr_os;
941
942 #if defined(CONFIG_FIT)
943         if (!images->legacy_hdr_valid) {
944                 fit_unsupported_reset ("Lynx");
945                 do_reset (cmdtp, flag, argc, argv);
946         }
947 #endif
948
949         lynxkdi_boot ((image_header_t *)hdr);
950 }
951 #endif /* CONFIG_LYNXKDI */
952
953 static void do_bootm_rtems (cmd_tbl_t *cmdtp, int flag,
954                            int argc, char *argv[],
955                            bootm_headers_t *images)
956 {
957         image_header_t *hdr = images->legacy_hdr_os;
958         void (*entry_point)(bd_t *);
959
960 #if defined(CONFIG_FIT)
961         if (!images->legacy_hdr_valid) {
962                 fit_unsupported_reset ("RTEMS");
963                 do_reset (cmdtp, flag, argc, argv);
964         }
965 #endif
966
967         entry_point = (void (*)(bd_t *))image_get_ep (hdr);
968
969         printf ("## Transferring control to RTEMS (at address %08lx) ...\n",
970                 (ulong)entry_point);
971
972         show_boot_progress (15);
973
974         /*
975          * RTEMS Parameters:
976          *   r3: ptr to board info data
977          */
978         (*entry_point)(gd->bd);
979 }
980
981 #if defined(CONFIG_CMD_ELF)
982 static void do_bootm_vxworks (cmd_tbl_t *cmdtp, int flag,
983                              int argc, char *argv[],
984                              bootm_headers_t *images)
985 {
986         char str[80];
987         image_header_t *hdr = images->legacy_hdr_os;
988
989 #if defined(CONFIG_FIT)
990         if (hdr == NULL) {
991                 fit_unsupported_reset ("VxWorks");
992                 do_reset (cmdtp, flag, argc, argv);
993         }
994 #endif
995
996         sprintf(str, "%x", image_get_ep (hdr)); /* write entry-point into string */
997         setenv("loadaddr", str);
998         do_bootvx(cmdtp, 0, 0, NULL);
999 }
1000
1001 static void do_bootm_qnxelf(cmd_tbl_t *cmdtp, int flag,
1002                             int argc, char *argv[],
1003                             bootm_headers_t *images)
1004 {
1005         char *local_args[2];
1006         char str[16];
1007         image_header_t *hdr = images->legacy_hdr_os;
1008
1009 #if defined(CONFIG_FIT)
1010         if (!images->legacy_hdr_valid) {
1011                 fit_unsupported_reset ("QNX");
1012                 do_reset (cmdtp, flag, argc, argv);
1013         }
1014 #endif
1015
1016         sprintf(str, "%x", image_get_ep (hdr)); /* write entry-point into string */
1017         local_args[0] = argv[0];
1018         local_args[1] = str;    /* and provide it via the arguments */
1019         do_bootelf(cmdtp, 0, 2, local_args);
1020 }
1021 #endif
1022
1023 #if defined(CONFIG_ARTOS) && defined(CONFIG_PPC)
1024 static void do_bootm_artos (cmd_tbl_t *cmdtp, int flag,
1025                            int argc, char *argv[],
1026                            bootm_headers_t *images)
1027 {
1028         ulong top;
1029         char *s, *cmdline;
1030         char **fwenv, **ss;
1031         int i, j, nxt, len, envno, envsz;
1032         bd_t *kbd;
1033         void (*entry)(bd_t *bd, char *cmdline, char **fwenv, ulong top);
1034         image_header_t *hdr = images->legacy_hdr_os;
1035
1036 #if defined(CONFIG_FIT)
1037         if (!images->legacy_hdr_valid) {
1038                 fit_unsupported_reset ("ARTOS");
1039                 do_reset (cmdtp, flag, argc, argv);
1040         }
1041 #endif
1042
1043         /*
1044          * Booting an ARTOS kernel image + application
1045          */
1046
1047         /* this used to be the top of memory, but was wrong... */
1048 #ifdef CONFIG_PPC
1049         /* get stack pointer */
1050         asm volatile ("mr %0,1" : "=r"(top) );
1051 #endif
1052         debug ("## Current stack ends at 0x%08lX ", top);
1053
1054         top -= 2048;            /* just to be sure */
1055         if (top > CFG_BOOTMAPSZ)
1056                 top = CFG_BOOTMAPSZ;
1057         top &= ~0xF;
1058
1059         debug ("=> set upper limit to 0x%08lX\n", top);
1060
1061         /* first check the artos specific boot args, then the linux args*/
1062         if ((s = getenv( "abootargs")) == NULL && (s = getenv ("bootargs")) == NULL)
1063                 s = "";
1064
1065         /* get length of cmdline, and place it */
1066         len = strlen (s);
1067         top = (top - (len + 1)) & ~0xF;
1068         cmdline = (char *)top;
1069         debug ("## cmdline at 0x%08lX ", top);
1070         strcpy (cmdline, s);
1071
1072         /* copy bdinfo */
1073         top = (top - sizeof (bd_t)) & ~0xF;
1074         debug ("## bd at 0x%08lX ", top);
1075         kbd = (bd_t *)top;
1076         memcpy (kbd, gd->bd, sizeof (bd_t));
1077
1078         /* first find number of env entries, and their size */
1079         envno = 0;
1080         envsz = 0;
1081         for (i = 0; env_get_char (i) != '\0'; i = nxt + 1) {
1082                 for (nxt = i; env_get_char (nxt) != '\0'; ++nxt)
1083                         ;
1084                 envno++;
1085                 envsz += (nxt - i) + 1; /* plus trailing zero */
1086         }
1087         envno++;        /* plus the terminating zero */
1088         debug ("## %u envvars total size %u ", envno, envsz);
1089
1090         top = (top - sizeof (char **) * envno) & ~0xF;
1091         fwenv = (char **)top;
1092         debug ("## fwenv at 0x%08lX ", top);
1093
1094         top = (top - envsz) & ~0xF;
1095         s = (char *)top;
1096         ss = fwenv;
1097
1098         /* now copy them */
1099         for (i = 0; env_get_char (i) != '\0'; i = nxt + 1) {
1100                 for (nxt = i; env_get_char (nxt) != '\0'; ++nxt)
1101                         ;
1102                 *ss++ = s;
1103                 for (j = i; j < nxt; ++j)
1104                         *s++ = env_get_char (j);
1105                 *s++ = '\0';
1106         }
1107         *ss++ = NULL;   /* terminate */
1108
1109         entry = (void (*)(bd_t *, char *, char **, ulong))image_get_ep (hdr);
1110         (*entry) (kbd, cmdline, fwenv, top);
1111 }
1112 #endif