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