Eric Lee / smarc-uboot

Download as
Browse Code ยป

Commit e2ce81696a6aeea65e86d7677d270e589a7d4d81

Authored by Kees Jongenburger
Committed by Tom Rini
1 parent ba931259b1
Exists in master and in 50 other branches 8qm-imx_v2020.04_5.4.70_2.3.0, emb_lf_v2022.04, imx_v2015.04_4.1.15_1.0.0_ga, pitx_8mp_lf_v2020.04, smarc-8m-android-10.0.0_2.6.0, smarc-8m-android-11.0.0_2.0.0, smarc-8mp-android-11.0.0_2.0.0, smarc-emmc-imx_v2014.04_3.10.53_1.1.0_ga, smarc-emmc-imx_v2014.04_3.14.28_1.0.0_ga, smarc-imx-l5.0.0_1.0.0-ga, smarc-imx6_v2018.03_4.14.98_2.0.0_ga, smarc-imx7_v2017.03_4.9.11_1.0.0_ga, smarc-imx7_v2018.03_4.14.98_2.0.0_ga, smarc-imx_v2014.04_3.14.28_1.0.0_ga, smarc-imx_v2015.04_4.1.15_1.0.0_ga, smarc-imx_v2017.03_4.9.11_1.0.0_ga, smarc-imx_v2017.03_4.9.88_2.0.0_ga, smarc-imx_v2017.03_o8.1.0_1.3.0_8m, smarc-imx_v2018.03_4.14.78_1.0.0_ga, smarc-m6.0.1_2.1.0-ga, smarc-n7.1.2_2.0.0-ga, smarc-rel_imx_4.1.15_2.0.0_ga, smarc_8m-imx_v2018.03_4.14.98_2.0.0_ga, smarc_8m-imx_v2019.04_4.19.35_1.1.0, smarc_8m_00d0-imx_v2018.03_4.14.98_2.0.0_ga, smarc_8mm-imx_v2018.03_4.14.98_2.0.0_ga, smarc_8mm-imx_v2019.04_4.19.35_1.1.0, smarc_8mm-imx_v2020.04_5.4.24_2.1.0, smarc_8mp_lf_v2020.04, smarc_8mq-imx_v2020.04_5.4.24_2.1.0, smarc_8mq_lf_v2020.04, ti-u-boot-2015.07, v2014.01, v2014.04, v2014.04-smarct33, v2014.04-smarct33-emmc, v2014.04-smartmen, v2014.07, v2014.07-smarct33, v2014.07-smartmen, v2015.07-smarct33, v2015.07-smarct33-emmc, v2015.07-smarct4x, v2016.05-dlt, v2016.05-smarct3x, v2016.05-smarct3x-emmc, v2016.05-smarct4x, v2017.01-smarct3x, v2017.01-smarct3x-emmc, v2017.01-smarct4x

netbsd:fix documentation typo. 

The documentation suggested the arguments where passed over r3-r6
while the code below simply does that over r0-r3.

Cc: Kumar Gala <galak@kernel.crashing.org>

Showing 1 changed file with 4 additions and 4 deletions Inline Diff

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