X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=common%2Fcmd_bootm.c;h=365ceebdf0672c0260ac5c2314939a1b65552845;hb=9179dd3bf5c257d1479fb4a154b57f33e3d839be;hp=f441e0e011a4312b7c5945a3e54145c84e8e4ce3;hpb=7582438c285bf0cef82909d0f232de64ec567a8a;p=oweals%2Fu-boot.git diff --git a/common/cmd_bootm.c b/common/cmd_bootm.c index f441e0e011..365ceebdf0 100644 --- a/common/cmd_bootm.c +++ b/common/cmd_bootm.c @@ -1,5 +1,5 @@ /* - * (C) Copyright 2000-2006 + * (C) Copyright 2000-2009 * Wolfgang Denk, DENX Software Engineering, wd@denx.de. * * See file CREDITS for list of people who contributed to this @@ -21,7 +21,6 @@ * MA 02111-1307 USA */ -#define DEBUG /* * Boot support @@ -31,36 +30,38 @@ #include #include #include -#include +#include #include #include +#include +#include #include -#if defined(CONFIG_OF_LIBFDT) -#include -#include -#include -#elif defined(CONFIG_OF_FLAT_TREE) -#include +#if defined(CONFIG_CMD_USB) +#include #endif -#if defined(CONFIG_TIMESTAMP) || defined(CONFIG_CMD_DATE) -#include -#endif - -#ifdef CFG_HUSH_PARSER +#ifdef CONFIG_SYS_HUSH_PARSER #include #endif -#ifdef CONFIG_HAS_DATAFLASH -#include +#if defined(CONFIG_OF_LIBFDT) +#include +#include +#include #endif +#ifdef CONFIG_LZMA +#include +#include +#include +#endif /* CONFIG_LZMA */ + DECLARE_GLOBAL_DATA_PTR; extern int gunzip (void *dst, int dstlen, unsigned char *src, unsigned long *lenp); -#ifndef CFG_BOOTM_LEN -#define CFG_BOOTM_LEN 0x800000 /* use 8MByte as default max gunzip size */ +#ifndef CONFIG_SYS_BOOTM_LEN +#define CONFIG_SYS_BOOTM_LEN 0x800000 /* use 8MByte as default max gunzip size */ #endif #ifdef CONFIG_BZIP2 @@ -81,7 +82,13 @@ static int do_imls (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]); static void fixup_silent_linux (void); #endif -static void print_type (image_header_t *hdr); +static image_header_t *image_get_kernel (ulong img_addr, int verify); +#if defined(CONFIG_FIT) +static int fit_check_kernel (const void *fit, int os_noffset, int verify); +#endif + +static void *boot_get_kernel (cmd_tbl_t *cmdtp, int flag,int argc, char *argv[], + bootm_headers_t *images, ulong *os_data, ulong *os_len); extern int do_reset (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]); /* @@ -92,311 +99,909 @@ extern int do_reset (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]); * - loaded (first part of) image to header load address, * - disabled interrupts. */ -typedef void boot_os_fn (cmd_tbl_t *cmdtp, int flag, - int argc, char *argv[], - image_header_t *hdr, /* of image to boot */ - int verify); /* getenv("verify")[0] != 'n' */ +typedef int boot_os_fn (int flag, int argc, char *argv[], + bootm_headers_t *images); /* pointers to os/initrd/fdt */ + +#define CONFIG_BOOTM_LINUX 1 +#define CONFIG_BOOTM_NETBSD 1 +#define CONFIG_BOOTM_RTEMS 1 +#ifdef CONFIG_BOOTM_LINUX extern boot_os_fn do_bootm_linux; +#endif +#ifdef CONFIG_BOOTM_NETBSD static boot_os_fn do_bootm_netbsd; +#endif #if defined(CONFIG_LYNXKDI) static boot_os_fn do_bootm_lynxkdi; extern void lynxkdi_boot (image_header_t *); #endif +#ifdef CONFIG_BOOTM_RTEMS static boot_os_fn do_bootm_rtems; +#endif #if defined(CONFIG_CMD_ELF) static boot_os_fn do_bootm_vxworks; static boot_os_fn do_bootm_qnxelf; int do_bootvx (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]); int do_bootelf (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]); #endif -#if defined(CONFIG_ARTOS) && defined(CONFIG_PPC) -extern uchar (*env_get_char)(int); /* Returns a character from the environment */ -static boot_os_fn do_bootm_artos; +#if defined(CONFIG_INTEGRITY) +static boot_os_fn do_bootm_integrity; #endif -ulong load_addr = CFG_LOAD_ADDR; /* Default Load Address */ +boot_os_fn * boot_os[] = { +#ifdef CONFIG_BOOTM_LINUX + [IH_OS_LINUX] = do_bootm_linux, +#endif +#ifdef CONFIG_BOOTM_NETBSD + [IH_OS_NETBSD] = do_bootm_netbsd, +#endif +#ifdef CONFIG_LYNXKDI + [IH_OS_LYNXOS] = do_bootm_lynxkdi, +#endif +#ifdef CONFIG_BOOTM_RTEMS + [IH_OS_RTEMS] = do_bootm_rtems, +#endif +#if defined(CONFIG_CMD_ELF) + [IH_OS_VXWORKS] = do_bootm_vxworks, + [IH_OS_QNX] = do_bootm_qnxelf, +#endif +#ifdef CONFIG_INTEGRITY + [IH_OS_INTEGRITY] = do_bootm_integrity, +#endif +}; +ulong load_addr = CONFIG_SYS_LOAD_ADDR; /* Default Load Address */ +static bootm_headers_t images; /* pointers to os/initrd/fdt images */ -/*******************************************************************/ -/* bootm - boot application image from image in memory */ -/*******************************************************************/ -int do_bootm (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]) +void __board_lmb_reserve(struct lmb *lmb) { - ulong iflag; - char *name, *s; - int (*appl)(int, char *[]); - uint unc_len = CFG_BOOTM_LEN; - int verify = getenv_verify(); + /* please define platform specific board_lmb_reserve() */ +} +void board_lmb_reserve(struct lmb *lmb) __attribute__((weak, alias("__board_lmb_reserve"))); - image_header_t *hdr; - ulong img_addr; - ulong os_data, os_len; +void __arch_lmb_reserve(struct lmb *lmb) +{ + /* please define platform specific arch_lmb_reserve() */ +} +void arch_lmb_reserve(struct lmb *lmb) __attribute__((weak, alias("__arch_lmb_reserve"))); - ulong image_start, image_end; - ulong load_start, load_end; +/* Allow for arch specific config before we boot */ +void __arch_preboot_os(void) +{ + /* please define platform specific arch_preboot_os() */ +} +void arch_preboot_os(void) __attribute__((weak, alias("__arch_preboot_os"))); + +#if defined(__ARM__) + #define IH_INITRD_ARCH IH_ARCH_ARM +#elif defined(__avr32__) + #define IH_INITRD_ARCH IH_ARCH_AVR32 +#elif defined(__bfin__) + #define IH_INITRD_ARCH IH_ARCH_BLACKFIN +#elif defined(__I386__) + #define IH_INITRD_ARCH IH_ARCH_I386 +#elif defined(__M68K__) + #define IH_INITRD_ARCH IH_ARCH_M68K +#elif defined(__microblaze__) + #define IH_INITRD_ARCH IH_ARCH_MICROBLAZE +#elif defined(__mips__) + #define IH_INITRD_ARCH IH_ARCH_MIPS +#elif defined(__nios__) + #define IH_INITRD_ARCH IH_ARCH_NIOS +#elif defined(__nios2__) + #define IH_INITRD_ARCH IH_ARCH_NIOS2 +#elif defined(__PPC__) + #define IH_INITRD_ARCH IH_ARCH_PPC +#elif defined(__sh__) + #define IH_INITRD_ARCH IH_ARCH_SH +#elif defined(__sparc__) + #define IH_INITRD_ARCH IH_ARCH_SPARC +#else +# error Unknown CPU type +#endif +static int bootm_start(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]) +{ + ulong mem_start; + phys_size_t mem_size; + void *os_hdr; + int ret; - if (argc < 2) { - img_addr = load_addr; - } else { - img_addr = simple_strtoul(argv[1], NULL, 16); - } + memset ((void *)&images, 0, sizeof (images)); + images.verify = getenv_yesno ("verify"); - show_boot_progress (1); - printf ("## Booting image at %08lx ...\n", img_addr); + lmb_init(&images.lmb); -#ifdef CONFIG_HAS_DATAFLASH - if (addr_dataflash (img_addr)){ - hdr = (image_header_t *)CFG_LOAD_ADDR; - read_dataflash (img_addr, image_get_header_size (), (char *)hdr); - } else -#endif - hdr = (image_header_t *)img_addr; + mem_start = getenv_bootm_low(); + mem_size = getenv_bootm_size(); - if (!image_check_magic(hdr)) { - puts ("Bad Magic Number\n"); - show_boot_progress (-1); - return 1; - } - show_boot_progress (2); + lmb_add(&images.lmb, (phys_addr_t)mem_start, mem_size); - if (!image_check_hcrc (hdr)) { - puts ("Bad Header Checksum\n"); - show_boot_progress (-2); + arch_lmb_reserve(&images.lmb); + board_lmb_reserve(&images.lmb); + + /* get kernel image header, start address and length */ + os_hdr = boot_get_kernel (cmdtp, flag, argc, argv, + &images, &images.os.image_start, &images.os.image_len); + if (images.os.image_len == 0) { + puts ("ERROR: can't get kernel image!\n"); return 1; } - show_boot_progress (3); -#ifdef CONFIG_HAS_DATAFLASH - if (addr_dataflash (img_addr)) - read_dataflash (img_addr + image_get_header_size (), - image_get_data_size (hdr), - (char *)image_get_data (hdr)); -#endif + /* get image parameters */ + switch (genimg_get_format (os_hdr)) { + case IMAGE_FORMAT_LEGACY: + images.os.type = image_get_type (os_hdr); + images.os.comp = image_get_comp (os_hdr); + images.os.os = image_get_os (os_hdr); - /* uImage is in a system RAM, pointed to by hdr */ - print_image_hdr (hdr); + images.os.end = image_get_image_end (os_hdr); + images.os.load = image_get_load (os_hdr); + break; +#if defined(CONFIG_FIT) + case IMAGE_FORMAT_FIT: + if (fit_image_get_type (images.fit_hdr_os, + images.fit_noffset_os, &images.os.type)) { + puts ("Can't get image type!\n"); + show_boot_progress (-109); + return 1; + } - if (verify) { - puts (" Verifying Checksum ... "); - if (!image_check_dcrc (hdr)) { - printf ("Bad Data CRC\n"); - show_boot_progress (-3); + if (fit_image_get_comp (images.fit_hdr_os, + images.fit_noffset_os, &images.os.comp)) { + puts ("Can't get image compression!\n"); + show_boot_progress (-110); return 1; } - puts ("OK\n"); - } - show_boot_progress (4); - if (!image_check_target_arch (hdr)) { - printf ("Unsupported Architecture 0x%x\n", image_get_arch (hdr)); - show_boot_progress (-4); - return 1; - } - show_boot_progress (5); + if (fit_image_get_os (images.fit_hdr_os, + images.fit_noffset_os, &images.os.os)) { + puts ("Can't get image OS!\n"); + show_boot_progress (-111); + return 1; + } + + images.os.end = fit_get_end (images.fit_hdr_os); - switch (image_get_type (hdr)) { - case IH_TYPE_STANDALONE: - name = "Standalone Application"; - /* A second argument overwrites the load address */ - if (argc > 2) { - image_set_load (hdr, simple_strtoul (argv[2], NULL, 16)); + if (fit_image_get_load (images.fit_hdr_os, images.fit_noffset_os, + &images.os.load)) { + puts ("Can't get image load address!\n"); + show_boot_progress (-112); + return 1; } break; - case IH_TYPE_KERNEL: - name = "Kernel Image"; - os_data = image_get_data (hdr); - os_len = image_get_data_size (hdr); - break; - case IH_TYPE_MULTI: - name = "Multi-File Image"; - image_multi_getimg (hdr, 0, &os_data, &os_len); - break; +#endif default: - printf ("Wrong Image Type for %s command\n", cmdtp->name); - show_boot_progress (-5); + puts ("ERROR: unknown image format type!\n"); return 1; } - show_boot_progress (6); - /* - * We have reached the point of no return: we are going to - * overwrite all exception vector code, so we cannot easily - * recover from any failures any more... - */ - iflag = disable_interrupts(); + /* find kernel entry point */ + if (images.legacy_hdr_valid) { + images.ep = image_get_ep (&images.legacy_hdr_os_copy); +#if defined(CONFIG_FIT) + } else if (images.fit_uname_os) { + ret = fit_image_get_entry (images.fit_hdr_os, + images.fit_noffset_os, &images.ep); + if (ret) { + puts ("Can't get entry point property!\n"); + return 1; + } +#endif + } else { + puts ("Could not find kernel entry point!\n"); + return 1; + } -#ifdef CONFIG_AMIGAONEG3SE - /* - * We've possible left the caches enabled during - * bios emulation, so turn them off again - */ - icache_disable(); - invalidate_l1_instruction_cache(); - flush_data_cache(); - dcache_disable(); + if (images.os.os == IH_OS_LINUX) { + /* find ramdisk */ + ret = boot_get_ramdisk (argc, argv, &images, IH_INITRD_ARCH, + &images.rd_start, &images.rd_end); + if (ret) { + puts ("Ramdisk image is corrupt or invalid\n"); + return 1; + } + +#if defined(CONFIG_OF_LIBFDT) +#if defined(CONFIG_PPC) || defined(CONFIG_M68K) || defined(CONFIG_SPARC) + /* find flattened device tree */ + ret = boot_get_fdt (flag, argc, argv, &images, + &images.ft_addr, &images.ft_len); + if (ret) { + puts ("Could not find a valid device tree\n"); + return 1; + } + + set_working_fdt_addr(images.ft_addr); +#endif #endif + } - image_start = (ulong)hdr; - image_end = image_get_image_end (hdr); - load_start = image_get_load (hdr); - load_end = 0; + images.os.start = (ulong)os_hdr; + images.state = BOOTM_STATE_START; - switch (image_get_comp (hdr)) { + return 0; +} + +#define BOOTM_ERR_RESET -1 +#define BOOTM_ERR_OVERLAP -2 +#define BOOTM_ERR_UNIMPLEMENTED -3 +static int bootm_load_os(image_info_t os, ulong *load_end, int boot_progress) +{ + uint8_t comp = os.comp; + ulong load = os.load; + ulong blob_start = os.start; + ulong blob_end = os.end; + ulong image_start = os.image_start; + ulong image_len = os.image_len; + uint unc_len = CONFIG_SYS_BOOTM_LEN; + + const char *type_name = genimg_get_type_name (os.type); + + switch (comp) { case IH_COMP_NONE: - if (image_get_load (hdr) == img_addr) { - printf (" XIP %s ... ", name); + if (load == blob_start) { + printf (" XIP %s ... ", type_name); } else { - printf (" Loading %s ... ", name); - - memmove_wd ((void *)image_get_load (hdr), - (void *)os_data, os_len, CHUNKSZ); + printf (" Loading %s ... ", type_name); - load_end = load_start + os_len; - puts("OK\n"); + if (load != image_start) { + memmove_wd ((void *)load, + (void *)image_start, image_len, CHUNKSZ); + } } + *load_end = load + image_len; + puts("OK\n"); break; case IH_COMP_GZIP: - printf (" Uncompressing %s ... ", name); - if (gunzip ((void *)image_get_load (hdr), unc_len, - (uchar *)os_data, &os_len) != 0) { - puts ("GUNZIP ERROR - must RESET board to recover\n"); - show_boot_progress (-6); - do_reset (cmdtp, flag, argc, argv); + printf (" Uncompressing %s ... ", type_name); + if (gunzip ((void *)load, unc_len, + (uchar *)image_start, &image_len) != 0) { + puts ("GUNZIP: uncompress, out-of-mem or overwrite error " + "- must RESET board to recover\n"); + if (boot_progress) + show_boot_progress (-6); + return BOOTM_ERR_RESET; } - load_end = load_start + os_len; + *load_end = load + image_len; break; #ifdef CONFIG_BZIP2 case IH_COMP_BZIP2: - printf (" Uncompressing %s ... ", name); + printf (" Uncompressing %s ... ", type_name); /* * If we've got less than 4 MB of malloc() space, * use slower decompression algorithm which requires * at most 2300 KB of memory. */ - int i = BZ2_bzBuffToBuffDecompress ((char*)image_get_load (hdr), - &unc_len, (char *)os_data, os_len, - CFG_MALLOC_LEN < (4096 * 1024), 0); + int i = BZ2_bzBuffToBuffDecompress ((char*)load, + &unc_len, (char *)image_start, image_len, + CONFIG_SYS_MALLOC_LEN < (4096 * 1024), 0); if (i != BZ_OK) { - printf ("BUNZIP2 ERROR %d - must RESET board to recover\n", i); - show_boot_progress (-6); - do_reset (cmdtp, flag, argc, argv); + printf ("BUNZIP2: uncompress or overwrite error %d " + "- must RESET board to recover\n", i); + if (boot_progress) + show_boot_progress (-6); + return BOOTM_ERR_RESET; } - load_end = load_start + unc_len; + *load_end = load + unc_len; break; #endif /* CONFIG_BZIP2 */ +#ifdef CONFIG_LZMA + case IH_COMP_LZMA: + printf (" Uncompressing %s ... ", type_name); + + int ret = lzmaBuffToBuffDecompress( + (unsigned char *)load, &unc_len, + (unsigned char *)image_start, image_len); + if (ret != SZ_OK) { + printf ("LZMA: uncompress or overwrite error %d " + "- must RESET board to recover\n", ret); + show_boot_progress (-6); + return BOOTM_ERR_RESET; + } + *load_end = load + unc_len; + break; +#endif /* CONFIG_LZMA */ default: - if (iflag) - enable_interrupts(); - printf ("Unimplemented compression type %d\n", image_get_comp (hdr)); - show_boot_progress (-7); - return 1; + printf ("Unimplemented compression type %d\n", comp); + return BOOTM_ERR_UNIMPLEMENTED; } puts ("OK\n"); - show_boot_progress (7); + debug (" kernel loaded at 0x%08lx, end = 0x%08lx\n", load, *load_end); + if (boot_progress) + show_boot_progress (7); - if ((load_start < image_end) && (load_end > image_start)) { - debug ("image_start = 0x%lX, image_end = 0x%lx\n", image_start, image_end); - debug ("load_start = 0x%lx, load_end = 0x%lx\n", load_start, load_end); + if ((load < blob_end) && (*load_end > blob_start)) { + debug ("images.os.start = 0x%lX, images.os.end = 0x%lx\n", blob_start, blob_end); + debug ("images.os.load = 0x%lx, load_end = 0x%lx\n", load, *load_end); - puts ("ERROR: image overwritten - must RESET the board to recover.\n"); - do_reset (cmdtp, flag, argc, argv); + return BOOTM_ERR_OVERLAP; } - switch (image_get_type (hdr)) { - case IH_TYPE_STANDALONE: - if (iflag) - enable_interrupts(); + return 0; +} - /* load (and uncompress), but don't start if "autostart" - * is set to "no" +static int bootm_start_standalone(ulong iflag, int argc, char *argv[]) +{ + char *s; + int (*appl)(int, char *[]); + + /* Don't start if "autostart" is set to "no" */ + if (((s = getenv("autostart")) != NULL) && (strcmp(s, "no") == 0)) { + char buf[32]; + sprintf(buf, "%lX", images.os.image_len); + setenv("filesize", buf); + return 0; + } + appl = (int (*)(int, char *[]))ntohl(images.ep); + (*appl)(argc-1, &argv[1]); + + return 0; +} + +/* we overload the cmd field with our state machine info instead of a + * function pointer */ +cmd_tbl_t cmd_bootm_sub[] = { + U_BOOT_CMD_MKENT(start, 0, 1, (void *)BOOTM_STATE_START, "", ""), + U_BOOT_CMD_MKENT(loados, 0, 1, (void *)BOOTM_STATE_LOADOS, "", ""), +#if defined(CONFIG_PPC) || defined(CONFIG_M68K) || defined(CONFIG_SPARC) + U_BOOT_CMD_MKENT(ramdisk, 0, 1, (void *)BOOTM_STATE_RAMDISK, "", ""), +#endif +#ifdef CONFIG_OF_LIBFDT + U_BOOT_CMD_MKENT(fdt, 0, 1, (void *)BOOTM_STATE_FDT, "", ""), +#endif + U_BOOT_CMD_MKENT(bdt, 0, 1, (void *)BOOTM_STATE_OS_BD_T, "", ""), + U_BOOT_CMD_MKENT(cmdline, 0, 1, (void *)BOOTM_STATE_OS_CMDLINE, "", ""), + U_BOOT_CMD_MKENT(prep, 0, 1, (void *)BOOTM_STATE_OS_PREP, "", ""), + U_BOOT_CMD_MKENT(go, 0, 1, (void *)BOOTM_STATE_OS_GO, "", ""), +}; + +int do_bootm_subcommand (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]) +{ + int ret = 0; + int state; + cmd_tbl_t *c; + boot_os_fn *boot_fn; + + c = find_cmd_tbl(argv[1], &cmd_bootm_sub[0], ARRAY_SIZE(cmd_bootm_sub)); + + if (c) { + state = (int)c->cmd; + + /* treat start special since it resets the state machine */ + if (state == BOOTM_STATE_START) { + argc--; + argv++; + return bootm_start(cmdtp, flag, argc, argv); + } + } + /* Unrecognized command */ + else { + cmd_usage(cmdtp); + return 1; + } + + if (images.state >= state) { + printf ("Trying to execute a command out of order\n"); + cmd_usage(cmdtp); + return 1; + } + + images.state |= state; + boot_fn = boot_os[images.os.os]; + + switch (state) { + ulong load_end; + case BOOTM_STATE_START: + /* should never occur */ + break; + case BOOTM_STATE_LOADOS: + ret = bootm_load_os(images.os, &load_end, 0); + if (ret) + return ret; + + lmb_reserve(&images.lmb, images.os.load, + (load_end - images.os.load)); + break; +#if defined(CONFIG_PPC) || defined(CONFIG_M68K) || defined(CONFIG_SPARC) + case BOOTM_STATE_RAMDISK: + { + ulong rd_len = images.rd_end - images.rd_start; + char str[17]; + + ret = boot_ramdisk_high(&images.lmb, images.rd_start, + rd_len, &images.initrd_start, &images.initrd_end); + if (ret) + return ret; + + sprintf(str, "%lx", images.initrd_start); + setenv("initrd_start", str); + sprintf(str, "%lx", images.initrd_end); + setenv("initrd_end", str); + } + break; +#endif +#ifdef CONFIG_OF_LIBFDT + case BOOTM_STATE_FDT: + { + ulong bootmap_base = getenv_bootm_low(); + ret = boot_relocate_fdt(&images.lmb, bootmap_base, + &images.ft_addr, &images.ft_len); + break; + } +#endif + case BOOTM_STATE_OS_CMDLINE: + ret = boot_fn(BOOTM_STATE_OS_CMDLINE, argc, argv, &images); + if (ret) + printf ("cmdline subcommand not supported\n"); + break; + case BOOTM_STATE_OS_BD_T: + ret = boot_fn(BOOTM_STATE_OS_BD_T, argc, argv, &images); + if (ret) + printf ("bdt subcommand not supported\n"); + break; + case BOOTM_STATE_OS_PREP: + ret = boot_fn(BOOTM_STATE_OS_PREP, argc, argv, &images); + if (ret) + printf ("prep subcommand not supported\n"); + break; + case BOOTM_STATE_OS_GO: + disable_interrupts(); + arch_preboot_os(); + boot_fn(BOOTM_STATE_OS_GO, argc, argv, &images); + break; + } + + return ret; +} + +/*******************************************************************/ +/* bootm - boot application image from image in memory */ +/*******************************************************************/ +static int relocated = 0; + +int do_bootm (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]) +{ + ulong iflag; + ulong load_end = 0; + int ret; + boot_os_fn *boot_fn; + + /* relocate boot function table */ + if (!relocated) { + int i; + for (i = 0; i < ARRAY_SIZE(boot_os); i++) + if (boot_os[i] != NULL) + boot_os[i] += gd->reloc_off; + relocated = 1; + } + + /* determine if we have a sub command */ + if (argc > 1) { + char *endp; + + simple_strtoul(argv[1], &endp, 16); + /* endp pointing to NULL means that argv[1] was just a + * valid number, pass it along to the normal bootm processing + * + * If endp is ':' or '#' assume a FIT identifier so pass + * along for normal processing. + * + * Right now we assume the first arg should never be '-' */ - if (((s = getenv("autostart")) != NULL) && (strcmp(s,"no") == 0)) { - char buf[32]; - sprintf(buf, "%lX", image_get_data_size(hdr)); - setenv("filesize", buf); - return 0; + if ((*endp != 0) && (*endp != ':') && (*endp != '#')) + return do_bootm_subcommand(cmdtp, flag, argc, argv); + } + + if (bootm_start(cmdtp, flag, argc, argv)) + return 1; + + /* + * We have reached the point of no return: we are going to + * overwrite all exception vector code, so we cannot easily + * recover from any failures any more... + */ + iflag = disable_interrupts(); + +#if defined(CONFIG_CMD_USB) + /* + * turn off USB to prevent the host controller from writing to the + * SDRAM while Linux is booting. This could happen (at least for OHCI + * controller), because the HCCA (Host Controller Communication Area) + * lies within the SDRAM and the host controller writes continously to + * this area (as busmaster!). The HccaFrameNumber is for example + * updated every 1 ms within the HCCA structure in SDRAM! For more + * details see the OpenHCI specification. + */ + usb_stop(); +#endif + +#ifdef CONFIG_AMIGAONEG3SE + /* + * We've possible left the caches enabled during + * bios emulation, so turn them off again + */ + icache_disable(); + dcache_disable(); +#endif + + ret = bootm_load_os(images.os, &load_end, 1); + + if (ret < 0) { + if (ret == BOOTM_ERR_RESET) + do_reset (cmdtp, flag, argc, argv); + if (ret == BOOTM_ERR_OVERLAP) { + if (images.legacy_hdr_valid) { + if (image_get_type (&images.legacy_hdr_os_copy) == IH_TYPE_MULTI) + puts ("WARNING: legacy format multi component " + "image overwritten\n"); + } else { + puts ("ERROR: new format image overwritten - " + "must RESET the board to recover\n"); + show_boot_progress (-113); + do_reset (cmdtp, flag, argc, argv); + } } - appl = (int (*)(int, char *[]))image_get_ep (hdr); - (*appl)(argc-1, &argv[1]); - return 0; - case IH_TYPE_KERNEL: - case IH_TYPE_MULTI: - /* handled below */ - break; - default: + if (ret == BOOTM_ERR_UNIMPLEMENTED) { + if (iflag) + enable_interrupts(); + show_boot_progress (-7); + return 1; + } + } + + lmb_reserve(&images.lmb, images.os.load, (load_end - images.os.load)); + + if (images.os.type == IH_TYPE_STANDALONE) { if (iflag) enable_interrupts(); - printf ("Can't boot image type %d\n", image_get_type (hdr)); - show_boot_progress (-8); - return 1; + /* This may return when 'autostart' is 'no' */ + bootm_start_standalone(iflag, argc, argv); + return 0; } + show_boot_progress (8); - switch (image_get_os (hdr)) { - default: /* handled by (original) Linux case */ - case IH_OS_LINUX: #ifdef CONFIG_SILENT_CONSOLE - fixup_silent_linux(); + if (images.os.os == IH_OS_LINUX) + fixup_silent_linux(); #endif - do_bootm_linux (cmdtp, flag, argc, argv, hdr, verify); - break; - case IH_OS_NETBSD: - do_bootm_netbsd (cmdtp, flag, argc, argv, hdr, verify); - break; + boot_fn = boot_os[images.os.os]; -#ifdef CONFIG_LYNXKDI - case IH_OS_LYNXOS: - do_bootm_lynxkdi (cmdtp, flag, argc, argv, hdr, verify); - break; + if (boot_fn == NULL) { + if (iflag) + enable_interrupts(); + printf ("ERROR: booting os '%s' (%d) is not supported\n", + genimg_get_os_name(images.os.os), images.os.os); + show_boot_progress (-8); + return 1; + } + + arch_preboot_os(); + + boot_fn(0, argc, argv, &images); + + show_boot_progress (-9); +#ifdef DEBUG + puts ("\n## Control returned to monitor - resetting...\n"); #endif + do_reset (cmdtp, flag, argc, argv); - case IH_OS_RTEMS: - do_bootm_rtems (cmdtp, flag, argc, argv, hdr, verify); - break; + return 1; +} -#if defined(CONFIG_CMD_ELF) - case IH_OS_VXWORKS: - do_bootm_vxworks (cmdtp, flag, argc, argv, hdr, verify); - break; +/** + * image_get_kernel - verify legacy format kernel image + * @img_addr: in RAM address of the legacy format image to be verified + * @verify: data CRC verification flag + * + * image_get_kernel() verifies legacy image integrity and returns pointer to + * legacy image header if image verification was completed successfully. + * + * returns: + * pointer to a legacy image header if valid image was found + * otherwise return NULL + */ +static image_header_t *image_get_kernel (ulong img_addr, int verify) +{ + image_header_t *hdr = (image_header_t *)img_addr; + + if (!image_check_magic(hdr)) { + puts ("Bad Magic Number\n"); + show_boot_progress (-1); + return NULL; + } + show_boot_progress (2); + + if (!image_check_hcrc (hdr)) { + puts ("Bad Header Checksum\n"); + show_boot_progress (-2); + return NULL; + } + + show_boot_progress (3); + image_print_contents (hdr); + + if (verify) { + puts (" Verifying Checksum ... "); + if (!image_check_dcrc (hdr)) { + printf ("Bad Data CRC\n"); + show_boot_progress (-3); + return NULL; + } + puts ("OK\n"); + } + show_boot_progress (4); + + if (!image_check_target_arch (hdr)) { + printf ("Unsupported Architecture 0x%x\n", image_get_arch (hdr)); + show_boot_progress (-4); + return NULL; + } + return hdr; +} + +/** + * fit_check_kernel - verify FIT format kernel subimage + * @fit_hdr: pointer to the FIT image header + * os_noffset: kernel subimage node offset within FIT image + * @verify: data CRC verification flag + * + * fit_check_kernel() verifies integrity of the kernel subimage and from + * specified FIT image. + * + * returns: + * 1, on success + * 0, on failure + */ +#if defined (CONFIG_FIT) +static int fit_check_kernel (const void *fit, int os_noffset, int verify) +{ + fit_image_print (fit, os_noffset, " "); + + if (verify) { + puts (" Verifying Hash Integrity ... "); + if (!fit_image_check_hashes (fit, os_noffset)) { + puts ("Bad Data Hash\n"); + show_boot_progress (-104); + return 0; + } + puts ("OK\n"); + } + show_boot_progress (105); - case IH_OS_QNX: - do_bootm_qnxelf (cmdtp, flag, argc, argv, hdr, verify); - break; + if (!fit_image_check_target_arch (fit, os_noffset)) { + puts ("Unsupported Architecture\n"); + show_boot_progress (-105); + return 0; + } + + show_boot_progress (106); + if (!fit_image_check_type (fit, os_noffset, IH_TYPE_KERNEL)) { + puts ("Not a kernel image\n"); + show_boot_progress (-106); + return 0; + } + + show_boot_progress (107); + return 1; +} +#endif /* CONFIG_FIT */ + +/** + * boot_get_kernel - find kernel image + * @os_data: pointer to a ulong variable, will hold os data start address + * @os_len: pointer to a ulong variable, will hold os data length + * + * boot_get_kernel() tries to find a kernel image, verifies its integrity + * and locates kernel data. + * + * returns: + * pointer to image header if valid image was found, plus kernel start + * address and length, otherwise NULL + */ +static void *boot_get_kernel (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[], + bootm_headers_t *images, ulong *os_data, ulong *os_len) +{ + image_header_t *hdr; + ulong img_addr; +#if defined(CONFIG_FIT) + void *fit_hdr; + const char *fit_uname_config = NULL; + const char *fit_uname_kernel = NULL; + const void *data; + size_t len; + int cfg_noffset; + int os_noffset; #endif -#ifdef CONFIG_ARTOS - case IH_OS_ARTOS: - do_bootm_artos (cmdtp, flag, argc, argv, hdr, verify); - break; + /* find out kernel image address */ + if (argc < 2) { + img_addr = load_addr; + debug ("* kernel: default image load address = 0x%08lx\n", + load_addr); +#if defined(CONFIG_FIT) + } else if (fit_parse_conf (argv[1], load_addr, &img_addr, + &fit_uname_config)) { + debug ("* kernel: config '%s' from image at 0x%08lx\n", + fit_uname_config, img_addr); + } else if (fit_parse_subimage (argv[1], load_addr, &img_addr, + &fit_uname_kernel)) { + debug ("* kernel: subimage '%s' from image at 0x%08lx\n", + fit_uname_kernel, img_addr); #endif + } else { + img_addr = simple_strtoul(argv[1], NULL, 16); + debug ("* kernel: cmdline image address = 0x%08lx\n", img_addr); } - show_boot_progress (-9); -#ifdef DEBUG - puts ("\n## Control returned to monitor - resetting...\n"); - do_reset (cmdtp, flag, argc, argv); + show_boot_progress (1); + + /* copy from dataflash if needed */ + img_addr = genimg_get_image (img_addr); + + /* check image type, for FIT images get FIT kernel node */ + *os_data = *os_len = 0; + switch (genimg_get_format ((void *)img_addr)) { + case IMAGE_FORMAT_LEGACY: + printf ("## Booting kernel from Legacy Image at %08lx ...\n", + img_addr); + hdr = image_get_kernel (img_addr, images->verify); + if (!hdr) + return NULL; + show_boot_progress (5); + + /* get os_data and os_len */ + switch (image_get_type (hdr)) { + case IH_TYPE_KERNEL: + *os_data = image_get_data (hdr); + *os_len = image_get_data_size (hdr); + break; + case IH_TYPE_MULTI: + image_multi_getimg (hdr, 0, os_data, os_len); + break; + case IH_TYPE_STANDALONE: + if (argc >2) { + hdr->ih_load = htonl(simple_strtoul(argv[2], NULL, 16)); + } + *os_data = image_get_data (hdr); + *os_len = image_get_data_size (hdr); + break; + default: + printf ("Wrong Image Type for %s command\n", cmdtp->name); + show_boot_progress (-5); + return NULL; + } + + /* + * copy image header to allow for image overwrites during kernel + * decompression. + */ + memmove (&images->legacy_hdr_os_copy, hdr, sizeof(image_header_t)); + + /* save pointer to image header */ + images->legacy_hdr_os = hdr; + + images->legacy_hdr_valid = 1; + show_boot_progress (6); + break; +#if defined(CONFIG_FIT) + case IMAGE_FORMAT_FIT: + fit_hdr = (void *)img_addr; + printf ("## Booting kernel from FIT Image at %08lx ...\n", + img_addr); + + if (!fit_check_format (fit_hdr)) { + puts ("Bad FIT kernel image format!\n"); + show_boot_progress (-100); + return NULL; + } + show_boot_progress (100); + + if (!fit_uname_kernel) { + /* + * no kernel image node unit name, try to get config + * node first. If config unit node name is NULL + * fit_conf_get_node() will try to find default config node + */ + show_boot_progress (101); + cfg_noffset = fit_conf_get_node (fit_hdr, fit_uname_config); + if (cfg_noffset < 0) { + show_boot_progress (-101); + return NULL; + } + /* save configuration uname provided in the first + * bootm argument + */ + images->fit_uname_cfg = fdt_get_name (fit_hdr, cfg_noffset, NULL); + printf (" Using '%s' configuration\n", images->fit_uname_cfg); + show_boot_progress (103); + + os_noffset = fit_conf_get_kernel_node (fit_hdr, cfg_noffset); + fit_uname_kernel = fit_get_name (fit_hdr, os_noffset, NULL); + } else { + /* get kernel component image node offset */ + show_boot_progress (102); + os_noffset = fit_image_get_node (fit_hdr, fit_uname_kernel); + } + if (os_noffset < 0) { + show_boot_progress (-103); + return NULL; + } + + printf (" Trying '%s' kernel subimage\n", fit_uname_kernel); + + show_boot_progress (104); + if (!fit_check_kernel (fit_hdr, os_noffset, images->verify)) + return NULL; + + /* get kernel image data address and length */ + if (fit_image_get_data (fit_hdr, os_noffset, &data, &len)) { + puts ("Could not find kernel subimage data!\n"); + show_boot_progress (-107); + return NULL; + } + show_boot_progress (108); + + *os_len = len; + *os_data = (ulong)data; + images->fit_hdr_os = fit_hdr; + images->fit_uname_os = fit_uname_kernel; + images->fit_noffset_os = os_noffset; + break; #endif - return 1; + default: + printf ("Wrong Image Format for %s command\n", cmdtp->name); + show_boot_progress (-108); + return NULL; + } + + debug (" kernel data at 0x%08lx, len = 0x%08lx (%ld)\n", + *os_data, *os_len, *os_len); + + return (void *)img_addr; } U_BOOT_CMD( - bootm, CFG_MAXARGS, 1, do_bootm, - "bootm - boot application image from memory\n", + bootm, CONFIG_SYS_MAXARGS, 1, do_bootm, + "boot application image from memory", "[addr [arg ...]]\n - boot application image stored in memory\n" "\tpassing arguments 'arg ...'; when booting a Linux kernel,\n" "\t'arg' can be the address of an initrd image\n" -#if defined(CONFIG_OF_FLAT_TREE) || defined(CONFIG_OF_LIBFDT) +#if defined(CONFIG_OF_LIBFDT) "\tWhen booting a Linux kernel which requires a flat device-tree\n" "\ta third argument is required which is the address of the\n" "\tdevice-tree blob. To boot that kernel without an initrd image,\n" "\tuse a '-' for the second argument. If you do not pass a third\n" "\ta bd_info struct will be passed instead\n" #endif +#if defined(CONFIG_FIT) + "\t\nFor the new multi component uImage format (FIT) addresses\n" + "\tmust be extened to include component or configuration unit name:\n" + "\taddr: - direct component image specification\n" + "\taddr# - configuration specification\n" + "\tUse iminfo command to get the list of existing component\n" + "\timages and configurations.\n" +#endif + "\nSub-commands to do part of the bootm sequence. The sub-commands " + "must be\n" + "issued in the order below (it's ok to not issue all sub-commands):\n" + "\tstart [addr [arg ...]]\n" + "\tloados - load OS image\n" +#if defined(CONFIG_PPC) || defined(CONFIG_M68K) || defined(CONFIG_SPARC) + "\tramdisk - relocate initrd, set env initrd_start/initrd_end\n" +#endif +#if defined(CONFIG_OF_LIBFDT) + "\tfdt - relocate flat device tree\n" +#endif + "\tbdt - OS specific bd_t processing\n" + "\tcmdline - OS specific command line processing/setup\n" + "\tprep - OS specific prep before relocation or go\n" + "\tgo - start OS" ); /*******************************************************************/ @@ -407,7 +1012,7 @@ int do_bootd (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]) { int rcode = 0; -#ifndef CFG_HUSH_PARSER +#ifndef CONFIG_SYS_HUSH_PARSER if (run_command (getenv ("bootcmd"), flag) < 0) rcode = 1; #else @@ -420,15 +1025,15 @@ int do_bootd (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]) U_BOOT_CMD( boot, 1, 1, do_bootd, - "boot - boot default, i.e., run 'bootcmd'\n", - NULL + "boot default, i.e., run 'bootcmd'", + "" ); /* keep old command name "bootd" for backward compatibility */ U_BOOT_CMD( bootd, 1, 1, do_bootd, - "bootd - boot default, i.e., run 'bootcmd'\n", - NULL + "boot default, i.e., run 'bootcmd'", + "" ); #endif @@ -458,38 +1063,65 @@ int do_iminfo (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]) static int image_info (ulong addr) { - image_header_t *hdr = (image_header_t *)addr; + void *hdr = (void *)addr; printf ("\n## Checking Image at %08lx ...\n", addr); - if (!image_check_magic (hdr)) { - puts (" Bad Magic Number\n"); - return 1; - } + switch (genimg_get_format (hdr)) { + case IMAGE_FORMAT_LEGACY: + puts (" Legacy image found\n"); + if (!image_check_magic (hdr)) { + puts (" Bad Magic Number\n"); + return 1; + } - if (!image_check_hcrc (hdr)) { - puts (" Bad Header Checksum\n"); - return 1; - } + if (!image_check_hcrc (hdr)) { + puts (" Bad Header Checksum\n"); + return 1; + } - print_image_hdr (hdr); + image_print_contents (hdr); - puts (" Verifying Checksum ... "); - if (!image_check_dcrc (hdr)) { - puts (" Bad Data CRC\n"); - return 1; + puts (" Verifying Checksum ... "); + if (!image_check_dcrc (hdr)) { + puts (" Bad Data CRC\n"); + return 1; + } + puts ("OK\n"); + return 0; +#if defined(CONFIG_FIT) + case IMAGE_FORMAT_FIT: + puts (" FIT image found\n"); + + if (!fit_check_format (hdr)) { + puts ("Bad FIT image format!\n"); + return 1; + } + + fit_print_contents (hdr); + + if (!fit_all_image_check_hashes (hdr)) { + puts ("Bad hash in FIT image!\n"); + return 1; + } + + return 0; +#endif + default: + puts ("Unknown image format!\n"); + break; } - puts ("OK\n"); - return 0; + + return 1; } U_BOOT_CMD( - iminfo, CFG_MAXARGS, 1, do_iminfo, - "iminfo - print header information for application image\n", + iminfo, CONFIG_SYS_MAXARGS, 1, do_iminfo, + "print header information for application image", "addr [addr ...]\n" " - print header information for application image starting at\n" " address 'addr' in memory; this includes verification of the\n" - " image contents (magic number, header and payload checksums)\n" + " image contents (magic number, header and payload checksums)" ); #endif @@ -502,32 +1134,47 @@ int do_imls (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]) { flash_info_t *info; int i, j; - image_header_t *hdr; + void *hdr; for (i = 0, info = &flash_info[0]; - i < CFG_MAX_FLASH_BANKS; ++i, ++info) { + i < CONFIG_SYS_MAX_FLASH_BANKS; ++i, ++info) { if (info->flash_id == FLASH_UNKNOWN) goto next_bank; for (j = 0; j < info->sector_count; ++j) { - hdr = (image_header_t *)info->start[j]; - - if (!hdr || !image_check_magic (hdr)) + hdr = (void *)info->start[j]; + if (!hdr) goto next_sector; - if (!image_check_hcrc (hdr)) + switch (genimg_get_format (hdr)) { + case IMAGE_FORMAT_LEGACY: + if (!image_check_hcrc (hdr)) + goto next_sector; + + printf ("Legacy Image at %08lX:\n", (ulong)hdr); + image_print_contents (hdr); + + puts (" Verifying Checksum ... "); + if (!image_check_dcrc (hdr)) { + puts ("Bad Data CRC\n"); + } else { + puts ("OK\n"); + } + break; +#if defined(CONFIG_FIT) + case IMAGE_FORMAT_FIT: + if (!fit_check_format (hdr)) + goto next_sector; + + printf ("FIT Image at %08lX:\n", (ulong)hdr); + fit_print_contents (hdr); + break; +#endif + default: goto next_sector; - - printf ("Image at %08lX:\n", (ulong)hdr); - print_image_hdr (hdr); - - puts (" Verifying Checksum ... "); - if (!image_check_dcrc (hdr)) { - puts ("Bad Data CRC\n"); - } else { - puts ("OK\n"); } + next_sector: ; } next_bank: ; @@ -538,119 +1185,16 @@ next_bank: ; U_BOOT_CMD( imls, 1, 1, do_imls, - "imls - list all images found in flash\n", + "list all images found in flash", "\n" " - Prints information about all images found at sector\n" - " boundaries in flash.\n" + " boundaries in flash." ); #endif /*******************************************************************/ -/* */ +/* helper routines */ /*******************************************************************/ -void print_image_hdr (image_header_t *hdr) -{ -#if defined(CONFIG_TIMESTAMP) || defined(CONFIG_CMD_DATE) - time_t timestamp = (time_t)image_get_time (hdr); - struct rtc_time tm; -#endif - - printf (" Image Name: %.*s\n", IH_NMLEN, image_get_name (hdr)); - -#if defined(CONFIG_TIMESTAMP) || defined(CONFIG_CMD_DATE) - to_tm (timestamp, &tm); - printf (" Created: %4d-%02d-%02d %2d:%02d:%02d UTC\n", - tm.tm_year, tm.tm_mon, tm.tm_mday, - tm.tm_hour, tm.tm_min, tm.tm_sec); -#endif - puts (" Image Type: "); - print_type (hdr); - - printf ("\n Data Size: %d Bytes = ", image_get_data_size (hdr)); - print_size (image_get_data_size (hdr), "\n"); - printf (" Load Address: %08x\n" - " Entry Point: %08x\n", - image_get_load (hdr), image_get_ep (hdr)); - - if (image_check_type (hdr, IH_TYPE_MULTI)) { - int i; - ulong data, len; - ulong count = image_multi_count (hdr); - - puts (" Contents:\n"); - for (i = 0; i < count; i++) { - image_multi_getimg (hdr, i, &data, &len); - printf (" Image %d: %8ld Bytes = ", i, len); - print_size (len, "\n"); - } - } -} - -static void print_type (image_header_t *hdr) -{ - char *os, *arch, *type, *comp; - - switch (image_get_os (hdr)) { - case IH_OS_INVALID: os = "Invalid OS"; break; - case IH_OS_NETBSD: os = "NetBSD"; break; - case IH_OS_LINUX: os = "Linux"; break; - case IH_OS_VXWORKS: os = "VxWorks"; break; - case IH_OS_QNX: os = "QNX"; break; - case IH_OS_U_BOOT: os = "U-Boot"; break; - case IH_OS_RTEMS: os = "RTEMS"; break; -#ifdef CONFIG_ARTOS - case IH_OS_ARTOS: os = "ARTOS"; break; -#endif -#ifdef CONFIG_LYNXKDI - case IH_OS_LYNXOS: os = "LynxOS"; break; -#endif - default: os = "Unknown OS"; break; - } - - switch (image_get_arch (hdr)) { - case IH_ARCH_INVALID: arch = "Invalid CPU"; break; - case IH_ARCH_ALPHA: arch = "Alpha"; break; - case IH_ARCH_ARM: arch = "ARM"; break; - case IH_ARCH_AVR32: arch = "AVR32"; break; - case IH_ARCH_BLACKFIN: arch = "Blackfin"; break; - case IH_ARCH_I386: arch = "Intel x86"; break; - case IH_ARCH_IA64: arch = "IA64"; break; - case IH_ARCH_M68K: arch = "M68K"; break; - case IH_ARCH_MICROBLAZE:arch = "Microblaze"; break; - case IH_ARCH_MIPS64: arch = "MIPS 64 Bit"; break; - case IH_ARCH_MIPS: arch = "MIPS"; break; - case IH_ARCH_NIOS2: arch = "Nios-II"; break; - case IH_ARCH_NIOS: arch = "Nios"; break; - case IH_ARCH_PPC: arch = "PowerPC"; break; - case IH_ARCH_S390: arch = "IBM S390"; break; - case IH_ARCH_SH: arch = "SuperH"; break; - case IH_ARCH_SPARC64: arch = "SPARC 64 Bit"; break; - case IH_ARCH_SPARC: arch = "SPARC"; break; - default: arch = "Unknown Architecture"; break; - } - - switch (image_get_type (hdr)) { - case IH_TYPE_INVALID: type = "Invalid Image"; break; - case IH_TYPE_STANDALONE:type = "Standalone Program"; break; - case IH_TYPE_KERNEL: type = "Kernel Image"; break; - case IH_TYPE_RAMDISK: type = "RAMDisk Image"; break; - case IH_TYPE_MULTI: type = "Multi-File Image"; break; - case IH_TYPE_FIRMWARE: type = "Firmware"; break; - case IH_TYPE_SCRIPT: type = "Script"; break; - case IH_TYPE_FLATDT: type = "Flat Device Tree"; break; - default: type = "Unknown Image"; break; - } - - switch (image_get_comp (hdr)) { - case IH_COMP_NONE: comp = "uncompressed"; break; - case IH_COMP_GZIP: comp = "gzip compressed"; break; - case IH_COMP_BZIP2: comp = "bzip2 compressed"; break; - default: comp = "unknown compression"; break; - } - - printf ("%s %s %s (%s)", arch, os, type, comp); -} - #ifdef CONFIG_SILENT_CONSOLE static void fixup_silent_linux () { @@ -688,16 +1232,27 @@ static void fixup_silent_linux () /* OS booting routines */ /*******************************************************************/ -static void do_bootm_netbsd (cmd_tbl_t *cmdtp, int flag, - int argc, char *argv[], - image_header_t *hdr, int verify) +#ifdef CONFIG_BOOTM_NETBSD +static int do_bootm_netbsd (int flag, int argc, char *argv[], + bootm_headers_t *images) { void (*loader)(bd_t *, image_header_t *, char *, char *); - image_header_t *img_addr; + image_header_t *os_hdr, *hdr; ulong kernel_data, kernel_len; char *consdev; char *cmdline; + if ((flag != 0) && (flag != BOOTM_STATE_OS_GO)) + return 1; + +#if defined(CONFIG_FIT) + if (!images->legacy_hdr_valid) { + fit_unsupported_reset ("NetBSD"); + return 1; + } +#endif + hdr = images->legacy_hdr_os; + /* * Booting a (NetBSD) kernel image * @@ -709,12 +1264,11 @@ static void do_bootm_netbsd (cmd_tbl_t *cmdtp, int flag, * line, the name of the console device, and (optionally) the * address of the original image header. */ - - img_addr = 0; - if (image_check_type (hdr, IH_TYPE_MULTI)) { + os_hdr = NULL; + if (image_check_type (&images->legacy_hdr_os_copy, IH_TYPE_MULTI)) { image_multi_getimg (hdr, 1, &kernel_data, &kernel_len); if (kernel_len) - img_addr = hdr; + os_hdr = hdr; } consdev = ""; @@ -746,7 +1300,7 @@ static void do_bootm_netbsd (cmd_tbl_t *cmdtp, int flag, cmdline = ""; } - loader = (void (*)(bd_t *, image_header_t *, char *, char *))image_get_ep (hdr); + loader = (void (*)(bd_t *, image_header_t *, char *, char *))images->ep; printf ("## Transferring control to NetBSD stage-2 loader (at address %08lx) ...\n", (ulong)loader); @@ -760,25 +1314,51 @@ static void do_bootm_netbsd (cmd_tbl_t *cmdtp, int flag, * r5: console device * r6: boot args string */ - (*loader) (gd->bd, img_addr, consdev, cmdline); + (*loader) (gd->bd, os_hdr, consdev, cmdline); + + return 1; } +#endif /* CONFIG_BOOTM_NETBSD*/ #ifdef CONFIG_LYNXKDI -static void do_bootm_lynxkdi (cmd_tbl_t *cmdtp, int flag, - int argc, char *argv[], - image_header_t *hdr, int verify) +static int do_bootm_lynxkdi (int flag, int argc, char *argv[], + bootm_headers_t *images) { - lynxkdi_boot (hdr); + image_header_t *hdr = &images->legacy_hdr_os_copy; + + if ((flag != 0) && (flag != BOOTM_STATE_OS_GO)) + return 1; + +#if defined(CONFIG_FIT) + if (!images->legacy_hdr_valid) { + fit_unsupported_reset ("Lynx"); + return 1; + } +#endif + + lynxkdi_boot ((image_header_t *)hdr); + + return 1; } #endif /* CONFIG_LYNXKDI */ -static void do_bootm_rtems (cmd_tbl_t *cmdtp, int flag, - int argc, char *argv[], - image_header_t *hdr, int verify) +#ifdef CONFIG_BOOTM_RTEMS +static int do_bootm_rtems (int flag, int argc, char *argv[], + bootm_headers_t *images) { void (*entry_point)(bd_t *); - entry_point = (void (*)(bd_t *))image_get_ep (hdr); + if ((flag != 0) && (flag != BOOTM_STATE_OS_GO)) + return 1; + +#if defined(CONFIG_FIT) + if (!images->legacy_hdr_valid) { + fit_unsupported_reset ("RTEMS"); + return 1; + } +#endif + + entry_point = (void (*)(bd_t *))images->ep; printf ("## Transferring control to RTEMS (at address %08lx) ...\n", (ulong)entry_point); @@ -790,113 +1370,88 @@ static void do_bootm_rtems (cmd_tbl_t *cmdtp, int flag, * r3: ptr to board info data */ (*entry_point)(gd->bd); + + return 1; } +#endif /* CONFIG_BOOTM_RTEMS */ #if defined(CONFIG_CMD_ELF) -static void do_bootm_vxworks (cmd_tbl_t *cmdtp, int flag, - int argc, char *argv[], - image_header_t *hdr, int verify) +static int do_bootm_vxworks (int flag, int argc, char *argv[], + bootm_headers_t *images) { char str[80]; - sprintf(str, "%x", image_get_ep (hdr)); /* write entry-point into string */ + if ((flag != 0) && (flag != BOOTM_STATE_OS_GO)) + return 1; + +#if defined(CONFIG_FIT) + if (!images->legacy_hdr_valid) { + fit_unsupported_reset ("VxWorks"); + return 1; + } +#endif + + sprintf(str, "%lx", images->ep); /* write entry-point into string */ setenv("loadaddr", str); - do_bootvx(cmdtp, 0, 0, NULL); + do_bootvx(NULL, 0, 0, NULL); + + return 1; } -static void do_bootm_qnxelf(cmd_tbl_t *cmdtp, int flag, - int argc, char *argv[], - image_header_t *hdr, int verify) +static int do_bootm_qnxelf(int flag, int argc, char *argv[], + bootm_headers_t *images) { char *local_args[2]; char str[16]; - sprintf(str, "%x", image_get_ep (hdr)); /* write entry-point into string */ + if ((flag != 0) && (flag != BOOTM_STATE_OS_GO)) + return 1; + +#if defined(CONFIG_FIT) + if (!images->legacy_hdr_valid) { + fit_unsupported_reset ("QNX"); + return 1; + } +#endif + + sprintf(str, "%lx", images->ep); /* write entry-point into string */ local_args[0] = argv[0]; local_args[1] = str; /* and provide it via the arguments */ - do_bootelf(cmdtp, 0, 2, local_args); + do_bootelf(NULL, 0, 2, local_args); + + return 1; } #endif -#if defined(CONFIG_ARTOS) && defined(CONFIG_PPC) -static void do_bootm_artos (cmd_tbl_t *cmdtp, int flag, - int argc, char *argv[], - image_header_t *hdr, int verify) +#ifdef CONFIG_INTEGRITY +static int do_bootm_integrity (int flag, int argc, char *argv[], + bootm_headers_t *images) { - ulong top; - char *s, *cmdline; - char **fwenv, **ss; - int i, j, nxt, len, envno, envsz; - bd_t *kbd; - void (*entry)(bd_t *bd, char *cmdline, char **fwenv, ulong top); + void (*entry_point)(void); + + if ((flag != 0) && (flag != BOOTM_STATE_OS_GO)) + return 1; + +#if defined(CONFIG_FIT) + if (!images->legacy_hdr_valid) { + fit_unsupported_reset ("INTEGRITY"); + return 1; + } +#endif + + entry_point = (void (*)(void))images->ep; + + printf ("## Transferring control to INTEGRITY (at address %08lx) ...\n", + (ulong)entry_point); + + show_boot_progress (15); /* - * Booting an ARTOS kernel image + application + * INTEGRITY Parameters: + * None */ + (*entry_point)(); - /* this used to be the top of memory, but was wrong... */ -#ifdef CONFIG_PPC - /* get stack pointer */ - asm volatile ("mr %0,1" : "=r"(top) ); -#endif - debug ("## Current stack ends at 0x%08lX ", top); - - top -= 2048; /* just to be sure */ - if (top > CFG_BOOTMAPSZ) - top = CFG_BOOTMAPSZ; - top &= ~0xF; - - debug ("=> set upper limit to 0x%08lX\n", top); - - /* first check the artos specific boot args, then the linux args*/ - if ((s = getenv( "abootargs")) == NULL && (s = getenv ("bootargs")) == NULL) - s = ""; - - /* get length of cmdline, and place it */ - len = strlen (s); - top = (top - (len + 1)) & ~0xF; - cmdline = (char *)top; - debug ("## cmdline at 0x%08lX ", top); - strcpy (cmdline, s); - - /* copy bdinfo */ - top = (top - sizeof (bd_t)) & ~0xF; - debug ("## bd at 0x%08lX ", top); - kbd = (bd_t *)top; - memcpy (kbd, gd->bd, sizeof (bd_t)); - - /* first find number of env entries, and their size */ - envno = 0; - envsz = 0; - for (i = 0; env_get_char (i) != '\0'; i = nxt + 1) { - for (nxt = i; env_get_char (nxt) != '\0'; ++nxt) - ; - envno++; - envsz += (nxt - i) + 1; /* plus trailing zero */ - } - envno++; /* plus the terminating zero */ - debug ("## %u envvars total size %u ", envno, envsz); - - top = (top - sizeof (char **) * envno) & ~0xF; - fwenv = (char **)top; - debug ("## fwenv at 0x%08lX ", top); - - top = (top - envsz) & ~0xF; - s = (char *)top; - ss = fwenv; - - /* now copy them */ - for (i = 0; env_get_char (i) != '\0'; i = nxt + 1) { - for (nxt = i; env_get_char (nxt) != '\0'; ++nxt) - ; - *ss++ = s; - for (j = i; j < nxt; ++j) - *s++ = env_get_char (j); - *s++ = '\0'; - } - *ss++ = NULL; /* terminate */ - - entry = (void (*)(bd_t *, char *, char **, ulong))image_get_ep (hdr); - (*entry) (kbd, cmdline, fwenv, top); + return 1; } #endif