blob: 4ea5977a54fe8e7bc8a0993212ef92137521dd5a [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>
dongqing.li994a05e2023-10-17 09:19:27 +080035#include <version.h>
Simon Glassb6396402014-06-12 07:24:46 -060036
Bo Lv81aadc32024-02-28 20:18:44 +080037#if defined(CONFIG_OF_LIBFDT_OVERLAY) && defined(CONFIG_AMLOGIC_MODIFY)
38#include <dt_table.h>
39#include <image-android-dt.h>
40#endif
41
Dongjin Kim545af0c2025-05-08 14:48:45 +090042#if defined(CONFIG_S7D_ODROIDC5)
43extern struct mmc *find_mmc_device(int dev_num);
44extern struct blk_desc *mmc_get_blk_desc(struct mmc *mmc);
45extern int mmc_get_env_dev(void);
46#endif
47
Simon Glassb6386f32020-11-05 10:33:43 -070048#define MAX_CMDLINE_SIZE SZ_4K
49
Simon Glassb6396402014-06-12 07:24:46 -060050#define IH_INITRD_ARCH IH_ARCH_DEFAULT
51
Simon Glassea51a622014-06-12 07:24:51 -060052#ifndef USE_HOSTCC
53
54DECLARE_GLOBAL_DATA_PTR;
55
Simon Glassd9d7c202022-09-06 20:26:50 -060056struct bootm_headers images; /* pointers to os/initrd/fdt images */
Tom Rini5db28902016-08-12 08:31:15 -040057
Simon Glass09140112020-05-10 11:40:03 -060058static const void *boot_get_kernel(struct cmd_tbl *cmdtp, int flag, int argc,
Simon Glassd9d7c202022-09-06 20:26:50 -060059 char *const argv[], struct bootm_headers *images,
Simon Glassb6396402014-06-12 07:24:46 -060060 ulong *os_data, ulong *os_len);
61
Simon Glass329da482018-05-16 09:42:25 -060062__weak void board_quiesce_devices(void)
63{
64}
65
Simon Glassb6396402014-06-12 07:24:46 -060066#ifdef CONFIG_LMB
Simon Glassd9d7c202022-09-06 20:26:50 -060067static void boot_start_lmb(struct bootm_headers *images)
Simon Glassb6396402014-06-12 07:24:46 -060068{
69 ulong mem_start;
70 phys_size_t mem_size;
71
Simon Glass723806c2017-08-03 12:22:15 -060072 mem_start = env_get_bootm_low();
73 mem_size = env_get_bootm_size();
Simon Glassb6396402014-06-12 07:24:46 -060074
Simon Goldschmidt9cc23232019-01-26 22:13:04 +010075 lmb_init_and_reserve_range(&images->lmb, (phys_addr_t)mem_start,
76 mem_size, NULL);
Simon Glassb6396402014-06-12 07:24:46 -060077}
78#else
79#define lmb_reserve(lmb, base, size)
Simon Glassd9d7c202022-09-06 20:26:50 -060080static inline void boot_start_lmb(struct bootm_headers *images) { }
Simon Glassb6396402014-06-12 07:24:46 -060081#endif
82
Simon Glass09140112020-05-10 11:40:03 -060083static int bootm_start(struct cmd_tbl *cmdtp, int flag, int argc,
84 char *const argv[])
Simon Glassb6396402014-06-12 07:24:46 -060085{
86 memset((void *)&images, 0, sizeof(images));
Simon Glassbfebc8c2017-08-03 12:22:13 -060087 images.verify = env_get_yesno("verify");
Simon Glassb6396402014-06-12 07:24:46 -060088
89 boot_start_lmb(&images);
90
91 bootstage_mark_name(BOOTSTAGE_ID_BOOTM_START, "bootm_start");
92 images.state = BOOTM_STATE_START;
93
94 return 0;
95}
96
Philippe Reynes9d46e632022-03-28 22:57:00 +020097static ulong bootm_data_addr(int argc, char *const argv[])
98{
99 ulong addr;
100
101 if (argc > 0)
102 addr = simple_strtoul(argv[0], NULL, 16);
103 else
104 addr = image_load_addr;
105
106 return addr;
107}
108
109static int bootm_pre_load(struct cmd_tbl *cmdtp, int flag, int argc,
110 char *const argv[])
111{
112 ulong data_addr = bootm_data_addr(argc, argv);
113 int ret = 0;
114
115 if (CONFIG_IS_ENABLED(CMD_BOOTM_PRE_LOAD))
116 ret = image_pre_load(data_addr);
117
118 if (ret)
119 ret = CMD_RET_FAILURE;
120
121 return ret;
122}
123
Simon Glass09140112020-05-10 11:40:03 -0600124static int bootm_find_os(struct cmd_tbl *cmdtp, int flag, int argc,
125 char *const argv[])
Simon Glassb6396402014-06-12 07:24:46 -0600126{
127 const void *os_hdr;
128 bool ep_found = false;
Simon Glass90268b82014-10-19 21:11:24 -0600129 int ret;
Simon Glassb6396402014-06-12 07:24:46 -0600130
131 /* get kernel image header, start address and length */
132 os_hdr = boot_get_kernel(cmdtp, flag, argc, argv,
133 &images, &images.os.image_start, &images.os.image_len);
134 if (images.os.image_len == 0) {
135 puts("ERROR: can't get kernel image!\n");
136 return 1;
137 }
138
139 /* get image parameters */
140 switch (genimg_get_format(os_hdr)) {
Tom Rinic76c93a2019-05-23 07:14:07 -0400141#if CONFIG_IS_ENABLED(LEGACY_IMAGE_FORMAT)
Simon Glassb6396402014-06-12 07:24:46 -0600142 case IMAGE_FORMAT_LEGACY:
143 images.os.type = image_get_type(os_hdr);
144 images.os.comp = image_get_comp(os_hdr);
145 images.os.os = image_get_os(os_hdr);
146
147 images.os.end = image_get_image_end(os_hdr);
148 images.os.load = image_get_load(os_hdr);
Simon Glass90268b82014-10-19 21:11:24 -0600149 images.os.arch = image_get_arch(os_hdr);
Bo Lv4a465022023-02-28 05:51:47 +0000150#ifdef CONFIG_AMLOGIC_MODIFY
151 if (images.os.arch == IH_ARCH_ARM) {
Bo Lvae6e7052024-04-26 18:05:18 +0800152 env_set("initrd_high", "0D000000");
153 env_set("fdt_high", "0D000000");
Bo Lv4a465022023-02-28 05:51:47 +0000154 }
155#endif
Simon Glassb6396402014-06-12 07:24:46 -0600156 break;
157#endif
Simon Glassbf371b42021-09-25 19:43:20 -0600158#if CONFIG_IS_ENABLED(FIT)
Simon Glassb6396402014-06-12 07:24:46 -0600159 case IMAGE_FORMAT_FIT:
160 if (fit_image_get_type(images.fit_hdr_os,
161 images.fit_noffset_os,
162 &images.os.type)) {
163 puts("Can't get image type!\n");
164 bootstage_error(BOOTSTAGE_ID_FIT_TYPE);
165 return 1;
166 }
167
168 if (fit_image_get_comp(images.fit_hdr_os,
169 images.fit_noffset_os,
170 &images.os.comp)) {
171 puts("Can't get image compression!\n");
172 bootstage_error(BOOTSTAGE_ID_FIT_COMPRESSION);
173 return 1;
174 }
175
176 if (fit_image_get_os(images.fit_hdr_os, images.fit_noffset_os,
177 &images.os.os)) {
178 puts("Can't get image OS!\n");
179 bootstage_error(BOOTSTAGE_ID_FIT_OS);
180 return 1;
181 }
182
Simon Glass90268b82014-10-19 21:11:24 -0600183 if (fit_image_get_arch(images.fit_hdr_os,
184 images.fit_noffset_os,
185 &images.os.arch)) {
186 puts("Can't get image ARCH!\n");
187 return 1;
188 }
189
Simon Glassb6396402014-06-12 07:24:46 -0600190 images.os.end = fit_get_end(images.fit_hdr_os);
191
192 if (fit_image_get_load(images.fit_hdr_os, images.fit_noffset_os,
193 &images.os.load)) {
194 puts("Can't get image load address!\n");
195 bootstage_error(BOOTSTAGE_ID_FIT_LOADADDR);
196 return 1;
197 }
198 break;
199#endif
200#ifdef CONFIG_ANDROID_BOOT_IMAGE
201 case IMAGE_FORMAT_ANDROID:
Bo Lv4a465022023-02-28 05:51:47 +0000202#ifdef CONFIG_AMLOGIC_MODIFY
Bo Lvcc445512024-03-21 13:48:45 +0800203 #ifdef CONFIG_MODIFY_INITRD_HIGH
204 env_set("initrd_high", "0D000000");
205 #endif
Bo Lv4a465022023-02-28 05:51:47 +0000206 if (image_get_magic((image_header_t *)images.os.image_start) == IH_MAGIC) {
Bo Lv6a9c2962024-03-27 11:23:21 +0800207 #ifdef CONFIG_INITRD_FDT_HIGH_ADDR
208 switch (env_get_bootm_size()) {
209 case 0x8000000:
210 env_set("initrd_high", "06000000");
211 env_set("fdt_high", "06000000");
212 break;
213 case 0x10000000:
214 case 0x20000000:
215 env_set("initrd_high", "0F400000");
216 env_set("fdt_high", "0F400000");
217 break;
218 default:
219 env_set("initrd_high", "0D000000");
220 env_set("fdt_high", "0D000000");
221 break;
222 }
Bo Lv4a465022023-02-28 05:51:47 +0000223 #else
224 env_set("initrd_high", "0D000000");
Bo Lv4a465022023-02-28 05:51:47 +0000225 env_set("fdt_high", "0D000000");
226 #endif
227
228 images.os.arch = ((image_header_t *)(images.os.image_start))->ih_arch;
229 images.os.image_start += sizeof(image_header_t);
230 }
231 images.os.type = IH_TYPE_KERNEL;
232
233 if (images.os.arch == IH_ARCH_ARM)
Bo Lv65d86792024-08-30 11:02:03 +0800234 images.os.comp = image_get_comp(os_hdr + sizeof(sizeof(boot_img_hdr_t)));
Bo Lv4a465022023-02-28 05:51:47 +0000235 else
236 images.os.comp = android_image_get_comp(os_hdr);
237
238 //images.os.comp = android_image_get_comp(os_hdr);
239 images.os.os = IH_OS_LINUX;
240
241 images.os.end = android_image_get_end(os_hdr);
242 images.os.load = android_image_get_kload(os_hdr);
243 if (images.os.load == 0x10008000)
244 images.os.load = 0x1080000;
245 images.ep = images.os.load;
246 ep_found = true;
247#else
Simon Glassb6396402014-06-12 07:24:46 -0600248 images.os.type = IH_TYPE_KERNEL;
Eugeniu Rosca829ceb22019-04-08 17:35:27 +0200249 images.os.comp = android_image_get_kcomp(os_hdr);
Simon Glassb6396402014-06-12 07:24:46 -0600250 images.os.os = IH_OS_LINUX;
Simon Glassb6396402014-06-12 07:24:46 -0600251
252 images.os.end = android_image_get_end(os_hdr);
253 images.os.load = android_image_get_kload(os_hdr);
Ahmad Draidi86f46952014-10-23 20:50:07 +0300254 images.ep = images.os.load;
255 ep_found = true;
Bo Lv4a465022023-02-28 05:51:47 +0000256#endif
Simon Glassb6396402014-06-12 07:24:46 -0600257 break;
258#endif
259 default:
260 puts("ERROR: unknown image format type!\n");
261 return 1;
262 }
263
Simon Glass90268b82014-10-19 21:11:24 -0600264 /* If we have a valid setup.bin, we will use that for entry (x86) */
Simon Glass5bda35c2014-10-10 08:21:57 -0600265 if (images.os.arch == IH_ARCH_I386 ||
266 images.os.arch == IH_ARCH_X86_64) {
Simon Glass90268b82014-10-19 21:11:24 -0600267 ulong len;
268
269 ret = boot_get_setup(&images, IH_ARCH_I386, &images.ep, &len);
270 if (ret < 0 && ret != -ENOENT) {
271 puts("Could not find a valid setup.bin for x86\n");
272 return 1;
273 }
274 /* Kernel entry point is the setup.bin */
275 } else if (images.legacy_hdr_valid) {
Simon Glassb6396402014-06-12 07:24:46 -0600276 images.ep = image_get_ep(&images.legacy_hdr_os_copy);
Simon Glassbf371b42021-09-25 19:43:20 -0600277#if CONFIG_IS_ENABLED(FIT)
Simon Glassb6396402014-06-12 07:24:46 -0600278 } else if (images.fit_uname_os) {
279 int ret;
280
281 ret = fit_image_get_entry(images.fit_hdr_os,
282 images.fit_noffset_os, &images.ep);
283 if (ret) {
284 puts("Can't get entry point property!\n");
285 return 1;
286 }
287#endif
288 } else if (!ep_found) {
289 puts("Could not find kernel entry point!\n");
290 return 1;
291 }
292
293 if (images.os.type == IH_TYPE_KERNEL_NOLOAD) {
Marek Vasut487b5fa2018-06-13 06:13:33 +0200294 if (CONFIG_IS_ENABLED(CMD_BOOTI) &&
295 images.os.arch == IH_ARCH_ARM64) {
296 ulong image_addr;
297 ulong image_size;
298
299 ret = booti_setup(images.os.image_start, &image_addr,
300 &image_size, true);
301 if (ret != 0)
302 return 1;
303
304 images.os.type = IH_TYPE_KERNEL;
305 images.os.load = image_addr;
306 images.ep = image_addr;
307 } else {
308 images.os.load = images.os.image_start;
309 images.ep += images.os.image_start;
310 }
Simon Glassb6396402014-06-12 07:24:46 -0600311 }
312
Simon Glass7a80de42016-02-24 09:14:42 -0700313 images.os.start = map_to_sysmem(os_hdr);
Simon Glassb6396402014-06-12 07:24:46 -0600314
315 return 0;
316}
317
Bo Lv81aadc32024-02-28 20:18:44 +0800318/*
319 * load dtb overlay partition to mem
320*/
321#if defined(CONFIG_OF_LIBFDT_OVERLAY) && defined(CONFIG_AMLOGIC_MODIFY)
322static int read_fdto_partition(void)
323{
324 char cmd[128];
325 void *dtbo_mem_addr = NULL;
326 char dtbo_partition[32] = {0};
327 char *s1;
328 struct dt_table_header hdr;
Dongjin Kim545af0c2025-05-08 14:48:45 +0900329#if defined(CONFIG_S7D_ODROIDC5)
330 struct blk_desc *dev_desc;
331 struct disk_partition info;
332 struct mmc *mmc = find_mmc_device(mmc_get_env_dev());
333 int ret;
334
335 if (!mmc)
336 return -EIO;
337
338 dev_desc = mmc_get_blk_desc(mmc);
339 if (!dev_desc)
340 return -EIO;
341#endif
Bo Lv81aadc32024-02-28 20:18:44 +0800342
343 //run_command("get_valid_slot;", 0);
344 s1 = env_get("active_slot");
345 if (s1 && (strcmp(s1, "normal") == 0))
346 strcpy(dtbo_partition, "dtbo");
347 else if (s1 && (strcmp(s1, "_a") == 0))
348 strcpy(dtbo_partition, "dtbo_a");
349 else if (s1 && (strcmp(s1, "_b") == 0))
350 strcpy(dtbo_partition, "dtbo_b");
351
Dongjin Kim545af0c2025-05-08 14:48:45 +0900352#if defined(CONFIG_S7D_ODROIDC5)
353 ret = part_get_info_by_name(dev_desc, dtbo_partition, &info);
354 if (ret) {
355 pr_err("Skip to read missing '%s' partition\n", dtbo_partition);
356 return -1;
357 }
358#endif
359
Bo Lv81aadc32024-02-28 20:18:44 +0800360 /*
361 * Though it is really no need to parse the adtimg infos
362 * here, but wasting time to read the whole dtbo image
363 * partition is unacceptable
364 */
365 pr_info("Start read %s partition datas!\n", dtbo_partition);
366 extern int store_read(const char *name, loff_t off, size_t size, void *buf);
367 if (store_read(dtbo_partition, 0,
368 sizeof(struct dt_table_header), &hdr) < 0) {
369 pr_err("Fail to read header of DTBO partition\n");
370 return -1;
371 }
372
373#ifdef CONFIG_CMD_ADTIMG
374 if (!android_dt_check_header((ulong)&hdr)) {
375 printf("DTBO partition header is incorrect\n");
376 return -1;
377 }
378#endif
379
380 dtbo_mem_addr = malloc(fdt32_to_cpu(hdr.total_size));
381 if (!dtbo_mem_addr) {
382 printf("out of memory\n");
383 return -1;
384 } else {
385 if (store_read(dtbo_partition, 0,
386 fdt32_to_cpu(hdr.total_size), dtbo_mem_addr) < 0) {
387 printf("Fail to read DTBO partition\n");
388 free(dtbo_mem_addr);
389 return -1;
390 }
391 else {
392 sprintf(cmd, "0x%p", dtbo_mem_addr);
393 env_set("dtbo_mem_addr",cmd);
394 }
395 }
396
397 return 0;
398}
399
400static int get_fdto_totalsize(u32 *tz)
401{
402#ifdef CONFIG_CMD_ADTIMG
403 unsigned long long dtbo_mem_addr = 0x0;
404#endif
405 int ret;
406
407 ret = read_fdto_partition();
408 if (ret != 0)
409 return ret;
410
411#ifdef CONFIG_CMD_ADTIMG
412 dtbo_mem_addr = simple_strtoul(env_get("dtbo_mem_addr"), NULL, 16);
413 *tz = android_dt_get_totalsize(dtbo_mem_addr);
414#endif
415 return 0;
416}
417
418static int do_fdt_overlay(void)
419{
420 unsigned long long dtbo_mem_addr = 0x0;
421 int dtbo_num = 0;
422 int i;
423 char cmd[128];
424 unsigned long long dtbo_start;
425 char *dtbo_idx = NULL;
426 char idx[32];
427
428 if (!env_get("dtbo_mem_addr")) {
429 pr_err("No valid dtbo image found\n");
430 return -1;
431 }
432
433 dtbo_mem_addr = simple_strtoul(env_get("dtbo_mem_addr"), NULL, 16);
434#ifdef CONFIG_CMD_ADTIMG
435 if (!android_dt_check_header(dtbo_mem_addr)) {
436 pr_err("Error: DTBO image header is incorrect\n");
437 return -1;
438 }
439#endif
440
441 /* android_dt_print_contents(dtbo_mem_addr); */
442 dtbo_num = fdt32_to_cpu((
443 (const struct dt_table_header *)dtbo_mem_addr)->dt_entry_count);
444 pr_info("find %d dtbos\n", dtbo_num);
445
446 dtbo_idx = env_get("androidboot.dtbo_idx");
447 if (!dtbo_idx) {
448 pr_info("No androidboot.dtbo_idx configured\n");
449 pr_info("And no dtbos will be applied\n");
450 return -1;
451 }
452 pr_info("dtbos to be applied: %s\n", dtbo_idx);
453
454 #ifndef CONFIG_CMD_ADTIMG
455 pr_info("Error: No adtimg support found\n");
456 return -1;
457 #endif
458
459 for (i = 0; i < dtbo_num; i++) {
460 memset(idx, 0x00, sizeof(idx));
461 sprintf(idx, "%d", i);
462 if (strstr(dtbo_idx, idx)) {
463 printf("Apply dtbo %d\n", i);
464 sprintf(cmd, "adtimg addr 0x%llx;adtimg get dt --index=%d dtbo_start 0x%llx",
465 dtbo_mem_addr, i, dtbo_mem_addr);
466 run_command(cmd, 0);
467 dtbo_start = simple_strtoul(
468 env_get("dtbo_start"), NULL, 16);
469
470 sprintf(cmd, "fdt apply 0x%llx", dtbo_start);
471 run_command(cmd, 0);
472 }
473 }
474
475 free((void *)dtbo_mem_addr);
476 return 0;
477}
478#endif
479
Karl Apsited52e8572015-05-21 09:52:49 -0400480/**
481 * bootm_find_images - wrapper to find and locate various images
482 * @flag: Ignored Argument
483 * @argc: command argument count
484 * @argv: command argument list
Tero Kristofbde7582020-06-12 15:41:20 +0300485 * @start: OS image start address
486 * @size: OS image size
Karl Apsited52e8572015-05-21 09:52:49 -0400487 *
488 * boot_find_images() will attempt to load an available ramdisk,
489 * flattened device tree, as well as specifically marked
490 * "loadable" images (loadables are FIT only)
491 *
492 * Note: bootm_find_images will skip an image if it is not found
493 *
494 * @return:
495 * 0, if all existing images were loaded correctly
496 * 1, if an image is found but corrupted, or invalid
497 */
Tero Kristofbde7582020-06-12 15:41:20 +0300498int bootm_find_images(int flag, int argc, char *const argv[], ulong start,
499 ulong size)
Simon Glassb6396402014-06-12 07:24:46 -0600500{
501 int ret;
502
Bo Lv81aadc32024-02-28 20:18:44 +0800503#if defined(CONFIG_OF_LIBFDT_OVERLAY) && defined(CONFIG_AMLOGIC_MODIFY)
504 u32 fdto_totalsize = 0;
505#endif
506
Simon Glassb6396402014-06-12 07:24:46 -0600507 /* find ramdisk */
508 ret = boot_get_ramdisk(argc, argv, &images, IH_INITRD_ARCH,
509 &images.rd_start, &images.rd_end);
510 if (ret) {
511 puts("Ramdisk image is corrupt or invalid\n");
512 return 1;
513 }
514
Tero Kristofbde7582020-06-12 15:41:20 +0300515 /* check if ramdisk overlaps OS image */
516 if (images.rd_start && (((ulong)images.rd_start >= start &&
Jaehoon Chungef4f4f12020-10-21 14:17:03 +0900517 (ulong)images.rd_start < start + size) ||
518 ((ulong)images.rd_end > start &&
519 (ulong)images.rd_end <= start + size) ||
520 ((ulong)images.rd_start < start &&
521 (ulong)images.rd_end >= start + size))) {
Tero Kristofbde7582020-06-12 15:41:20 +0300522 printf("ERROR: RD image overlaps OS image (OS=0x%lx..0x%lx)\n",
523 start, start + size);
524 return 1;
525 }
526
Simon Glass0c303f92021-09-25 19:43:21 -0600527#if CONFIG_IS_ENABLED(OF_LIBFDT)
Simon Glassb6396402014-06-12 07:24:46 -0600528 /* find flattened device tree */
529 ret = boot_get_fdt(flag, argc, argv, IH_ARCH_DEFAULT, &images,
530 &images.ft_addr, &images.ft_len);
531 if (ret) {
532 puts("Could not find a valid device tree\n");
533 return 1;
534 }
Tero Kristofbde7582020-06-12 15:41:20 +0300535
536 /* check if FDT overlaps OS image */
537 if (images.ft_addr &&
538 (((ulong)images.ft_addr >= start &&
Pali Rohár5acfdfb2022-08-27 14:48:10 +0200539 (ulong)images.ft_addr < start + size) ||
Tero Kristofbde7582020-06-12 15:41:20 +0300540 ((ulong)images.ft_addr + images.ft_len >= start &&
Pali Rohár5acfdfb2022-08-27 14:48:10 +0200541 (ulong)images.ft_addr + images.ft_len < start + size))) {
Tero Kristofbde7582020-06-12 15:41:20 +0300542 printf("ERROR: FDT image overlaps OS image (OS=0x%lx..0x%lx)\n",
543 start, start + size);
544 return 1;
545 }
546
Simon Goldschmidt596be5f2018-12-17 20:14:42 +0100547 if (CONFIG_IS_ENABLED(CMD_FDT))
548 set_working_fdt_addr(map_to_sysmem(images.ft_addr));
Bo Lv81aadc32024-02-28 20:18:44 +0800549
550#if defined(CONFIG_OF_LIBFDT_OVERLAY) && defined(CONFIG_AMLOGIC_MODIFY)
551 if (get_fdto_totalsize(&fdto_totalsize) == 0)
552 fdt_set_totalsize(images.ft_addr, fdt_get_header(images.ft_addr,
553 totalsize) + fdto_totalsize);
554 images.ft_len = fdt_get_header(images.ft_addr, totalsize);
555 do_fdt_overlay();
556#endif
Simon Glassb6396402014-06-12 07:24:46 -0600557#endif
558
Simon Glassbf371b42021-09-25 19:43:20 -0600559#if CONFIG_IS_ENABLED(FIT)
Simon Glass4ed37ab2021-09-25 07:03:20 -0600560 if (IS_ENABLED(CONFIG_FPGA)) {
561 /* find bitstreams */
562 ret = boot_get_fpga(argc, argv, &images, IH_ARCH_DEFAULT,
563 NULL, NULL);
564 if (ret) {
565 printf("FPGA image is corrupted or invalid\n");
566 return 1;
567 }
Michal Simek62afc602016-05-17 14:03:50 +0200568 }
Michal Simek62afc602016-05-17 14:03:50 +0200569
Karl Apsite84a07db2015-05-21 09:52:48 -0400570 /* find all of the loadables */
571 ret = boot_get_loadable(argc, argv, &images, IH_ARCH_DEFAULT,
572 NULL, NULL);
573 if (ret) {
574 printf("Loadable(s) is corrupt or invalid\n");
575 return 1;
576 }
Karl Apsite84a07db2015-05-21 09:52:48 -0400577#endif
578
Simon Glassb6396402014-06-12 07:24:46 -0600579 return 0;
580}
581
Simon Glass09140112020-05-10 11:40:03 -0600582static int bootm_find_other(struct cmd_tbl *cmdtp, int flag, int argc,
583 char *const argv[])
Simon Glassb6396402014-06-12 07:24:46 -0600584{
585 if (((images.os.type == IH_TYPE_KERNEL) ||
586 (images.os.type == IH_TYPE_KERNEL_NOLOAD) ||
587 (images.os.type == IH_TYPE_MULTI)) &&
588 (images.os.os == IH_OS_LINUX ||
589 images.os.os == IH_OS_VXWORKS))
Tero Kristofbde7582020-06-12 15:41:20 +0300590 return bootm_find_images(flag, argc, argv, 0, 0);
Simon Glassb6396402014-06-12 07:24:46 -0600591
592 return 0;
593}
Simon Glass40e59752014-12-02 13:17:30 -0700594#endif /* USE_HOSTC */
595
Julius Werner20908542019-07-24 19:37:54 -0700596#if !defined(USE_HOSTCC) || defined(CONFIG_FIT_SIGNATURE)
Simon Glass3086c052014-12-02 13:17:37 -0700597/**
598 * handle_decomp_error() - display a decompression error
599 *
600 * This function tries to produce a useful message. In the case where the
601 * uncompressed size is the same as the available space, we can assume that
602 * the image is too large for the buffer.
603 *
604 * @comp_type: Compression type being used (IH_COMP_...)
605 * @uncomp_size: Number of bytes uncompressed
Tom Rinic45568c2022-06-25 19:29:46 -0400606 * @buf_size: Number of bytes the decompresion buffer was
Julius Werner20908542019-07-24 19:37:54 -0700607 * @ret: errno error code received from compression library
Heinrich Schuchardt185f8122022-01-19 18:05:50 +0100608 * Return: Appropriate BOOTM_ERR_ error code
Simon Glass3086c052014-12-02 13:17:37 -0700609 */
Tom Rinic45568c2022-06-25 19:29:46 -0400610static int handle_decomp_error(int comp_type, size_t uncomp_size,
611 size_t buf_size, int ret)
Simon Glass40e59752014-12-02 13:17:30 -0700612{
Simon Glass3086c052014-12-02 13:17:37 -0700613 const char *name = genimg_get_comp_name(comp_type);
614
Julius Werner20908542019-07-24 19:37:54 -0700615 /* ENOSYS means unimplemented compression type, don't reset. */
616 if (ret == -ENOSYS)
617 return BOOTM_ERR_UNIMPLEMENTED;
618
Tom Rinic45568c2022-06-25 19:29:46 -0400619 if (uncomp_size >= buf_size)
Simon Glass3086c052014-12-02 13:17:37 -0700620 printf("Image too large: increase CONFIG_SYS_BOOTM_LEN\n");
Simon Glass40e59752014-12-02 13:17:30 -0700621 else
Simon Glass3086c052014-12-02 13:17:37 -0700622 printf("%s: uncompress error %d\n", name, ret);
623
624 /*
625 * The decompression routines are now safe, so will not write beyond
626 * their bounds. Probably it is not necessary to reset, but maintain
627 * the current behaviour for now.
628 */
629 printf("Must RESET board to recover\n");
Simon Glass40e59752014-12-02 13:17:30 -0700630#ifndef USE_HOSTCC
631 bootstage_error(BOOTSTAGE_ID_DECOMP_IMAGE);
632#endif
633
634 return BOOTM_ERR_RESET;
635}
Julius Werner20908542019-07-24 19:37:54 -0700636#endif
Simon Glass2b164f12014-06-12 07:24:52 -0600637
Simon Glassce1400f2014-06-12 07:24:53 -0600638#ifndef USE_HOSTCC
Simon Glassd9d7c202022-09-06 20:26:50 -0600639static int bootm_load_os(struct bootm_headers *images, int boot_progress)
Simon Glass2b164f12014-06-12 07:24:52 -0600640{
Simon Glassda79b2f2022-09-06 20:26:51 -0600641 struct image_info os = images->os;
Simon Glass2b164f12014-06-12 07:24:52 -0600642 ulong load = os.load;
Tom Rinicc955352018-05-01 12:32:37 -0400643 ulong load_end;
Simon Glass2b164f12014-06-12 07:24:52 -0600644 ulong blob_start = os.start;
645 ulong blob_end = os.end;
646 ulong image_start = os.image_start;
647 ulong image_len = os.image_len;
Bryan O'Donoghuebbac9222018-04-15 11:48:17 +0100648 ulong flush_start = ALIGN_DOWN(load, ARCH_DMA_MINALIGN);
Simon Glass2b164f12014-06-12 07:24:52 -0600649 bool no_overlap;
650 void *load_buf, *image_buf;
651 int err;
652
653 load_buf = map_sysmem(load, 0);
654 image_buf = map_sysmem(os.image_start, image_len);
Julius Werner20908542019-07-24 19:37:54 -0700655 err = image_decomp(os.comp, load, os.image_start, os.type,
656 load_buf, image_buf, image_len,
657 CONFIG_SYS_BOOTM_LEN, &load_end);
Simon Glass2b164f12014-06-12 07:24:52 -0600658 if (err) {
Tom Rinic45568c2022-06-25 19:29:46 -0400659 err = handle_decomp_error(os.comp, load_end - load,
660 CONFIG_SYS_BOOTM_LEN, err);
Simon Glass2b164f12014-06-12 07:24:52 -0600661 bootstage_error(BOOTSTAGE_ID_DECOMP_IMAGE);
662 return err;
663 }
Bo Lvda8d5b72023-07-31 14:58:21 +0800664
665#ifdef CONFIG_AMLOGIC_MODIFY
Bo Lv77426d62023-08-11 19:05:38 +0800666 extern uint32_t get_rsv_mem_size(void);
667 if (load_end >= IOTRACE_LOAD_ADDR && load < get_rsv_mem_size())
Bo Lvda8d5b72023-07-31 14:58:21 +0800668 printf("[Warning] kernel overlap iotrace, please reset decompress addr\n");
669#endif
670
Heinrich Schuchardt21d39462020-08-30 11:34:12 +0200671 /* We need the decompressed image size in the next steps */
672 images->os.image_len = load_end - load;
Bryan O'Donoghuebbac9222018-04-15 11:48:17 +0100673
Trent Piephob4353b32019-03-27 23:50:09 +0000674 flush_cache(flush_start, ALIGN(load_end, ARCH_DMA_MINALIGN) - flush_start);
Simon Glassb6396402014-06-12 07:24:46 -0600675
Bo Lv65d86792024-08-30 11:02:03 +0800676 printf(" kernel loaded at 0x%08lx, end = 0x%08lx\n", load, load_end);
Simon Glassb6396402014-06-12 07:24:46 -0600677 bootstage_mark(BOOTSTAGE_ID_KERNEL_LOADED);
678
Simon Glass2b164f12014-06-12 07:24:52 -0600679 no_overlap = (os.comp == IH_COMP_NONE && load == image_start);
680
Tom Rinicc955352018-05-01 12:32:37 -0400681 if (!no_overlap && load < blob_end && load_end > blob_start) {
Simon Glassb6396402014-06-12 07:24:46 -0600682 debug("images.os.start = 0x%lX, images.os.end = 0x%lx\n",
683 blob_start, blob_end);
684 debug("images.os.load = 0x%lx, load_end = 0x%lx\n", load,
Tom Rinicc955352018-05-01 12:32:37 -0400685 load_end);
Bo Lv4a465022023-02-28 05:51:47 +0000686#ifndef CONFIG_ANDROID_BOOT_IMAGE
Simon Glassb6396402014-06-12 07:24:46 -0600687 /* Check what type of image this is. */
688 if (images->legacy_hdr_valid) {
689 if (image_get_type(&images->legacy_hdr_os_copy)
690 == IH_TYPE_MULTI)
691 puts("WARNING: legacy format multi component image overwritten\n");
692 return BOOTM_ERR_OVERLAP;
693 } else {
694 puts("ERROR: new format image overwritten - must RESET the board to recover\n");
695 bootstage_error(BOOTSTAGE_ID_OVERWRITTEN);
696 return BOOTM_ERR_RESET;
697 }
Bo Lv4a465022023-02-28 05:51:47 +0000698#endif
Simon Glassb6396402014-06-12 07:24:46 -0600699 }
700
Tom Rinicc955352018-05-01 12:32:37 -0400701 lmb_reserve(&images->lmb, images->os.load, (load_end -
702 images->os.load));
Simon Glassb6396402014-06-12 07:24:46 -0600703 return 0;
704}
705
706/**
707 * bootm_disable_interrupts() - Disable interrupts in preparation for load/boot
708 *
Heinrich Schuchardt185f8122022-01-19 18:05:50 +0100709 * Return: interrupt flag (0 if interrupts were disabled, non-zero if they were
Simon Glassb6396402014-06-12 07:24:46 -0600710 * enabled)
711 */
712ulong bootm_disable_interrupts(void)
713{
714 ulong iflag;
715
716 /*
717 * We have reached the point of no return: we are going to
718 * overwrite all exception vector code, so we cannot easily
719 * recover from any failures any more...
720 */
721 iflag = disable_interrupts();
722#ifdef CONFIG_NETCONSOLE
723 /* Stop the ethernet stack if NetConsole could have left it up */
724 eth_halt();
Bernhard Nortmann4917c062015-09-14 15:29:45 +0200725# ifndef CONFIG_DM_ETH
Simon Glassb6396402014-06-12 07:24:46 -0600726 eth_unregister(eth_get_dev());
Bernhard Nortmann4917c062015-09-14 15:29:45 +0200727# endif
Simon Glassb6396402014-06-12 07:24:46 -0600728#endif
729
730#if defined(CONFIG_CMD_USB)
731 /*
732 * turn off USB to prevent the host controller from writing to the
733 * SDRAM while Linux is booting. This could happen (at least for OHCI
734 * controller), because the HCCA (Host Controller Communication Area)
735 * lies within the SDRAM and the host controller writes continously to
736 * this area (as busmaster!). The HccaFrameNumber is for example
737 * updated every 1 ms within the HCCA structure in SDRAM! For more
738 * details see the OpenHCI specification.
739 */
740 usb_stop();
741#endif
742 return iflag;
743}
744
Simon Glass6cd92b12020-11-05 10:33:42 -0700745#define CONSOLE_ARG "console="
Sean Andersonba9aa402022-05-19 18:26:05 -0400746#define NULL_CONSOLE (CONSOLE_ARG "ttynull")
747#define CONSOLE_ARG_SIZE sizeof(NULL_CONSOLE)
Simon Glassb6396402014-06-12 07:24:46 -0600748
Simon Glassb6386f32020-11-05 10:33:43 -0700749/**
750 * fixup_silent_linux() - Handle silencing the linux boot if required
751 *
752 * This uses the silent_linux envvar to control whether to add/set a "console="
753 * parameter to the command line
754 *
755 * @buf: Buffer containing the string to process
756 * @maxlen: Maximum length of buffer
Heinrich Schuchardt185f8122022-01-19 18:05:50 +0100757 * Return: 0 if OK, -ENOSPC if @maxlen is too small
Simon Glassb6386f32020-11-05 10:33:43 -0700758 */
759static int fixup_silent_linux(char *buf, int maxlen)
Simon Glassb6396402014-06-12 07:24:46 -0600760{
Simon Glassb6396402014-06-12 07:24:46 -0600761 int want_silent;
Simon Glassb6386f32020-11-05 10:33:43 -0700762 char *cmdline;
763 int size;
Simon Glassb6396402014-06-12 07:24:46 -0600764
Simon Glassb6386f32020-11-05 10:33:43 -0700765 /*
766 * Move the input string to the end of buffer. The output string will be
767 * built up at the start.
768 */
769 size = strlen(buf) + 1;
770 if (size * 2 > maxlen)
771 return -ENOSPC;
772 cmdline = buf + maxlen - size;
773 memmove(cmdline, buf, size);
Simon Glassb6396402014-06-12 07:24:46 -0600774 /*
775 * Only fix cmdline when requested. The environment variable can be:
776 *
777 * no - we never fixup
778 * yes - we always fixup
779 * unset - we rely on the console silent flag
780 */
Simon Glassbfebc8c2017-08-03 12:22:13 -0600781 want_silent = env_get_yesno("silent_linux");
Simon Glassb6396402014-06-12 07:24:46 -0600782 if (want_silent == 0)
Simon Glass4ae42642020-11-05 10:33:39 -0700783 return 0;
Simon Glassb6396402014-06-12 07:24:46 -0600784 else if (want_silent == -1 && !(gd->flags & GD_FLG_SILENT))
Simon Glass4ae42642020-11-05 10:33:39 -0700785 return 0;
Simon Glassb6396402014-06-12 07:24:46 -0600786
787 debug("before silent fix-up: %s\n", cmdline);
Simon Glassb6386f32020-11-05 10:33:43 -0700788 if (*cmdline) {
Simon Glassb6396402014-06-12 07:24:46 -0600789 char *start = strstr(cmdline, CONSOLE_ARG);
790
Simon Glassb6386f32020-11-05 10:33:43 -0700791 /* Check space for maximum possible new command line */
792 if (size + CONSOLE_ARG_SIZE > maxlen)
Simon Glass4ae42642020-11-05 10:33:39 -0700793 return -ENOSPC;
Simon Glassb6396402014-06-12 07:24:46 -0600794
795 if (start) {
796 char *end = strchr(start, ' ');
Simon Glass6cd92b12020-11-05 10:33:42 -0700797 int start_bytes;
Simon Glassb6396402014-06-12 07:24:46 -0600798
Sean Andersonba9aa402022-05-19 18:26:05 -0400799 start_bytes = start - cmdline;
Simon Glass6cd92b12020-11-05 10:33:42 -0700800 strncpy(buf, cmdline, start_bytes);
Sean Andersonba9aa402022-05-19 18:26:05 -0400801 strncpy(buf + start_bytes, NULL_CONSOLE, CONSOLE_ARG_SIZE);
Simon Glassb6396402014-06-12 07:24:46 -0600802 if (end)
Sean Andersonba9aa402022-05-19 18:26:05 -0400803 strcpy(buf + start_bytes + CONSOLE_ARG_SIZE - 1, end);
Simon Glassb6396402014-06-12 07:24:46 -0600804 else
Sean Andersonba9aa402022-05-19 18:26:05 -0400805 buf[start_bytes + CONSOLE_ARG_SIZE] = '\0';
Simon Glassb6396402014-06-12 07:24:46 -0600806 } else {
Sean Andersonba9aa402022-05-19 18:26:05 -0400807 sprintf(buf, "%s %s", cmdline, NULL_CONSOLE);
Simon Glassb6396402014-06-12 07:24:46 -0600808 }
Simon Glassb6386f32020-11-05 10:33:43 -0700809 if (buf + strlen(buf) >= cmdline)
810 return -ENOSPC;
Simon Glassb6396402014-06-12 07:24:46 -0600811 } else {
Sean Andersonba9aa402022-05-19 18:26:05 -0400812 if (maxlen < CONSOLE_ARG_SIZE)
Simon Glassb6386f32020-11-05 10:33:43 -0700813 return -ENOSPC;
Sean Andersonba9aa402022-05-19 18:26:05 -0400814 strcpy(buf, NULL_CONSOLE);
Simon Glassb6396402014-06-12 07:24:46 -0600815 }
Simon Glassb6386f32020-11-05 10:33:43 -0700816 debug("after silent fix-up: %s\n", buf);
Simon Glassb6396402014-06-12 07:24:46 -0600817
Simon Glassb6386f32020-11-05 10:33:43 -0700818 return 0;
819}
820
Simon Glass51bb3382020-11-05 10:33:48 -0700821/**
822 * process_subst() - Handle substitution of ${...} fields in the environment
823 *
824 * Handle variable substitution in the provided buffer
825 *
826 * @buf: Buffer containing the string to process
827 * @maxlen: Maximum length of buffer
Heinrich Schuchardt185f8122022-01-19 18:05:50 +0100828 * Return: 0 if OK, -ENOSPC if @maxlen is too small
Simon Glass51bb3382020-11-05 10:33:48 -0700829 */
830static int process_subst(char *buf, int maxlen)
831{
832 char *cmdline;
833 int size;
834 int ret;
835
836 /* Move to end of buffer */
837 size = strlen(buf) + 1;
838 cmdline = buf + maxlen - size;
839 if (buf + size > cmdline)
840 return -ENOSPC;
841 memmove(cmdline, buf, size);
842
843 ret = cli_simple_process_macros(cmdline, buf, cmdline - buf);
844
845 return ret;
846}
847
Simon Glass4448fe82020-11-05 10:33:45 -0700848int bootm_process_cmdline(char *buf, int maxlen, int flags)
849{
850 int ret;
851
852 /* Check config first to enable compiler to eliminate code */
853 if (IS_ENABLED(CONFIG_SILENT_CONSOLE) &&
854 !IS_ENABLED(CONFIG_SILENT_U_BOOT_ONLY) &&
Bo Lvaa183f82023-07-29 13:30:00 +0800855 (flags & BOOTM_CL_SILENT) &&
856 !IS_ENABLED(CONFIG_AMLOGIC_MODIFY)) {
Simon Glass4448fe82020-11-05 10:33:45 -0700857 ret = fixup_silent_linux(buf, maxlen);
858 if (ret)
859 return log_msg_ret("silent", ret);
860 }
Simon Glassa8d69622021-03-15 18:11:23 +1300861 if (IS_ENABLED(CONFIG_BOOTARGS_SUBST) && IS_ENABLED(CONFIG_CMDLINE) &&
862 (flags & BOOTM_CL_SUBST)) {
Simon Glass51bb3382020-11-05 10:33:48 -0700863 ret = process_subst(buf, maxlen);
864 if (ret)
Simon Glass185756e2021-02-06 09:57:35 -0700865 return log_msg_ret("subst", ret);
Simon Glass51bb3382020-11-05 10:33:48 -0700866 }
Simon Glass4448fe82020-11-05 10:33:45 -0700867
868 return 0;
869}
870
Simon Glassb3c01672020-11-05 10:33:44 -0700871int bootm_process_cmdline_env(int flags)
Simon Glassb6386f32020-11-05 10:33:43 -0700872{
873 const int maxlen = MAX_CMDLINE_SIZE;
Simon Glassb3c01672020-11-05 10:33:44 -0700874 bool do_silent;
Simon Glassb6386f32020-11-05 10:33:43 -0700875 const char *env;
876 char *buf;
877 int ret;
878
879 /* First check if any action is needed */
880 do_silent = IS_ENABLED(CONFIG_SILENT_CONSOLE) &&
Simon Glassb3c01672020-11-05 10:33:44 -0700881 !IS_ENABLED(CONFIG_SILENT_U_BOOT_ONLY) && (flags & BOOTM_CL_SILENT);
Simon Glass51bb3382020-11-05 10:33:48 -0700882 if (!do_silent && !IS_ENABLED(CONFIG_BOOTARGS_SUBST))
Simon Glassb6386f32020-11-05 10:33:43 -0700883 return 0;
884
885 env = env_get("bootargs");
886 if (env && strlen(env) >= maxlen)
887 return -E2BIG;
888 buf = malloc(maxlen);
889 if (!buf)
890 return -ENOMEM;
891 if (env)
892 strcpy(buf, env);
893 else
894 *buf = '\0';
Simon Glass4448fe82020-11-05 10:33:45 -0700895 ret = bootm_process_cmdline(buf, maxlen, flags);
Simon Glassb6386f32020-11-05 10:33:43 -0700896 if (!ret) {
897 ret = env_set("bootargs", buf);
898
899 /*
900 * If buf is "" and bootargs does not exist, this will produce
901 * an error trying to delete bootargs. Ignore it
902 */
903 if (ret == -ENOENT)
904 ret = 0;
905 }
Simon Glassb6396402014-06-12 07:24:46 -0600906 free(buf);
Simon Glassb6386f32020-11-05 10:33:43 -0700907 if (ret)
908 return log_msg_ret("env", ret);
Simon Glass4ae42642020-11-05 10:33:39 -0700909
910 return 0;
Simon Glassb6396402014-06-12 07:24:46 -0600911}
Simon Glassb6396402014-06-12 07:24:46 -0600912
913/**
914 * Execute selected states of the bootm command.
915 *
916 * Note the arguments to this state must be the first argument, Any 'bootm'
917 * or sub-command arguments must have already been taken.
918 *
919 * Note that if states contains more than one flag it MUST contain
920 * BOOTM_STATE_START, since this handles and consumes the command line args.
921 *
922 * Also note that aside from boot_os_fn functions and bootm_load_os no other
923 * functions we store the return value of in 'ret' may use a negative return
924 * value, without special handling.
925 *
926 * @param cmdtp Pointer to bootm command table entry
927 * @param flag Command flags (CMD_FLAG_...)
928 * @param argc Number of subcommand arguments (0 = no arguments)
929 * @param argv Arguments
930 * @param states Mask containing states to run (BOOTM_STATE_...)
931 * @param images Image header information
932 * @param boot_progress 1 to show boot progress, 0 to not do this
Heinrich Schuchardt185f8122022-01-19 18:05:50 +0100933 * Return: 0 if ok, something else on error. Some errors will cause this
Simon Glassb6396402014-06-12 07:24:46 -0600934 * function to perform a reboot! If states contains BOOTM_STATE_OS_GO
935 * then the intent is to boot an OS, so this function will not return
936 * unless the image type is standalone.
937 */
Simon Glass09140112020-05-10 11:40:03 -0600938int do_bootm_states(struct cmd_tbl *cmdtp, int flag, int argc,
Simon Glassd9d7c202022-09-06 20:26:50 -0600939 char *const argv[], int states, struct bootm_headers *images,
Simon Glass09140112020-05-10 11:40:03 -0600940 int boot_progress)
Simon Glassb6396402014-06-12 07:24:46 -0600941{
942 boot_os_fn *boot_fn;
943 ulong iflag = 0;
944 int ret = 0, need_boot_fn;
945
946 images->state |= states;
947
948 /*
949 * Work through the states and see how far we get. We stop on
950 * any error.
951 */
952 if (states & BOOTM_STATE_START)
953 ret = bootm_start(cmdtp, flag, argc, argv);
954
Philippe Reynes9d46e632022-03-28 22:57:00 +0200955 if (!ret && (states & BOOTM_STATE_PRE_LOAD))
956 ret = bootm_pre_load(cmdtp, flag, argc, argv);
957
Simon Glassb6396402014-06-12 07:24:46 -0600958 if (!ret && (states & BOOTM_STATE_FINDOS))
959 ret = bootm_find_os(cmdtp, flag, argc, argv);
960
Zubair Lutfullah Kakakhelba079842016-09-09 09:18:58 +0100961 if (!ret && (states & BOOTM_STATE_FINDOTHER))
Simon Glassb6396402014-06-12 07:24:46 -0600962 ret = bootm_find_other(cmdtp, flag, argc, argv);
Simon Glassb6396402014-06-12 07:24:46 -0600963
dongqing.li994a05e2023-10-17 09:19:27 +0800964#if defined(CONFIG_MDUMP_COMPRESS) || \
965 ((defined CONFIG_SUPPORT_BL33Z) && \
966 (defined CONFIG_FULL_RAMDUMP))
967 extern void check_ramdump(void);
968 check_ramdump();
969#endif
970
Simon Glassb6396402014-06-12 07:24:46 -0600971 /* Load the OS */
972 if (!ret && (states & BOOTM_STATE_LOADOS)) {
Simon Glassb6396402014-06-12 07:24:46 -0600973 iflag = bootm_disable_interrupts();
Tom Rinicc955352018-05-01 12:32:37 -0400974 ret = bootm_load_os(images, 0);
975 if (ret && ret != BOOTM_ERR_OVERLAP)
Simon Glassb6396402014-06-12 07:24:46 -0600976 goto err;
977 else if (ret == BOOTM_ERR_OVERLAP)
978 ret = 0;
Simon Glassb6396402014-06-12 07:24:46 -0600979 }
980
981 /* Relocate the ramdisk */
982#ifdef CONFIG_SYS_BOOT_RAMDISK_HIGH
983 if (!ret && (states & BOOTM_STATE_RAMDISK)) {
984 ulong rd_len = images->rd_end - images->rd_start;
985
986 ret = boot_ramdisk_high(&images->lmb, images->rd_start,
987 rd_len, &images->initrd_start, &images->initrd_end);
988 if (!ret) {
Simon Glass018f5302017-08-03 12:22:10 -0600989 env_set_hex("initrd_start", images->initrd_start);
990 env_set_hex("initrd_end", images->initrd_end);
Simon Glassb6396402014-06-12 07:24:46 -0600991 }
992 }
993#endif
Simon Glass0c303f92021-09-25 19:43:21 -0600994#if CONFIG_IS_ENABLED(OF_LIBFDT) && defined(CONFIG_LMB)
Simon Glassb6396402014-06-12 07:24:46 -0600995 if (!ret && (states & BOOTM_STATE_FDT)) {
996 boot_fdt_add_mem_rsv_regions(&images->lmb, images->ft_addr);
997 ret = boot_relocate_fdt(&images->lmb, &images->ft_addr,
998 &images->ft_len);
999 }
1000#endif
1001
Hangyu Lif6740182023-03-27 15:45:23 +08001002#ifdef CONFIG_AMLOGIC_MODIFY
1003 /* Check reserved memory region */
1004#ifdef CONFIG_CMD_RSVMEM
1005 ret = run_command("rsvmem check", 0);
1006 if (ret) {
1007 puts("rsvmem check failed\n");
1008 return ret;
1009 }
1010#endif
Yan Wangd7a42e72024-07-04 14:32:25 +08001011
1012 /* memtag region protect */
1013#ifdef CONFIG_CMD_MEMTAG
1014 run_command("memtag check", 0);
1015#endif
Hangyu Lif6740182023-03-27 15:45:23 +08001016#endif
1017
Simon Glassb6396402014-06-12 07:24:46 -06001018 /* From now on, we need the OS boot function */
1019 if (ret)
1020 return ret;
1021 boot_fn = bootm_os_get_boot_func(images->os.os);
1022 need_boot_fn = states & (BOOTM_STATE_OS_CMDLINE |
1023 BOOTM_STATE_OS_BD_T | BOOTM_STATE_OS_PREP |
1024 BOOTM_STATE_OS_FAKE_GO | BOOTM_STATE_OS_GO);
1025 if (boot_fn == NULL && need_boot_fn) {
1026 if (iflag)
1027 enable_interrupts();
1028 printf("ERROR: booting os '%s' (%d) is not supported\n",
1029 genimg_get_os_name(images->os.os), images->os.os);
1030 bootstage_error(BOOTSTAGE_ID_CHECK_BOOT_OS);
1031 return 1;
1032 }
1033
Hector Palacios19e86492016-07-11 12:34:37 +02001034
Simon Glassb6396402014-06-12 07:24:46 -06001035 /* Call various other states that are not generally used */
1036 if (!ret && (states & BOOTM_STATE_OS_CMDLINE))
1037 ret = boot_fn(BOOTM_STATE_OS_CMDLINE, argc, argv, images);
1038 if (!ret && (states & BOOTM_STATE_OS_BD_T))
1039 ret = boot_fn(BOOTM_STATE_OS_BD_T, argc, argv, images);
Hector Palacios19e86492016-07-11 12:34:37 +02001040 if (!ret && (states & BOOTM_STATE_OS_PREP)) {
Simon Glass51bb3382020-11-05 10:33:48 -07001041 ret = bootm_process_cmdline_env(images->os.os == IH_OS_LINUX);
Simon Glassd9477a02020-11-05 10:33:41 -07001042 if (ret) {
1043 printf("Cmdline setup failed (err=%d)\n", ret);
1044 ret = CMD_RET_FAILURE;
1045 goto err;
Simon Glass4ae42642020-11-05 10:33:39 -07001046 }
Simon Glassb6396402014-06-12 07:24:46 -06001047 ret = boot_fn(BOOTM_STATE_OS_PREP, argc, argv, images);
Hector Palacios19e86492016-07-11 12:34:37 +02001048 }
Simon Glassb6396402014-06-12 07:24:46 -06001049
1050#ifdef CONFIG_TRACE
1051 /* Pretend to run the OS, then run a user command */
1052 if (!ret && (states & BOOTM_STATE_OS_FAKE_GO)) {
Simon Glass00caae62017-08-03 12:22:12 -06001053 char *cmd_list = env_get("fakegocmd");
Simon Glassb6396402014-06-12 07:24:46 -06001054
1055 ret = boot_selected_os(argc, argv, BOOTM_STATE_OS_FAKE_GO,
1056 images, boot_fn);
1057 if (!ret && cmd_list)
1058 ret = run_command_list(cmd_list, -1, flag);
1059 }
1060#endif
1061
1062 /* Check for unsupported subcommand. */
1063 if (ret) {
Simon Glass13819f02022-10-11 09:47:07 -06001064 printf("subcommand failed (err=%d)\n", ret);
Simon Glassb6396402014-06-12 07:24:46 -06001065 return ret;
1066 }
1067
1068 /* Now run the OS! We hope this doesn't return */
1069 if (!ret && (states & BOOTM_STATE_OS_GO))
1070 ret = boot_selected_os(argc, argv, BOOTM_STATE_OS_GO,
1071 images, boot_fn);
1072
1073 /* Deal with any fallout */
1074err:
1075 if (iflag)
1076 enable_interrupts();
1077
1078 if (ret == BOOTM_ERR_UNIMPLEMENTED)
1079 bootstage_error(BOOTSTAGE_ID_DECOMP_UNIMPL);
1080 else if (ret == BOOTM_ERR_RESET)
1081 do_reset(cmdtp, flag, argc, argv);
1082
1083 return ret;
1084}
1085
Tom Rinic76c93a2019-05-23 07:14:07 -04001086#if CONFIG_IS_ENABLED(LEGACY_IMAGE_FORMAT)
Simon Glassb6396402014-06-12 07:24:46 -06001087/**
1088 * image_get_kernel - verify legacy format kernel image
1089 * @img_addr: in RAM address of the legacy format image to be verified
1090 * @verify: data CRC verification flag
1091 *
1092 * image_get_kernel() verifies legacy image integrity and returns pointer to
1093 * legacy image header if image verification was completed successfully.
1094 *
1095 * returns:
1096 * pointer to a legacy image header if valid image was found
1097 * otherwise return NULL
1098 */
Simon Glassf3543e62022-09-06 20:26:52 -06001099static struct legacy_img_hdr *image_get_kernel(ulong img_addr, int verify)
Simon Glassb6396402014-06-12 07:24:46 -06001100{
Simon Glassf3543e62022-09-06 20:26:52 -06001101 struct legacy_img_hdr *hdr = (struct legacy_img_hdr *)img_addr;
Simon Glassb6396402014-06-12 07:24:46 -06001102
1103 if (!image_check_magic(hdr)) {
1104 puts("Bad Magic Number\n");
1105 bootstage_error(BOOTSTAGE_ID_CHECK_MAGIC);
1106 return NULL;
1107 }
1108 bootstage_mark(BOOTSTAGE_ID_CHECK_HEADER);
1109
1110 if (!image_check_hcrc(hdr)) {
1111 puts("Bad Header Checksum\n");
1112 bootstage_error(BOOTSTAGE_ID_CHECK_HEADER);
1113 return NULL;
1114 }
1115
1116 bootstage_mark(BOOTSTAGE_ID_CHECK_CHECKSUM);
1117 image_print_contents(hdr);
1118
1119 if (verify) {
1120 puts(" Verifying Checksum ... ");
1121 if (!image_check_dcrc(hdr)) {
1122 printf("Bad Data CRC\n");
1123 bootstage_error(BOOTSTAGE_ID_CHECK_CHECKSUM);
1124 return NULL;
1125 }
1126 puts("OK\n");
1127 }
1128 bootstage_mark(BOOTSTAGE_ID_CHECK_ARCH);
1129
1130 if (!image_check_target_arch(hdr)) {
1131 printf("Unsupported Architecture 0x%x\n", image_get_arch(hdr));
1132 bootstage_error(BOOTSTAGE_ID_CHECK_ARCH);
1133 return NULL;
1134 }
1135 return hdr;
1136}
1137#endif
1138
1139/**
1140 * boot_get_kernel - find kernel image
1141 * @os_data: pointer to a ulong variable, will hold os data start address
1142 * @os_len: pointer to a ulong variable, will hold os data length
1143 *
1144 * boot_get_kernel() tries to find a kernel image, verifies its integrity
1145 * and locates kernel data.
1146 *
1147 * returns:
1148 * pointer to image header if valid image was found, plus kernel start
1149 * address and length, otherwise NULL
1150 */
Simon Glass09140112020-05-10 11:40:03 -06001151static const void *boot_get_kernel(struct cmd_tbl *cmdtp, int flag, int argc,
Simon Glassd9d7c202022-09-06 20:26:50 -06001152 char *const argv[], struct bootm_headers *images,
Simon Glassb6396402014-06-12 07:24:46 -06001153 ulong *os_data, ulong *os_len)
1154{
Tom Rinic76c93a2019-05-23 07:14:07 -04001155#if CONFIG_IS_ENABLED(LEGACY_IMAGE_FORMAT)
Simon Glassf3543e62022-09-06 20:26:52 -06001156 struct legacy_img_hdr *hdr;
Simon Glassb6396402014-06-12 07:24:46 -06001157#endif
1158 ulong img_addr;
1159 const void *buf;
Simon Glassb6396402014-06-12 07:24:46 -06001160 const char *fit_uname_config = NULL;
1161 const char *fit_uname_kernel = NULL;
Simon Glassbf371b42021-09-25 19:43:20 -06001162#if CONFIG_IS_ENABLED(FIT)
Simon Glassb6396402014-06-12 07:24:46 -06001163 int os_noffset;
1164#endif
1165
Bo Lv4a465022023-02-28 05:51:47 +00001166#ifdef CONFIG_AMLOGIC_MODIFY
Xindong Xuac88caf2024-10-28 17:10:12 +08001167#ifndef CONFIG_AVB2
Bo Lv4a465022023-02-28 05:51:47 +00001168#ifdef CONFIG_AML_ANTIROLLBACK
1169 boot_img_hdr_t **tmp_img_hdr = (boot_img_hdr_t **)&buf;
1170#endif
Xindong Xuac88caf2024-10-28 17:10:12 +08001171#endif
1172
Bo Lv4a465022023-02-28 05:51:47 +00001173#endif
1174
Bryan Wue6c88a62014-08-15 16:51:39 -07001175 img_addr = genimg_get_kernel_addr_fit(argc < 1 ? NULL : argv[0],
1176 &fit_uname_config,
1177 &fit_uname_kernel);
Simon Glassb6396402014-06-12 07:24:46 -06001178
Philippe Reynes9d46e632022-03-28 22:57:00 +02001179 if (CONFIG_IS_ENABLED(CMD_BOOTM_PRE_LOAD))
1180 img_addr += image_load_offset;
1181
Simon Glassb6396402014-06-12 07:24:46 -06001182 bootstage_mark(BOOTSTAGE_ID_CHECK_MAGIC);
1183
Simon Glassb6396402014-06-12 07:24:46 -06001184 /* check image type, for FIT images get FIT kernel node */
1185 *os_data = *os_len = 0;
1186 buf = map_sysmem(img_addr, 0);
1187 switch (genimg_get_format(buf)) {
Tom Rinic76c93a2019-05-23 07:14:07 -04001188#if CONFIG_IS_ENABLED(LEGACY_IMAGE_FORMAT)
Simon Glassb6396402014-06-12 07:24:46 -06001189 case IMAGE_FORMAT_LEGACY:
1190 printf("## Booting kernel from Legacy Image at %08lx ...\n",
1191 img_addr);
1192 hdr = image_get_kernel(img_addr, images->verify);
1193 if (!hdr)
1194 return NULL;
1195 bootstage_mark(BOOTSTAGE_ID_CHECK_IMAGETYPE);
1196
1197 /* get os_data and os_len */
1198 switch (image_get_type(hdr)) {
1199 case IH_TYPE_KERNEL:
1200 case IH_TYPE_KERNEL_NOLOAD:
1201 *os_data = image_get_data(hdr);
1202 *os_len = image_get_data_size(hdr);
1203 break;
1204 case IH_TYPE_MULTI:
1205 image_multi_getimg(hdr, 0, os_data, os_len);
1206 break;
1207 case IH_TYPE_STANDALONE:
1208 *os_data = image_get_data(hdr);
1209 *os_len = image_get_data_size(hdr);
1210 break;
1211 default:
1212 printf("Wrong Image Type for %s command\n",
1213 cmdtp->name);
1214 bootstage_error(BOOTSTAGE_ID_CHECK_IMAGETYPE);
1215 return NULL;
1216 }
1217
1218 /*
1219 * copy image header to allow for image overwrites during
1220 * kernel decompression.
1221 */
1222 memmove(&images->legacy_hdr_os_copy, hdr,
Simon Glassf3543e62022-09-06 20:26:52 -06001223 sizeof(struct legacy_img_hdr));
Simon Glassb6396402014-06-12 07:24:46 -06001224
1225 /* save pointer to image header */
1226 images->legacy_hdr_os = hdr;
1227
1228 images->legacy_hdr_valid = 1;
1229 bootstage_mark(BOOTSTAGE_ID_DECOMP_IMAGE);
1230 break;
1231#endif
Simon Glassbf371b42021-09-25 19:43:20 -06001232#if CONFIG_IS_ENABLED(FIT)
Simon Glassb6396402014-06-12 07:24:46 -06001233 case IMAGE_FORMAT_FIT:
Simon Glass126cc862014-06-12 07:24:47 -06001234 os_noffset = fit_image_load(images, img_addr,
Simon Glassb6396402014-06-12 07:24:46 -06001235 &fit_uname_kernel, &fit_uname_config,
1236 IH_ARCH_DEFAULT, IH_TYPE_KERNEL,
1237 BOOTSTAGE_ID_FIT_KERNEL_START,
1238 FIT_LOAD_IGNORED, os_data, os_len);
1239 if (os_noffset < 0)
1240 return NULL;
1241
1242 images->fit_hdr_os = map_sysmem(img_addr, 0);
1243 images->fit_uname_os = fit_uname_kernel;
1244 images->fit_uname_cfg = fit_uname_config;
1245 images->fit_noffset_os = os_noffset;
1246 break;
1247#endif
1248#ifdef CONFIG_ANDROID_BOOT_IMAGE
1249 case IMAGE_FORMAT_ANDROID:
1250 printf("## Booting Android Image at 0x%08lx ...\n", img_addr);
Bo Lv4a465022023-02-28 05:51:47 +00001251
1252#ifndef CONFIG_AMLOGIC_MODIFY
Simon Glass07c0cd72014-06-12 07:24:48 -06001253 if (android_image_get_kernel(buf, images->verify,
Simon Glassb6396402014-06-12 07:24:46 -06001254 os_data, os_len))
1255 return NULL;
Bo Lv4a465022023-02-28 05:51:47 +00001256#else
1257 if (!android_image_need_move(&img_addr, buf))
1258 buf = map_sysmem(img_addr, 0);
1259 else
1260 return NULL;
1261 if (android_image_get_kernel(buf, images->verify,
1262 os_data, os_len))
1263 return NULL;
1264
Xindong Xuac88caf2024-10-28 17:10:12 +08001265#ifndef CONFIG_AVB2
Bo Lv4a465022023-02-28 05:51:47 +00001266#ifdef CONFIG_AML_ANTIROLLBACK
1267 if (!check_antirollback((*tmp_img_hdr)->kernel_version)) {
1268 *os_len = 0;
1269 return NULL;
1270 }
1271#endif
Xindong Xuac88caf2024-10-28 17:10:12 +08001272#endif
Bo Lv4a465022023-02-28 05:51:47 +00001273#endif
Simon Glassb6396402014-06-12 07:24:46 -06001274 break;
1275#endif
1276 default:
1277 printf("Wrong Image Format for %s command\n", cmdtp->name);
1278 bootstage_error(BOOTSTAGE_ID_FIT_KERNEL_INFO);
1279 return NULL;
1280 }
1281
1282 debug(" kernel data at 0x%08lx, len = 0x%08lx (%ld)\n",
1283 *os_data, *os_len, *os_len);
1284
1285 return buf;
1286}
Heinrich Schuchardtf6c6df72019-01-08 18:13:06 +01001287
1288/**
1289 * switch_to_non_secure_mode() - switch to non-secure mode
1290 *
1291 * This routine is overridden by architectures requiring this feature.
1292 */
1293void __weak switch_to_non_secure_mode(void)
1294{
1295}
1296
Simon Glassce1400f2014-06-12 07:24:53 -06001297#else /* USE_HOSTCC */
1298
Fabrice Fontaine93e07882019-05-03 22:37:05 +02001299#if defined(CONFIG_FIT_SIGNATURE)
Simon Glass8a9d0372020-03-18 11:44:02 -06001300static int bootm_host_load_image(const void *fit, int req_image_type,
1301 int cfg_noffset)
Simon Glassce1400f2014-06-12 07:24:53 -06001302{
1303 const char *fit_uname_config = NULL;
1304 ulong data, len;
Simon Glassd9d7c202022-09-06 20:26:50 -06001305 struct bootm_headers images;
Simon Glassce1400f2014-06-12 07:24:53 -06001306 int noffset;
Tom Rinic45568c2022-06-25 19:29:46 -04001307 ulong load_end, buf_size;
Simon Glassce1400f2014-06-12 07:24:53 -06001308 uint8_t image_type;
Daniel Golle0cd57f22022-08-27 04:14:42 +01001309 uint8_t image_comp;
Simon Glassce1400f2014-06-12 07:24:53 -06001310 void *load_buf;
1311 int ret;
1312
Simon Glass8a9d0372020-03-18 11:44:02 -06001313 fit_uname_config = fdt_get_name(fit, cfg_noffset, NULL);
Simon Glassce1400f2014-06-12 07:24:53 -06001314 memset(&images, '\0', sizeof(images));
1315 images.verify = 1;
1316 noffset = fit_image_load(&images, (ulong)fit,
1317 NULL, &fit_uname_config,
1318 IH_ARCH_DEFAULT, req_image_type, -1,
1319 FIT_LOAD_IGNORED, &data, &len);
1320 if (noffset < 0)
1321 return noffset;
1322 if (fit_image_get_type(fit, noffset, &image_type)) {
1323 puts("Can't get image type!\n");
1324 return -EINVAL;
1325 }
1326
Daniel Golle88de6c52022-08-27 04:17:28 +01001327 if (fit_image_get_comp(fit, noffset, &image_comp))
1328 image_comp = IH_COMP_NONE;
Simon Glassce1400f2014-06-12 07:24:53 -06001329
1330 /* Allow the image to expand by a factor of 4, should be safe */
Tom Rinic45568c2022-06-25 19:29:46 -04001331 buf_size = (1 << 20) + len * 4;
1332 load_buf = malloc(buf_size);
Daniel Golle0cd57f22022-08-27 04:14:42 +01001333 ret = image_decomp(image_comp, 0, data, image_type, load_buf,
Tom Rinic45568c2022-06-25 19:29:46 -04001334 (void *)data, len, buf_size, &load_end);
Simon Glassce1400f2014-06-12 07:24:53 -06001335 free(load_buf);
Simon Glass081cc192014-12-02 13:17:33 -07001336
Julius Werner20908542019-07-24 19:37:54 -07001337 if (ret) {
Daniel Golle0cd57f22022-08-27 04:14:42 +01001338 ret = handle_decomp_error(image_comp, load_end - 0, buf_size, ret);
Julius Werner20908542019-07-24 19:37:54 -07001339 if (ret != BOOTM_ERR_UNIMPLEMENTED)
1340 return ret;
1341 }
Simon Glassce1400f2014-06-12 07:24:53 -06001342
1343 return 0;
1344}
1345
1346int bootm_host_load_images(const void *fit, int cfg_noffset)
1347{
1348 static uint8_t image_types[] = {
1349 IH_TYPE_KERNEL,
1350 IH_TYPE_FLATDT,
1351 IH_TYPE_RAMDISK,
1352 };
1353 int err = 0;
1354 int i;
1355
1356 for (i = 0; i < ARRAY_SIZE(image_types); i++) {
1357 int ret;
1358
Simon Glass8a9d0372020-03-18 11:44:02 -06001359 ret = bootm_host_load_image(fit, image_types[i], cfg_noffset);
Simon Glassce1400f2014-06-12 07:24:53 -06001360 if (!err && ret && ret != -ENOENT)
1361 err = ret;
1362 }
1363
1364 /* Return the first error we found */
1365 return err;
1366}
Fabrice Fontaine93e07882019-05-03 22:37:05 +02001367#endif
Simon Glassea51a622014-06-12 07:24:51 -06001368
1369#endif /* ndef USE_HOSTCC */