blob: 75f0b4a9af8a04bf6c2268cc4f6bf32b75478cbd [file] [log] [blame]
Tom Rini83d290c2018-05-06 17:58:06 -04001// SPDX-License-Identifier: GPL-2.0+
Simon Glassb6396402014-06-12 07:24:46 -06002/*
3 * (C) Copyright 2000-2009
4 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
Simon Glassb6396402014-06-12 07:24:46 -06005 */
6
Simon Glassea51a622014-06-12 07:24:51 -06007#ifndef USE_HOSTCC
Simon Glassb6396402014-06-12 07:24:46 -06008#include <common.h>
Simon Glassea51a622014-06-12 07:24:51 -06009#include <bootstage.h>
Simon Glass51bb3382020-11-05 10:33:48 -070010#include <cli.h>
Simon Glass1eb69ae2019-11-14 12:57:39 -070011#include <cpu_func.h>
Simon Glassc7694dd2019-08-01 09:46:46 -060012#include <env.h>
Simon Glass90268b82014-10-19 21:11:24 -060013#include <errno.h>
Simon Glassb6396402014-06-12 07:24:46 -060014#include <fdt_support.h>
Simon Glass36bf4462019-11-14 12:57:42 -070015#include <irq_func.h>
Simon Glassb6396402014-06-12 07:24:46 -060016#include <lmb.h>
Simon Glassf7ae49f2020-05-10 11:40:05 -060017#include <log.h>
Simon Glassb6396402014-06-12 07:24:46 -060018#include <malloc.h>
Joe Hershberger0eb25b62015-03-22 17:08:59 -050019#include <mapmem.h>
Simon Glass90526e92020-05-10 11:39:56 -060020#include <net.h>
21#include <asm/cache.h>
Simon Glass401d1c42020-10-30 21:38:53 -060022#include <asm/global_data.h>
Simon Glassb6396402014-06-12 07:24:46 -060023#include <asm/io.h>
Simon Glassb6386f32020-11-05 10:33:43 -070024#include <linux/sizes.h>
Simon Glassb6396402014-06-12 07:24:46 -060025#if defined(CONFIG_CMD_USB)
26#include <usb.h>
27#endif
Simon Glassea51a622014-06-12 07:24:51 -060028#else
29#include "mkimage.h"
30#endif
Simon Glassb6396402014-06-12 07:24:46 -060031
Simon Glassea51a622014-06-12 07:24:51 -060032#include <command.h>
33#include <bootm.h>
34#include <image.h>
Simon Glassb6396402014-06-12 07:24:46 -060035
Simon Glassb6386f32020-11-05 10:33:43 -070036#define MAX_CMDLINE_SIZE SZ_4K
37
Simon Glassb6396402014-06-12 07:24:46 -060038#define IH_INITRD_ARCH IH_ARCH_DEFAULT
39
Simon Glassea51a622014-06-12 07:24:51 -060040#ifndef USE_HOSTCC
41
42DECLARE_GLOBAL_DATA_PTR;
43
Simon Glassd9d7c202022-09-06 20:26:50 -060044struct bootm_headers images; /* pointers to os/initrd/fdt images */
Tom Rini5db28902016-08-12 08:31:15 -040045
Simon Glass09140112020-05-10 11:40:03 -060046static const void *boot_get_kernel(struct cmd_tbl *cmdtp, int flag, int argc,
Simon Glassd9d7c202022-09-06 20:26:50 -060047 char *const argv[], struct bootm_headers *images,
Simon Glassb6396402014-06-12 07:24:46 -060048 ulong *os_data, ulong *os_len);
49
Simon Glass329da482018-05-16 09:42:25 -060050__weak void board_quiesce_devices(void)
51{
52}
53
Simon Glassb6396402014-06-12 07:24:46 -060054#ifdef CONFIG_LMB
Simon Glassd9d7c202022-09-06 20:26:50 -060055static void boot_start_lmb(struct bootm_headers *images)
Simon Glassb6396402014-06-12 07:24:46 -060056{
57 ulong mem_start;
58 phys_size_t mem_size;
59
Simon Glass723806c2017-08-03 12:22:15 -060060 mem_start = env_get_bootm_low();
61 mem_size = env_get_bootm_size();
Simon Glassb6396402014-06-12 07:24:46 -060062
Simon Goldschmidt9cc23232019-01-26 22:13:04 +010063 lmb_init_and_reserve_range(&images->lmb, (phys_addr_t)mem_start,
64 mem_size, NULL);
Simon Glassb6396402014-06-12 07:24:46 -060065}
66#else
67#define lmb_reserve(lmb, base, size)
Simon Glassd9d7c202022-09-06 20:26:50 -060068static inline void boot_start_lmb(struct bootm_headers *images) { }
Simon Glassb6396402014-06-12 07:24:46 -060069#endif
70
Simon Glass09140112020-05-10 11:40:03 -060071static int bootm_start(struct cmd_tbl *cmdtp, int flag, int argc,
72 char *const argv[])
Simon Glassb6396402014-06-12 07:24:46 -060073{
74 memset((void *)&images, 0, sizeof(images));
Simon Glassbfebc8c2017-08-03 12:22:13 -060075 images.verify = env_get_yesno("verify");
Simon Glassb6396402014-06-12 07:24:46 -060076
77 boot_start_lmb(&images);
78
79 bootstage_mark_name(BOOTSTAGE_ID_BOOTM_START, "bootm_start");
80 images.state = BOOTM_STATE_START;
81
82 return 0;
83}
84
Philippe Reynes9d46e632022-03-28 22:57:00 +020085static ulong bootm_data_addr(int argc, char *const argv[])
86{
87 ulong addr;
88
89 if (argc > 0)
90 addr = simple_strtoul(argv[0], NULL, 16);
91 else
92 addr = image_load_addr;
93
94 return addr;
95}
96
97static int bootm_pre_load(struct cmd_tbl *cmdtp, int flag, int argc,
98 char *const argv[])
99{
100 ulong data_addr = bootm_data_addr(argc, argv);
101 int ret = 0;
102
Simon Glass494bcf12023-02-05 15:36:24 -0700103 if (IS_ENABLED(CONFIG_CMD_BOOTM_PRE_LOAD))
Philippe Reynes9d46e632022-03-28 22:57:00 +0200104 ret = image_pre_load(data_addr);
105
106 if (ret)
107 ret = CMD_RET_FAILURE;
108
109 return ret;
110}
111
Simon Glass09140112020-05-10 11:40:03 -0600112static int bootm_find_os(struct cmd_tbl *cmdtp, int flag, int argc,
113 char *const argv[])
Simon Glassb6396402014-06-12 07:24:46 -0600114{
115 const void *os_hdr;
Safae Ouajih636da202023-02-06 00:50:17 +0100116#ifdef CONFIG_ANDROID_BOOT_IMAGE
117 const void *vendor_boot_img;
118 const void *boot_img;
119#endif
Simon Glassb6396402014-06-12 07:24:46 -0600120 bool ep_found = false;
Simon Glass90268b82014-10-19 21:11:24 -0600121 int ret;
Simon Glassb6396402014-06-12 07:24:46 -0600122
123 /* get kernel image header, start address and length */
124 os_hdr = boot_get_kernel(cmdtp, flag, argc, argv,
125 &images, &images.os.image_start, &images.os.image_len);
126 if (images.os.image_len == 0) {
127 puts("ERROR: can't get kernel image!\n");
128 return 1;
129 }
130
131 /* get image parameters */
132 switch (genimg_get_format(os_hdr)) {
Tom Rinic76c93a2019-05-23 07:14:07 -0400133#if CONFIG_IS_ENABLED(LEGACY_IMAGE_FORMAT)
Simon Glassb6396402014-06-12 07:24:46 -0600134 case IMAGE_FORMAT_LEGACY:
135 images.os.type = image_get_type(os_hdr);
136 images.os.comp = image_get_comp(os_hdr);
137 images.os.os = image_get_os(os_hdr);
138
139 images.os.end = image_get_image_end(os_hdr);
140 images.os.load = image_get_load(os_hdr);
Simon Glass90268b82014-10-19 21:11:24 -0600141 images.os.arch = image_get_arch(os_hdr);
Simon Glassb6396402014-06-12 07:24:46 -0600142 break;
143#endif
Simon Glassbf371b42021-09-25 19:43:20 -0600144#if CONFIG_IS_ENABLED(FIT)
Simon Glassb6396402014-06-12 07:24:46 -0600145 case IMAGE_FORMAT_FIT:
146 if (fit_image_get_type(images.fit_hdr_os,
147 images.fit_noffset_os,
148 &images.os.type)) {
149 puts("Can't get image type!\n");
150 bootstage_error(BOOTSTAGE_ID_FIT_TYPE);
151 return 1;
152 }
153
154 if (fit_image_get_comp(images.fit_hdr_os,
155 images.fit_noffset_os,
156 &images.os.comp)) {
157 puts("Can't get image compression!\n");
158 bootstage_error(BOOTSTAGE_ID_FIT_COMPRESSION);
159 return 1;
160 }
161
162 if (fit_image_get_os(images.fit_hdr_os, images.fit_noffset_os,
163 &images.os.os)) {
164 puts("Can't get image OS!\n");
165 bootstage_error(BOOTSTAGE_ID_FIT_OS);
166 return 1;
167 }
168
Simon Glass90268b82014-10-19 21:11:24 -0600169 if (fit_image_get_arch(images.fit_hdr_os,
170 images.fit_noffset_os,
171 &images.os.arch)) {
172 puts("Can't get image ARCH!\n");
173 return 1;
174 }
175
Simon Glassb6396402014-06-12 07:24:46 -0600176 images.os.end = fit_get_end(images.fit_hdr_os);
177
178 if (fit_image_get_load(images.fit_hdr_os, images.fit_noffset_os,
179 &images.os.load)) {
180 puts("Can't get image load address!\n");
181 bootstage_error(BOOTSTAGE_ID_FIT_LOADADDR);
182 return 1;
183 }
184 break;
185#endif
186#ifdef CONFIG_ANDROID_BOOT_IMAGE
187 case IMAGE_FORMAT_ANDROID:
Safae Ouajih636da202023-02-06 00:50:17 +0100188 boot_img = os_hdr;
189 vendor_boot_img = NULL;
190 if (IS_ENABLED(CONFIG_CMD_ABOOTIMG)) {
191 boot_img = map_sysmem(get_abootimg_addr(), 0);
192 vendor_boot_img = map_sysmem(get_avendor_bootimg_addr(), 0);
193 }
Simon Glassb6396402014-06-12 07:24:46 -0600194 images.os.type = IH_TYPE_KERNEL;
Safae Ouajih636da202023-02-06 00:50:17 +0100195 images.os.comp = android_image_get_kcomp(boot_img, vendor_boot_img);
Simon Glassb6396402014-06-12 07:24:46 -0600196 images.os.os = IH_OS_LINUX;
Safae Ouajih636da202023-02-06 00:50:17 +0100197 images.os.end = android_image_get_end(boot_img, vendor_boot_img);
198 images.os.load = android_image_get_kload(boot_img, vendor_boot_img);
Ahmad Draidi86f46952014-10-23 20:50:07 +0300199 images.ep = images.os.load;
200 ep_found = true;
Safae Ouajih636da202023-02-06 00:50:17 +0100201 if (IS_ENABLED(CONFIG_CMD_ABOOTIMG)) {
202 unmap_sysmem(vendor_boot_img);
203 unmap_sysmem(boot_img);
204 }
Simon Glassb6396402014-06-12 07:24:46 -0600205 break;
206#endif
207 default:
208 puts("ERROR: unknown image format type!\n");
209 return 1;
210 }
211
Simon Glass90268b82014-10-19 21:11:24 -0600212 /* If we have a valid setup.bin, we will use that for entry (x86) */
Simon Glass5bda35c2014-10-10 08:21:57 -0600213 if (images.os.arch == IH_ARCH_I386 ||
214 images.os.arch == IH_ARCH_X86_64) {
Simon Glass90268b82014-10-19 21:11:24 -0600215 ulong len;
216
217 ret = boot_get_setup(&images, IH_ARCH_I386, &images.ep, &len);
218 if (ret < 0 && ret != -ENOENT) {
219 puts("Could not find a valid setup.bin for x86\n");
220 return 1;
221 }
222 /* Kernel entry point is the setup.bin */
223 } else if (images.legacy_hdr_valid) {
Simon Glassb6396402014-06-12 07:24:46 -0600224 images.ep = image_get_ep(&images.legacy_hdr_os_copy);
Simon Glassbf371b42021-09-25 19:43:20 -0600225#if CONFIG_IS_ENABLED(FIT)
Simon Glassb6396402014-06-12 07:24:46 -0600226 } else if (images.fit_uname_os) {
227 int ret;
228
229 ret = fit_image_get_entry(images.fit_hdr_os,
230 images.fit_noffset_os, &images.ep);
231 if (ret) {
232 puts("Can't get entry point property!\n");
233 return 1;
234 }
235#endif
236 } else if (!ep_found) {
237 puts("Could not find kernel entry point!\n");
238 return 1;
239 }
240
241 if (images.os.type == IH_TYPE_KERNEL_NOLOAD) {
Simon Glassef65aa32023-02-05 15:36:23 -0700242 if (IS_ENABLED(CONFIG_CMD_BOOTI) &&
Heinrich Schuchardt4533b3d2023-06-13 08:18:27 +0200243 images.os.arch == IH_ARCH_ARM64 &&
244 images.os.os == IH_OS_LINUX) {
Marek Vasut487b5fa2018-06-13 06:13:33 +0200245 ulong image_addr;
246 ulong image_size;
247
248 ret = booti_setup(images.os.image_start, &image_addr,
249 &image_size, true);
250 if (ret != 0)
251 return 1;
252
253 images.os.type = IH_TYPE_KERNEL;
254 images.os.load = image_addr;
255 images.ep = image_addr;
256 } else {
257 images.os.load = images.os.image_start;
258 images.ep += images.os.image_start;
259 }
Simon Glassb6396402014-06-12 07:24:46 -0600260 }
261
Simon Glass7a80de42016-02-24 09:14:42 -0700262 images.os.start = map_to_sysmem(os_hdr);
Simon Glassb6396402014-06-12 07:24:46 -0600263
264 return 0;
265}
266
Karl Apsited52e8572015-05-21 09:52:49 -0400267/**
268 * bootm_find_images - wrapper to find and locate various images
269 * @flag: Ignored Argument
270 * @argc: command argument count
271 * @argv: command argument list
Tero Kristofbde7582020-06-12 15:41:20 +0300272 * @start: OS image start address
273 * @size: OS image size
Karl Apsited52e8572015-05-21 09:52:49 -0400274 *
275 * boot_find_images() will attempt to load an available ramdisk,
276 * flattened device tree, as well as specifically marked
277 * "loadable" images (loadables are FIT only)
278 *
279 * Note: bootm_find_images will skip an image if it is not found
280 *
281 * @return:
282 * 0, if all existing images were loaded correctly
283 * 1, if an image is found but corrupted, or invalid
284 */
Tero Kristofbde7582020-06-12 15:41:20 +0300285int bootm_find_images(int flag, int argc, char *const argv[], ulong start,
286 ulong size)
Simon Glassb6396402014-06-12 07:24:46 -0600287{
288 int ret;
289
290 /* find ramdisk */
291 ret = boot_get_ramdisk(argc, argv, &images, IH_INITRD_ARCH,
292 &images.rd_start, &images.rd_end);
293 if (ret) {
294 puts("Ramdisk image is corrupt or invalid\n");
295 return 1;
296 }
297
Tero Kristofbde7582020-06-12 15:41:20 +0300298 /* check if ramdisk overlaps OS image */
299 if (images.rd_start && (((ulong)images.rd_start >= start &&
Jaehoon Chungef4f4f12020-10-21 14:17:03 +0900300 (ulong)images.rd_start < start + size) ||
301 ((ulong)images.rd_end > start &&
302 (ulong)images.rd_end <= start + size) ||
303 ((ulong)images.rd_start < start &&
304 (ulong)images.rd_end >= start + size))) {
Tero Kristofbde7582020-06-12 15:41:20 +0300305 printf("ERROR: RD image overlaps OS image (OS=0x%lx..0x%lx)\n",
306 start, start + size);
307 return 1;
308 }
309
Simon Glass0c303f92021-09-25 19:43:21 -0600310#if CONFIG_IS_ENABLED(OF_LIBFDT)
Simon Glassb6396402014-06-12 07:24:46 -0600311 /* find flattened device tree */
312 ret = boot_get_fdt(flag, argc, argv, IH_ARCH_DEFAULT, &images,
313 &images.ft_addr, &images.ft_len);
314 if (ret) {
315 puts("Could not find a valid device tree\n");
316 return 1;
317 }
Tero Kristofbde7582020-06-12 15:41:20 +0300318
319 /* check if FDT overlaps OS image */
320 if (images.ft_addr &&
321 (((ulong)images.ft_addr >= start &&
Pali Rohár5acfdfb2022-08-27 14:48:10 +0200322 (ulong)images.ft_addr < start + size) ||
Tero Kristofbde7582020-06-12 15:41:20 +0300323 ((ulong)images.ft_addr + images.ft_len >= start &&
Pali Rohár5acfdfb2022-08-27 14:48:10 +0200324 (ulong)images.ft_addr + images.ft_len < start + size))) {
Tero Kristofbde7582020-06-12 15:41:20 +0300325 printf("ERROR: FDT image overlaps OS image (OS=0x%lx..0x%lx)\n",
326 start, start + size);
327 return 1;
328 }
329
Simon Glass3a09f382023-02-05 15:36:30 -0700330 if (IS_ENABLED(CONFIG_CMD_FDT))
Simon Goldschmidt596be5f2018-12-17 20:14:42 +0100331 set_working_fdt_addr(map_to_sysmem(images.ft_addr));
Simon Glassb6396402014-06-12 07:24:46 -0600332#endif
333
Simon Glassbf371b42021-09-25 19:43:20 -0600334#if CONFIG_IS_ENABLED(FIT)
Simon Glass4ed37ab2021-09-25 07:03:20 -0600335 if (IS_ENABLED(CONFIG_FPGA)) {
336 /* find bitstreams */
337 ret = boot_get_fpga(argc, argv, &images, IH_ARCH_DEFAULT,
338 NULL, NULL);
339 if (ret) {
340 printf("FPGA image is corrupted or invalid\n");
341 return 1;
342 }
Michal Simek62afc602016-05-17 14:03:50 +0200343 }
Michal Simek62afc602016-05-17 14:03:50 +0200344
Karl Apsite84a07db2015-05-21 09:52:48 -0400345 /* find all of the loadables */
346 ret = boot_get_loadable(argc, argv, &images, IH_ARCH_DEFAULT,
347 NULL, NULL);
348 if (ret) {
349 printf("Loadable(s) is corrupt or invalid\n");
350 return 1;
351 }
Karl Apsite84a07db2015-05-21 09:52:48 -0400352#endif
353
Simon Glassb6396402014-06-12 07:24:46 -0600354 return 0;
355}
356
Simon Glass09140112020-05-10 11:40:03 -0600357static int bootm_find_other(struct cmd_tbl *cmdtp, int flag, int argc,
358 char *const argv[])
Simon Glassb6396402014-06-12 07:24:46 -0600359{
360 if (((images.os.type == IH_TYPE_KERNEL) ||
361 (images.os.type == IH_TYPE_KERNEL_NOLOAD) ||
362 (images.os.type == IH_TYPE_MULTI)) &&
363 (images.os.os == IH_OS_LINUX ||
364 images.os.os == IH_OS_VXWORKS))
Tero Kristofbde7582020-06-12 15:41:20 +0300365 return bootm_find_images(flag, argc, argv, 0, 0);
Simon Glassb6396402014-06-12 07:24:46 -0600366
367 return 0;
368}
Simon Glass40e59752014-12-02 13:17:30 -0700369#endif /* USE_HOSTC */
370
Julius Werner20908542019-07-24 19:37:54 -0700371#if !defined(USE_HOSTCC) || defined(CONFIG_FIT_SIGNATURE)
Simon Glass3086c052014-12-02 13:17:37 -0700372/**
373 * handle_decomp_error() - display a decompression error
374 *
375 * This function tries to produce a useful message. In the case where the
376 * uncompressed size is the same as the available space, we can assume that
377 * the image is too large for the buffer.
378 *
379 * @comp_type: Compression type being used (IH_COMP_...)
380 * @uncomp_size: Number of bytes uncompressed
Tom Rinic45568c2022-06-25 19:29:46 -0400381 * @buf_size: Number of bytes the decompresion buffer was
Julius Werner20908542019-07-24 19:37:54 -0700382 * @ret: errno error code received from compression library
Heinrich Schuchardt185f8122022-01-19 18:05:50 +0100383 * Return: Appropriate BOOTM_ERR_ error code
Simon Glass3086c052014-12-02 13:17:37 -0700384 */
Tom Rinic45568c2022-06-25 19:29:46 -0400385static int handle_decomp_error(int comp_type, size_t uncomp_size,
386 size_t buf_size, int ret)
Simon Glass40e59752014-12-02 13:17:30 -0700387{
Simon Glass3086c052014-12-02 13:17:37 -0700388 const char *name = genimg_get_comp_name(comp_type);
389
Julius Werner20908542019-07-24 19:37:54 -0700390 /* ENOSYS means unimplemented compression type, don't reset. */
391 if (ret == -ENOSYS)
392 return BOOTM_ERR_UNIMPLEMENTED;
393
Tom Rinic45568c2022-06-25 19:29:46 -0400394 if (uncomp_size >= buf_size)
Simon Glass3086c052014-12-02 13:17:37 -0700395 printf("Image too large: increase CONFIG_SYS_BOOTM_LEN\n");
Simon Glass40e59752014-12-02 13:17:30 -0700396 else
Simon Glass3086c052014-12-02 13:17:37 -0700397 printf("%s: uncompress error %d\n", name, ret);
398
399 /*
400 * The decompression routines are now safe, so will not write beyond
401 * their bounds. Probably it is not necessary to reset, but maintain
402 * the current behaviour for now.
403 */
404 printf("Must RESET board to recover\n");
Simon Glass40e59752014-12-02 13:17:30 -0700405#ifndef USE_HOSTCC
406 bootstage_error(BOOTSTAGE_ID_DECOMP_IMAGE);
407#endif
408
409 return BOOTM_ERR_RESET;
410}
Julius Werner20908542019-07-24 19:37:54 -0700411#endif
Simon Glass2b164f12014-06-12 07:24:52 -0600412
Simon Glassce1400f2014-06-12 07:24:53 -0600413#ifndef USE_HOSTCC
Simon Glassd9d7c202022-09-06 20:26:50 -0600414static int bootm_load_os(struct bootm_headers *images, int boot_progress)
Simon Glass2b164f12014-06-12 07:24:52 -0600415{
Simon Glassda79b2f2022-09-06 20:26:51 -0600416 struct image_info os = images->os;
Simon Glass2b164f12014-06-12 07:24:52 -0600417 ulong load = os.load;
Tom Rinicc955352018-05-01 12:32:37 -0400418 ulong load_end;
Simon Glass2b164f12014-06-12 07:24:52 -0600419 ulong blob_start = os.start;
420 ulong blob_end = os.end;
421 ulong image_start = os.image_start;
422 ulong image_len = os.image_len;
Bryan O'Donoghuebbac9222018-04-15 11:48:17 +0100423 ulong flush_start = ALIGN_DOWN(load, ARCH_DMA_MINALIGN);
Simon Glass2b164f12014-06-12 07:24:52 -0600424 bool no_overlap;
425 void *load_buf, *image_buf;
426 int err;
427
428 load_buf = map_sysmem(load, 0);
429 image_buf = map_sysmem(os.image_start, image_len);
Julius Werner20908542019-07-24 19:37:54 -0700430 err = image_decomp(os.comp, load, os.image_start, os.type,
431 load_buf, image_buf, image_len,
432 CONFIG_SYS_BOOTM_LEN, &load_end);
Simon Glass2b164f12014-06-12 07:24:52 -0600433 if (err) {
Tom Rinic45568c2022-06-25 19:29:46 -0400434 err = handle_decomp_error(os.comp, load_end - load,
435 CONFIG_SYS_BOOTM_LEN, err);
Simon Glass2b164f12014-06-12 07:24:52 -0600436 bootstage_error(BOOTSTAGE_ID_DECOMP_IMAGE);
437 return err;
438 }
Heinrich Schuchardt21d39462020-08-30 11:34:12 +0200439 /* We need the decompressed image size in the next steps */
440 images->os.image_len = load_end - load;
Bryan O'Donoghuebbac9222018-04-15 11:48:17 +0100441
Trent Piephob4353b32019-03-27 23:50:09 +0000442 flush_cache(flush_start, ALIGN(load_end, ARCH_DMA_MINALIGN) - flush_start);
Simon Glassb6396402014-06-12 07:24:46 -0600443
Tom Rinicc955352018-05-01 12:32:37 -0400444 debug(" kernel loaded at 0x%08lx, end = 0x%08lx\n", load, load_end);
Simon Glassb6396402014-06-12 07:24:46 -0600445 bootstage_mark(BOOTSTAGE_ID_KERNEL_LOADED);
446
Simon Glass2b164f12014-06-12 07:24:52 -0600447 no_overlap = (os.comp == IH_COMP_NONE && load == image_start);
448
Tom Rinicc955352018-05-01 12:32:37 -0400449 if (!no_overlap && load < blob_end && load_end > blob_start) {
Simon Glassb6396402014-06-12 07:24:46 -0600450 debug("images.os.start = 0x%lX, images.os.end = 0x%lx\n",
451 blob_start, blob_end);
452 debug("images.os.load = 0x%lx, load_end = 0x%lx\n", load,
Tom Rinicc955352018-05-01 12:32:37 -0400453 load_end);
Simon Glassb6396402014-06-12 07:24:46 -0600454
455 /* Check what type of image this is. */
456 if (images->legacy_hdr_valid) {
457 if (image_get_type(&images->legacy_hdr_os_copy)
458 == IH_TYPE_MULTI)
459 puts("WARNING: legacy format multi component image overwritten\n");
460 return BOOTM_ERR_OVERLAP;
461 } else {
462 puts("ERROR: new format image overwritten - must RESET the board to recover\n");
463 bootstage_error(BOOTSTAGE_ID_OVERWRITTEN);
464 return BOOTM_ERR_RESET;
465 }
466 }
467
Tom Rinicc955352018-05-01 12:32:37 -0400468 lmb_reserve(&images->lmb, images->os.load, (load_end -
469 images->os.load));
Simon Glassb6396402014-06-12 07:24:46 -0600470 return 0;
471}
472
473/**
474 * bootm_disable_interrupts() - Disable interrupts in preparation for load/boot
475 *
Heinrich Schuchardt185f8122022-01-19 18:05:50 +0100476 * Return: interrupt flag (0 if interrupts were disabled, non-zero if they were
Simon Glassb6396402014-06-12 07:24:46 -0600477 * enabled)
478 */
479ulong bootm_disable_interrupts(void)
480{
481 ulong iflag;
482
483 /*
484 * We have reached the point of no return: we are going to
485 * overwrite all exception vector code, so we cannot easily
486 * recover from any failures any more...
487 */
488 iflag = disable_interrupts();
489#ifdef CONFIG_NETCONSOLE
490 /* Stop the ethernet stack if NetConsole could have left it up */
491 eth_halt();
Simon Glassb6396402014-06-12 07:24:46 -0600492#endif
493
494#if defined(CONFIG_CMD_USB)
495 /*
496 * turn off USB to prevent the host controller from writing to the
497 * SDRAM while Linux is booting. This could happen (at least for OHCI
498 * controller), because the HCCA (Host Controller Communication Area)
499 * lies within the SDRAM and the host controller writes continously to
500 * this area (as busmaster!). The HccaFrameNumber is for example
501 * updated every 1 ms within the HCCA structure in SDRAM! For more
502 * details see the OpenHCI specification.
503 */
504 usb_stop();
505#endif
506 return iflag;
507}
508
Simon Glass6cd92b12020-11-05 10:33:42 -0700509#define CONSOLE_ARG "console="
Sean Andersonba9aa402022-05-19 18:26:05 -0400510#define NULL_CONSOLE (CONSOLE_ARG "ttynull")
511#define CONSOLE_ARG_SIZE sizeof(NULL_CONSOLE)
Simon Glassb6396402014-06-12 07:24:46 -0600512
Simon Glassb6386f32020-11-05 10:33:43 -0700513/**
514 * fixup_silent_linux() - Handle silencing the linux boot if required
515 *
516 * This uses the silent_linux envvar to control whether to add/set a "console="
517 * parameter to the command line
518 *
519 * @buf: Buffer containing the string to process
520 * @maxlen: Maximum length of buffer
Heinrich Schuchardt185f8122022-01-19 18:05:50 +0100521 * Return: 0 if OK, -ENOSPC if @maxlen is too small
Simon Glassb6386f32020-11-05 10:33:43 -0700522 */
523static int fixup_silent_linux(char *buf, int maxlen)
Simon Glassb6396402014-06-12 07:24:46 -0600524{
Simon Glassb6396402014-06-12 07:24:46 -0600525 int want_silent;
Simon Glassb6386f32020-11-05 10:33:43 -0700526 char *cmdline;
527 int size;
Simon Glassb6396402014-06-12 07:24:46 -0600528
Simon Glassb6386f32020-11-05 10:33:43 -0700529 /*
530 * Move the input string to the end of buffer. The output string will be
531 * built up at the start.
532 */
533 size = strlen(buf) + 1;
534 if (size * 2 > maxlen)
535 return -ENOSPC;
536 cmdline = buf + maxlen - size;
537 memmove(cmdline, buf, size);
Simon Glassb6396402014-06-12 07:24:46 -0600538 /*
539 * Only fix cmdline when requested. The environment variable can be:
540 *
541 * no - we never fixup
542 * yes - we always fixup
543 * unset - we rely on the console silent flag
544 */
Simon Glassbfebc8c2017-08-03 12:22:13 -0600545 want_silent = env_get_yesno("silent_linux");
Simon Glassb6396402014-06-12 07:24:46 -0600546 if (want_silent == 0)
Simon Glass4ae42642020-11-05 10:33:39 -0700547 return 0;
Simon Glassb6396402014-06-12 07:24:46 -0600548 else if (want_silent == -1 && !(gd->flags & GD_FLG_SILENT))
Simon Glass4ae42642020-11-05 10:33:39 -0700549 return 0;
Simon Glassb6396402014-06-12 07:24:46 -0600550
551 debug("before silent fix-up: %s\n", cmdline);
Simon Glassb6386f32020-11-05 10:33:43 -0700552 if (*cmdline) {
Simon Glassb6396402014-06-12 07:24:46 -0600553 char *start = strstr(cmdline, CONSOLE_ARG);
554
Simon Glassb6386f32020-11-05 10:33:43 -0700555 /* Check space for maximum possible new command line */
556 if (size + CONSOLE_ARG_SIZE > maxlen)
Simon Glass4ae42642020-11-05 10:33:39 -0700557 return -ENOSPC;
Simon Glassb6396402014-06-12 07:24:46 -0600558
559 if (start) {
560 char *end = strchr(start, ' ');
Simon Glass6cd92b12020-11-05 10:33:42 -0700561 int start_bytes;
Simon Glassb6396402014-06-12 07:24:46 -0600562
Sean Andersonba9aa402022-05-19 18:26:05 -0400563 start_bytes = start - cmdline;
Simon Glass6cd92b12020-11-05 10:33:42 -0700564 strncpy(buf, cmdline, start_bytes);
Sean Andersonba9aa402022-05-19 18:26:05 -0400565 strncpy(buf + start_bytes, NULL_CONSOLE, CONSOLE_ARG_SIZE);
Simon Glassb6396402014-06-12 07:24:46 -0600566 if (end)
Sean Andersonba9aa402022-05-19 18:26:05 -0400567 strcpy(buf + start_bytes + CONSOLE_ARG_SIZE - 1, end);
Simon Glassb6396402014-06-12 07:24:46 -0600568 else
Sean Andersonba9aa402022-05-19 18:26:05 -0400569 buf[start_bytes + CONSOLE_ARG_SIZE] = '\0';
Simon Glassb6396402014-06-12 07:24:46 -0600570 } else {
Sean Andersonba9aa402022-05-19 18:26:05 -0400571 sprintf(buf, "%s %s", cmdline, NULL_CONSOLE);
Simon Glassb6396402014-06-12 07:24:46 -0600572 }
Simon Glassb6386f32020-11-05 10:33:43 -0700573 if (buf + strlen(buf) >= cmdline)
574 return -ENOSPC;
Simon Glassb6396402014-06-12 07:24:46 -0600575 } else {
Sean Andersonba9aa402022-05-19 18:26:05 -0400576 if (maxlen < CONSOLE_ARG_SIZE)
Simon Glassb6386f32020-11-05 10:33:43 -0700577 return -ENOSPC;
Sean Andersonba9aa402022-05-19 18:26:05 -0400578 strcpy(buf, NULL_CONSOLE);
Simon Glassb6396402014-06-12 07:24:46 -0600579 }
Simon Glassb6386f32020-11-05 10:33:43 -0700580 debug("after silent fix-up: %s\n", buf);
Simon Glassb6396402014-06-12 07:24:46 -0600581
Simon Glassb6386f32020-11-05 10:33:43 -0700582 return 0;
583}
584
Simon Glass51bb3382020-11-05 10:33:48 -0700585/**
586 * process_subst() - Handle substitution of ${...} fields in the environment
587 *
588 * Handle variable substitution in the provided buffer
589 *
590 * @buf: Buffer containing the string to process
591 * @maxlen: Maximum length of buffer
Heinrich Schuchardt185f8122022-01-19 18:05:50 +0100592 * Return: 0 if OK, -ENOSPC if @maxlen is too small
Simon Glass51bb3382020-11-05 10:33:48 -0700593 */
594static int process_subst(char *buf, int maxlen)
595{
596 char *cmdline;
597 int size;
598 int ret;
599
600 /* Move to end of buffer */
601 size = strlen(buf) + 1;
602 cmdline = buf + maxlen - size;
603 if (buf + size > cmdline)
604 return -ENOSPC;
605 memmove(cmdline, buf, size);
606
607 ret = cli_simple_process_macros(cmdline, buf, cmdline - buf);
608
609 return ret;
610}
611
Simon Glass4448fe82020-11-05 10:33:45 -0700612int bootm_process_cmdline(char *buf, int maxlen, int flags)
613{
614 int ret;
615
616 /* Check config first to enable compiler to eliminate code */
617 if (IS_ENABLED(CONFIG_SILENT_CONSOLE) &&
618 !IS_ENABLED(CONFIG_SILENT_U_BOOT_ONLY) &&
619 (flags & BOOTM_CL_SILENT)) {
620 ret = fixup_silent_linux(buf, maxlen);
621 if (ret)
622 return log_msg_ret("silent", ret);
623 }
Simon Glassa8d69622021-03-15 18:11:23 +1300624 if (IS_ENABLED(CONFIG_BOOTARGS_SUBST) && IS_ENABLED(CONFIG_CMDLINE) &&
625 (flags & BOOTM_CL_SUBST)) {
Simon Glass51bb3382020-11-05 10:33:48 -0700626 ret = process_subst(buf, maxlen);
627 if (ret)
Simon Glass185756e2021-02-06 09:57:35 -0700628 return log_msg_ret("subst", ret);
Simon Glass51bb3382020-11-05 10:33:48 -0700629 }
Simon Glass4448fe82020-11-05 10:33:45 -0700630
631 return 0;
632}
633
Simon Glassb3c01672020-11-05 10:33:44 -0700634int bootm_process_cmdline_env(int flags)
Simon Glassb6386f32020-11-05 10:33:43 -0700635{
636 const int maxlen = MAX_CMDLINE_SIZE;
Simon Glassb3c01672020-11-05 10:33:44 -0700637 bool do_silent;
Simon Glassb6386f32020-11-05 10:33:43 -0700638 const char *env;
639 char *buf;
640 int ret;
641
642 /* First check if any action is needed */
643 do_silent = IS_ENABLED(CONFIG_SILENT_CONSOLE) &&
Simon Glassb3c01672020-11-05 10:33:44 -0700644 !IS_ENABLED(CONFIG_SILENT_U_BOOT_ONLY) && (flags & BOOTM_CL_SILENT);
Simon Glass51bb3382020-11-05 10:33:48 -0700645 if (!do_silent && !IS_ENABLED(CONFIG_BOOTARGS_SUBST))
Simon Glassb6386f32020-11-05 10:33:43 -0700646 return 0;
647
648 env = env_get("bootargs");
649 if (env && strlen(env) >= maxlen)
650 return -E2BIG;
651 buf = malloc(maxlen);
652 if (!buf)
653 return -ENOMEM;
654 if (env)
655 strcpy(buf, env);
656 else
657 *buf = '\0';
Simon Glass4448fe82020-11-05 10:33:45 -0700658 ret = bootm_process_cmdline(buf, maxlen, flags);
Simon Glassb6386f32020-11-05 10:33:43 -0700659 if (!ret) {
660 ret = env_set("bootargs", buf);
661
662 /*
663 * If buf is "" and bootargs does not exist, this will produce
664 * an error trying to delete bootargs. Ignore it
665 */
666 if (ret == -ENOENT)
667 ret = 0;
668 }
Simon Glassb6396402014-06-12 07:24:46 -0600669 free(buf);
Simon Glassb6386f32020-11-05 10:33:43 -0700670 if (ret)
671 return log_msg_ret("env", ret);
Simon Glass4ae42642020-11-05 10:33:39 -0700672
673 return 0;
Simon Glassb6396402014-06-12 07:24:46 -0600674}
Simon Glassb6396402014-06-12 07:24:46 -0600675
676/**
677 * Execute selected states of the bootm command.
678 *
679 * Note the arguments to this state must be the first argument, Any 'bootm'
680 * or sub-command arguments must have already been taken.
681 *
682 * Note that if states contains more than one flag it MUST contain
683 * BOOTM_STATE_START, since this handles and consumes the command line args.
684 *
685 * Also note that aside from boot_os_fn functions and bootm_load_os no other
686 * functions we store the return value of in 'ret' may use a negative return
687 * value, without special handling.
688 *
689 * @param cmdtp Pointer to bootm command table entry
690 * @param flag Command flags (CMD_FLAG_...)
691 * @param argc Number of subcommand arguments (0 = no arguments)
692 * @param argv Arguments
693 * @param states Mask containing states to run (BOOTM_STATE_...)
694 * @param images Image header information
695 * @param boot_progress 1 to show boot progress, 0 to not do this
Heinrich Schuchardt185f8122022-01-19 18:05:50 +0100696 * Return: 0 if ok, something else on error. Some errors will cause this
Simon Glassb6396402014-06-12 07:24:46 -0600697 * function to perform a reboot! If states contains BOOTM_STATE_OS_GO
698 * then the intent is to boot an OS, so this function will not return
699 * unless the image type is standalone.
700 */
Simon Glass09140112020-05-10 11:40:03 -0600701int do_bootm_states(struct cmd_tbl *cmdtp, int flag, int argc,
Simon Glassd9d7c202022-09-06 20:26:50 -0600702 char *const argv[], int states, struct bootm_headers *images,
Simon Glass09140112020-05-10 11:40:03 -0600703 int boot_progress)
Simon Glassb6396402014-06-12 07:24:46 -0600704{
705 boot_os_fn *boot_fn;
706 ulong iflag = 0;
707 int ret = 0, need_boot_fn;
708
709 images->state |= states;
710
711 /*
712 * Work through the states and see how far we get. We stop on
713 * any error.
714 */
715 if (states & BOOTM_STATE_START)
716 ret = bootm_start(cmdtp, flag, argc, argv);
717
Philippe Reynes9d46e632022-03-28 22:57:00 +0200718 if (!ret && (states & BOOTM_STATE_PRE_LOAD))
719 ret = bootm_pre_load(cmdtp, flag, argc, argv);
720
Simon Glassb6396402014-06-12 07:24:46 -0600721 if (!ret && (states & BOOTM_STATE_FINDOS))
722 ret = bootm_find_os(cmdtp, flag, argc, argv);
723
Zubair Lutfullah Kakakhelba079842016-09-09 09:18:58 +0100724 if (!ret && (states & BOOTM_STATE_FINDOTHER))
Simon Glassb6396402014-06-12 07:24:46 -0600725 ret = bootm_find_other(cmdtp, flag, argc, argv);
Simon Glassb6396402014-06-12 07:24:46 -0600726
727 /* Load the OS */
728 if (!ret && (states & BOOTM_STATE_LOADOS)) {
Simon Glassb6396402014-06-12 07:24:46 -0600729 iflag = bootm_disable_interrupts();
Tom Rinicc955352018-05-01 12:32:37 -0400730 ret = bootm_load_os(images, 0);
731 if (ret && ret != BOOTM_ERR_OVERLAP)
Simon Glassb6396402014-06-12 07:24:46 -0600732 goto err;
733 else if (ret == BOOTM_ERR_OVERLAP)
734 ret = 0;
Simon Glassb6396402014-06-12 07:24:46 -0600735 }
736
737 /* Relocate the ramdisk */
738#ifdef CONFIG_SYS_BOOT_RAMDISK_HIGH
739 if (!ret && (states & BOOTM_STATE_RAMDISK)) {
740 ulong rd_len = images->rd_end - images->rd_start;
741
742 ret = boot_ramdisk_high(&images->lmb, images->rd_start,
743 rd_len, &images->initrd_start, &images->initrd_end);
744 if (!ret) {
Simon Glass018f5302017-08-03 12:22:10 -0600745 env_set_hex("initrd_start", images->initrd_start);
746 env_set_hex("initrd_end", images->initrd_end);
Simon Glassb6396402014-06-12 07:24:46 -0600747 }
748 }
749#endif
Simon Glass0c303f92021-09-25 19:43:21 -0600750#if CONFIG_IS_ENABLED(OF_LIBFDT) && defined(CONFIG_LMB)
Simon Glassb6396402014-06-12 07:24:46 -0600751 if (!ret && (states & BOOTM_STATE_FDT)) {
752 boot_fdt_add_mem_rsv_regions(&images->lmb, images->ft_addr);
753 ret = boot_relocate_fdt(&images->lmb, &images->ft_addr,
754 &images->ft_len);
755 }
756#endif
757
758 /* From now on, we need the OS boot function */
759 if (ret)
760 return ret;
761 boot_fn = bootm_os_get_boot_func(images->os.os);
762 need_boot_fn = states & (BOOTM_STATE_OS_CMDLINE |
763 BOOTM_STATE_OS_BD_T | BOOTM_STATE_OS_PREP |
764 BOOTM_STATE_OS_FAKE_GO | BOOTM_STATE_OS_GO);
765 if (boot_fn == NULL && need_boot_fn) {
766 if (iflag)
767 enable_interrupts();
768 printf("ERROR: booting os '%s' (%d) is not supported\n",
769 genimg_get_os_name(images->os.os), images->os.os);
770 bootstage_error(BOOTSTAGE_ID_CHECK_BOOT_OS);
771 return 1;
772 }
773
Hector Palacios19e86492016-07-11 12:34:37 +0200774
Simon Glassb6396402014-06-12 07:24:46 -0600775 /* Call various other states that are not generally used */
776 if (!ret && (states & BOOTM_STATE_OS_CMDLINE))
777 ret = boot_fn(BOOTM_STATE_OS_CMDLINE, argc, argv, images);
778 if (!ret && (states & BOOTM_STATE_OS_BD_T))
779 ret = boot_fn(BOOTM_STATE_OS_BD_T, argc, argv, images);
Hector Palacios19e86492016-07-11 12:34:37 +0200780 if (!ret && (states & BOOTM_STATE_OS_PREP)) {
Simon Glass51bb3382020-11-05 10:33:48 -0700781 ret = bootm_process_cmdline_env(images->os.os == IH_OS_LINUX);
Simon Glassd9477a02020-11-05 10:33:41 -0700782 if (ret) {
783 printf("Cmdline setup failed (err=%d)\n", ret);
784 ret = CMD_RET_FAILURE;
785 goto err;
Simon Glass4ae42642020-11-05 10:33:39 -0700786 }
Simon Glassb6396402014-06-12 07:24:46 -0600787 ret = boot_fn(BOOTM_STATE_OS_PREP, argc, argv, images);
Hector Palacios19e86492016-07-11 12:34:37 +0200788 }
Simon Glassb6396402014-06-12 07:24:46 -0600789
790#ifdef CONFIG_TRACE
791 /* Pretend to run the OS, then run a user command */
792 if (!ret && (states & BOOTM_STATE_OS_FAKE_GO)) {
Simon Glass00caae62017-08-03 12:22:12 -0600793 char *cmd_list = env_get("fakegocmd");
Simon Glassb6396402014-06-12 07:24:46 -0600794
795 ret = boot_selected_os(argc, argv, BOOTM_STATE_OS_FAKE_GO,
796 images, boot_fn);
797 if (!ret && cmd_list)
798 ret = run_command_list(cmd_list, -1, flag);
799 }
800#endif
801
802 /* Check for unsupported subcommand. */
803 if (ret) {
Simon Glass13819f02022-10-11 09:47:07 -0600804 printf("subcommand failed (err=%d)\n", ret);
Simon Glassb6396402014-06-12 07:24:46 -0600805 return ret;
806 }
807
808 /* Now run the OS! We hope this doesn't return */
809 if (!ret && (states & BOOTM_STATE_OS_GO))
810 ret = boot_selected_os(argc, argv, BOOTM_STATE_OS_GO,
811 images, boot_fn);
812
813 /* Deal with any fallout */
814err:
815 if (iflag)
816 enable_interrupts();
817
818 if (ret == BOOTM_ERR_UNIMPLEMENTED)
819 bootstage_error(BOOTSTAGE_ID_DECOMP_UNIMPL);
820 else if (ret == BOOTM_ERR_RESET)
821 do_reset(cmdtp, flag, argc, argv);
822
823 return ret;
824}
825
Tom Rinic76c93a2019-05-23 07:14:07 -0400826#if CONFIG_IS_ENABLED(LEGACY_IMAGE_FORMAT)
Simon Glassb6396402014-06-12 07:24:46 -0600827/**
828 * image_get_kernel - verify legacy format kernel image
829 * @img_addr: in RAM address of the legacy format image to be verified
830 * @verify: data CRC verification flag
831 *
832 * image_get_kernel() verifies legacy image integrity and returns pointer to
833 * legacy image header if image verification was completed successfully.
834 *
835 * returns:
836 * pointer to a legacy image header if valid image was found
837 * otherwise return NULL
838 */
Simon Glassf3543e62022-09-06 20:26:52 -0600839static struct legacy_img_hdr *image_get_kernel(ulong img_addr, int verify)
Simon Glassb6396402014-06-12 07:24:46 -0600840{
Simon Glassf3543e62022-09-06 20:26:52 -0600841 struct legacy_img_hdr *hdr = (struct legacy_img_hdr *)img_addr;
Simon Glassb6396402014-06-12 07:24:46 -0600842
843 if (!image_check_magic(hdr)) {
844 puts("Bad Magic Number\n");
845 bootstage_error(BOOTSTAGE_ID_CHECK_MAGIC);
846 return NULL;
847 }
848 bootstage_mark(BOOTSTAGE_ID_CHECK_HEADER);
849
850 if (!image_check_hcrc(hdr)) {
851 puts("Bad Header Checksum\n");
852 bootstage_error(BOOTSTAGE_ID_CHECK_HEADER);
853 return NULL;
854 }
855
856 bootstage_mark(BOOTSTAGE_ID_CHECK_CHECKSUM);
857 image_print_contents(hdr);
858
859 if (verify) {
860 puts(" Verifying Checksum ... ");
861 if (!image_check_dcrc(hdr)) {
862 printf("Bad Data CRC\n");
863 bootstage_error(BOOTSTAGE_ID_CHECK_CHECKSUM);
864 return NULL;
865 }
866 puts("OK\n");
867 }
868 bootstage_mark(BOOTSTAGE_ID_CHECK_ARCH);
869
870 if (!image_check_target_arch(hdr)) {
871 printf("Unsupported Architecture 0x%x\n", image_get_arch(hdr));
872 bootstage_error(BOOTSTAGE_ID_CHECK_ARCH);
873 return NULL;
874 }
875 return hdr;
876}
877#endif
878
879/**
880 * boot_get_kernel - find kernel image
881 * @os_data: pointer to a ulong variable, will hold os data start address
882 * @os_len: pointer to a ulong variable, will hold os data length
883 *
884 * boot_get_kernel() tries to find a kernel image, verifies its integrity
885 * and locates kernel data.
886 *
887 * returns:
888 * pointer to image header if valid image was found, plus kernel start
889 * address and length, otherwise NULL
890 */
Simon Glass09140112020-05-10 11:40:03 -0600891static const void *boot_get_kernel(struct cmd_tbl *cmdtp, int flag, int argc,
Simon Glassd9d7c202022-09-06 20:26:50 -0600892 char *const argv[], struct bootm_headers *images,
Simon Glassb6396402014-06-12 07:24:46 -0600893 ulong *os_data, ulong *os_len)
894{
Tom Rinic76c93a2019-05-23 07:14:07 -0400895#if CONFIG_IS_ENABLED(LEGACY_IMAGE_FORMAT)
Simon Glassf3543e62022-09-06 20:26:52 -0600896 struct legacy_img_hdr *hdr;
Simon Glassb6396402014-06-12 07:24:46 -0600897#endif
898 ulong img_addr;
899 const void *buf;
Simon Glassb6396402014-06-12 07:24:46 -0600900 const char *fit_uname_config = NULL;
901 const char *fit_uname_kernel = NULL;
Simon Glassbf371b42021-09-25 19:43:20 -0600902#if CONFIG_IS_ENABLED(FIT)
Simon Glassb6396402014-06-12 07:24:46 -0600903 int os_noffset;
904#endif
905
Safae Ouajih636da202023-02-06 00:50:17 +0100906#ifdef CONFIG_ANDROID_BOOT_IMAGE
907 const void *boot_img;
908 const void *vendor_boot_img;
909#endif
Bryan Wue6c88a62014-08-15 16:51:39 -0700910 img_addr = genimg_get_kernel_addr_fit(argc < 1 ? NULL : argv[0],
911 &fit_uname_config,
912 &fit_uname_kernel);
Simon Glassb6396402014-06-12 07:24:46 -0600913
Simon Glass494bcf12023-02-05 15:36:24 -0700914 if (IS_ENABLED(CONFIG_CMD_BOOTM_PRE_LOAD))
Philippe Reynes9d46e632022-03-28 22:57:00 +0200915 img_addr += image_load_offset;
916
Simon Glassb6396402014-06-12 07:24:46 -0600917 bootstage_mark(BOOTSTAGE_ID_CHECK_MAGIC);
918
Simon Glassb6396402014-06-12 07:24:46 -0600919 /* check image type, for FIT images get FIT kernel node */
920 *os_data = *os_len = 0;
921 buf = map_sysmem(img_addr, 0);
922 switch (genimg_get_format(buf)) {
Tom Rinic76c93a2019-05-23 07:14:07 -0400923#if CONFIG_IS_ENABLED(LEGACY_IMAGE_FORMAT)
Simon Glassb6396402014-06-12 07:24:46 -0600924 case IMAGE_FORMAT_LEGACY:
925 printf("## Booting kernel from Legacy Image at %08lx ...\n",
926 img_addr);
927 hdr = image_get_kernel(img_addr, images->verify);
928 if (!hdr)
929 return NULL;
930 bootstage_mark(BOOTSTAGE_ID_CHECK_IMAGETYPE);
931
932 /* get os_data and os_len */
933 switch (image_get_type(hdr)) {
934 case IH_TYPE_KERNEL:
935 case IH_TYPE_KERNEL_NOLOAD:
936 *os_data = image_get_data(hdr);
937 *os_len = image_get_data_size(hdr);
938 break;
939 case IH_TYPE_MULTI:
940 image_multi_getimg(hdr, 0, os_data, os_len);
941 break;
942 case IH_TYPE_STANDALONE:
943 *os_data = image_get_data(hdr);
944 *os_len = image_get_data_size(hdr);
945 break;
946 default:
947 printf("Wrong Image Type for %s command\n",
948 cmdtp->name);
949 bootstage_error(BOOTSTAGE_ID_CHECK_IMAGETYPE);
950 return NULL;
951 }
952
953 /*
954 * copy image header to allow for image overwrites during
955 * kernel decompression.
956 */
957 memmove(&images->legacy_hdr_os_copy, hdr,
Simon Glassf3543e62022-09-06 20:26:52 -0600958 sizeof(struct legacy_img_hdr));
Simon Glassb6396402014-06-12 07:24:46 -0600959
960 /* save pointer to image header */
961 images->legacy_hdr_os = hdr;
962
963 images->legacy_hdr_valid = 1;
964 bootstage_mark(BOOTSTAGE_ID_DECOMP_IMAGE);
965 break;
966#endif
Simon Glassbf371b42021-09-25 19:43:20 -0600967#if CONFIG_IS_ENABLED(FIT)
Simon Glassb6396402014-06-12 07:24:46 -0600968 case IMAGE_FORMAT_FIT:
Simon Glass126cc862014-06-12 07:24:47 -0600969 os_noffset = fit_image_load(images, img_addr,
Simon Glassb6396402014-06-12 07:24:46 -0600970 &fit_uname_kernel, &fit_uname_config,
971 IH_ARCH_DEFAULT, IH_TYPE_KERNEL,
972 BOOTSTAGE_ID_FIT_KERNEL_START,
973 FIT_LOAD_IGNORED, os_data, os_len);
974 if (os_noffset < 0)
975 return NULL;
976
977 images->fit_hdr_os = map_sysmem(img_addr, 0);
978 images->fit_uname_os = fit_uname_kernel;
979 images->fit_uname_cfg = fit_uname_config;
980 images->fit_noffset_os = os_noffset;
981 break;
982#endif
983#ifdef CONFIG_ANDROID_BOOT_IMAGE
984 case IMAGE_FORMAT_ANDROID:
Safae Ouajih636da202023-02-06 00:50:17 +0100985 boot_img = buf;
986 vendor_boot_img = NULL;
987 if (IS_ENABLED(CONFIG_CMD_ABOOTIMG)) {
988 boot_img = map_sysmem(get_abootimg_addr(), 0);
989 vendor_boot_img = map_sysmem(get_avendor_bootimg_addr(), 0);
990 }
Simon Glassb6396402014-06-12 07:24:46 -0600991 printf("## Booting Android Image at 0x%08lx ...\n", img_addr);
Safae Ouajih636da202023-02-06 00:50:17 +0100992 if (android_image_get_kernel(boot_img, vendor_boot_img, images->verify,
Simon Glassb6396402014-06-12 07:24:46 -0600993 os_data, os_len))
994 return NULL;
Safae Ouajih636da202023-02-06 00:50:17 +0100995 if (IS_ENABLED(CONFIG_CMD_ABOOTIMG)) {
996 unmap_sysmem(vendor_boot_img);
997 unmap_sysmem(boot_img);
998 }
Simon Glassb6396402014-06-12 07:24:46 -0600999 break;
1000#endif
1001 default:
1002 printf("Wrong Image Format for %s command\n", cmdtp->name);
1003 bootstage_error(BOOTSTAGE_ID_FIT_KERNEL_INFO);
1004 return NULL;
1005 }
1006
1007 debug(" kernel data at 0x%08lx, len = 0x%08lx (%ld)\n",
1008 *os_data, *os_len, *os_len);
1009
1010 return buf;
1011}
Heinrich Schuchardtf6c6df72019-01-08 18:13:06 +01001012
1013/**
1014 * switch_to_non_secure_mode() - switch to non-secure mode
1015 *
1016 * This routine is overridden by architectures requiring this feature.
1017 */
1018void __weak switch_to_non_secure_mode(void)
1019{
1020}
1021
Simon Glassce1400f2014-06-12 07:24:53 -06001022#else /* USE_HOSTCC */
1023
Fabrice Fontaine93e07882019-05-03 22:37:05 +02001024#if defined(CONFIG_FIT_SIGNATURE)
Simon Glass8a9d0372020-03-18 11:44:02 -06001025static int bootm_host_load_image(const void *fit, int req_image_type,
1026 int cfg_noffset)
Simon Glassce1400f2014-06-12 07:24:53 -06001027{
1028 const char *fit_uname_config = NULL;
1029 ulong data, len;
Simon Glassd9d7c202022-09-06 20:26:50 -06001030 struct bootm_headers images;
Simon Glassce1400f2014-06-12 07:24:53 -06001031 int noffset;
Tom Rinic45568c2022-06-25 19:29:46 -04001032 ulong load_end, buf_size;
Simon Glassce1400f2014-06-12 07:24:53 -06001033 uint8_t image_type;
Daniel Golle0cd57f22022-08-27 04:14:42 +01001034 uint8_t image_comp;
Simon Glassce1400f2014-06-12 07:24:53 -06001035 void *load_buf;
1036 int ret;
1037
Simon Glass8a9d0372020-03-18 11:44:02 -06001038 fit_uname_config = fdt_get_name(fit, cfg_noffset, NULL);
Simon Glassce1400f2014-06-12 07:24:53 -06001039 memset(&images, '\0', sizeof(images));
1040 images.verify = 1;
1041 noffset = fit_image_load(&images, (ulong)fit,
1042 NULL, &fit_uname_config,
1043 IH_ARCH_DEFAULT, req_image_type, -1,
1044 FIT_LOAD_IGNORED, &data, &len);
1045 if (noffset < 0)
1046 return noffset;
1047 if (fit_image_get_type(fit, noffset, &image_type)) {
1048 puts("Can't get image type!\n");
1049 return -EINVAL;
1050 }
1051
Daniel Golle88de6c52022-08-27 04:17:28 +01001052 if (fit_image_get_comp(fit, noffset, &image_comp))
1053 image_comp = IH_COMP_NONE;
Simon Glassce1400f2014-06-12 07:24:53 -06001054
1055 /* Allow the image to expand by a factor of 4, should be safe */
Tom Rinic45568c2022-06-25 19:29:46 -04001056 buf_size = (1 << 20) + len * 4;
1057 load_buf = malloc(buf_size);
Daniel Golle0cd57f22022-08-27 04:14:42 +01001058 ret = image_decomp(image_comp, 0, data, image_type, load_buf,
Tom Rinic45568c2022-06-25 19:29:46 -04001059 (void *)data, len, buf_size, &load_end);
Simon Glassce1400f2014-06-12 07:24:53 -06001060 free(load_buf);
Simon Glass081cc192014-12-02 13:17:33 -07001061
Julius Werner20908542019-07-24 19:37:54 -07001062 if (ret) {
Daniel Golle0cd57f22022-08-27 04:14:42 +01001063 ret = handle_decomp_error(image_comp, load_end - 0, buf_size, ret);
Julius Werner20908542019-07-24 19:37:54 -07001064 if (ret != BOOTM_ERR_UNIMPLEMENTED)
1065 return ret;
1066 }
Simon Glassce1400f2014-06-12 07:24:53 -06001067
1068 return 0;
1069}
1070
1071int bootm_host_load_images(const void *fit, int cfg_noffset)
1072{
1073 static uint8_t image_types[] = {
1074 IH_TYPE_KERNEL,
1075 IH_TYPE_FLATDT,
1076 IH_TYPE_RAMDISK,
1077 };
1078 int err = 0;
1079 int i;
1080
1081 for (i = 0; i < ARRAY_SIZE(image_types); i++) {
1082 int ret;
1083
Simon Glass8a9d0372020-03-18 11:44:02 -06001084 ret = bootm_host_load_image(fit, image_types[i], cfg_noffset);
Simon Glassce1400f2014-06-12 07:24:53 -06001085 if (!err && ret && ret != -ENOENT)
1086 err = ret;
1087 }
1088
1089 /* Return the first error we found */
1090 return err;
1091}
Fabrice Fontaine93e07882019-05-03 22:37:05 +02001092#endif
Simon Glassea51a622014-06-12 07:24:51 -06001093
1094#endif /* ndef USE_HOSTCC */