Tom Rini | 83d290c | 2018-05-06 17:58:06 -0400 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0+ |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 2 | /* |
| 3 | * (C) Copyright 2000-2009 |
| 4 | * Wolfgang Denk, DENX Software Engineering, wd@denx.de. |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 5 | */ |
| 6 | |
Simon Glass | ea51a62 | 2014-06-12 07:24:51 -0600 | [diff] [blame] | 7 | #ifndef USE_HOSTCC |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 8 | #include <common.h> |
Simon Glass | ea51a62 | 2014-06-12 07:24:51 -0600 | [diff] [blame] | 9 | #include <bootstage.h> |
Simon Glass | 51bb338 | 2020-11-05 10:33:48 -0700 | [diff] [blame] | 10 | #include <cli.h> |
Simon Glass | 1eb69ae | 2019-11-14 12:57:39 -0700 | [diff] [blame] | 11 | #include <cpu_func.h> |
Simon Glass | c7694dd | 2019-08-01 09:46:46 -0600 | [diff] [blame] | 12 | #include <env.h> |
Simon Glass | 90268b8 | 2014-10-19 21:11:24 -0600 | [diff] [blame] | 13 | #include <errno.h> |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 14 | #include <fdt_support.h> |
Simon Glass | 36bf446 | 2019-11-14 12:57:42 -0700 | [diff] [blame] | 15 | #include <irq_func.h> |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 16 | #include <lmb.h> |
Simon Glass | f7ae49f | 2020-05-10 11:40:05 -0600 | [diff] [blame] | 17 | #include <log.h> |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 18 | #include <malloc.h> |
Joe Hershberger | 0eb25b6 | 2015-03-22 17:08:59 -0500 | [diff] [blame] | 19 | #include <mapmem.h> |
Simon Glass | 90526e9 | 2020-05-10 11:39:56 -0600 | [diff] [blame] | 20 | #include <net.h> |
| 21 | #include <asm/cache.h> |
Simon Glass | 401d1c4 | 2020-10-30 21:38:53 -0600 | [diff] [blame] | 22 | #include <asm/global_data.h> |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 23 | #include <asm/io.h> |
Simon Glass | b6386f3 | 2020-11-05 10:33:43 -0700 | [diff] [blame] | 24 | #include <linux/sizes.h> |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 25 | #if defined(CONFIG_CMD_USB) |
| 26 | #include <usb.h> |
| 27 | #endif |
Simon Glass | ea51a62 | 2014-06-12 07:24:51 -0600 | [diff] [blame] | 28 | #else |
| 29 | #include "mkimage.h" |
| 30 | #endif |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 31 | |
Simon Glass | ea51a62 | 2014-06-12 07:24:51 -0600 | [diff] [blame] | 32 | #include <command.h> |
| 33 | #include <bootm.h> |
| 34 | #include <image.h> |
dongqing.li | 994a05e | 2023-10-17 09:19:27 +0800 | [diff] [blame] | 35 | #include <version.h> |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 36 | |
Bo Lv | 81aadc3 | 2024-02-28 20:18:44 +0800 | [diff] [blame] | 37 | #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 Kim | 545af0c | 2025-05-08 14:48:45 +0900 | [diff] [blame] | 42 | #if defined(CONFIG_S7D_ODROIDC5) |
| 43 | extern struct mmc *find_mmc_device(int dev_num); |
| 44 | extern struct blk_desc *mmc_get_blk_desc(struct mmc *mmc); |
| 45 | extern int mmc_get_env_dev(void); |
| 46 | #endif |
| 47 | |
Simon Glass | b6386f3 | 2020-11-05 10:33:43 -0700 | [diff] [blame] | 48 | #define MAX_CMDLINE_SIZE SZ_4K |
| 49 | |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 50 | #define IH_INITRD_ARCH IH_ARCH_DEFAULT |
| 51 | |
Simon Glass | ea51a62 | 2014-06-12 07:24:51 -0600 | [diff] [blame] | 52 | #ifndef USE_HOSTCC |
| 53 | |
| 54 | DECLARE_GLOBAL_DATA_PTR; |
| 55 | |
Simon Glass | d9d7c20 | 2022-09-06 20:26:50 -0600 | [diff] [blame] | 56 | struct bootm_headers images; /* pointers to os/initrd/fdt images */ |
Tom Rini | 5db2890 | 2016-08-12 08:31:15 -0400 | [diff] [blame] | 57 | |
Simon Glass | 0914011 | 2020-05-10 11:40:03 -0600 | [diff] [blame] | 58 | static const void *boot_get_kernel(struct cmd_tbl *cmdtp, int flag, int argc, |
Simon Glass | d9d7c20 | 2022-09-06 20:26:50 -0600 | [diff] [blame] | 59 | char *const argv[], struct bootm_headers *images, |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 60 | ulong *os_data, ulong *os_len); |
| 61 | |
Simon Glass | 329da48 | 2018-05-16 09:42:25 -0600 | [diff] [blame] | 62 | __weak void board_quiesce_devices(void) |
| 63 | { |
| 64 | } |
| 65 | |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 66 | #ifdef CONFIG_LMB |
Simon Glass | d9d7c20 | 2022-09-06 20:26:50 -0600 | [diff] [blame] | 67 | static void boot_start_lmb(struct bootm_headers *images) |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 68 | { |
| 69 | ulong mem_start; |
| 70 | phys_size_t mem_size; |
| 71 | |
Simon Glass | 723806c | 2017-08-03 12:22:15 -0600 | [diff] [blame] | 72 | mem_start = env_get_bootm_low(); |
| 73 | mem_size = env_get_bootm_size(); |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 74 | |
Simon Goldschmidt | 9cc2323 | 2019-01-26 22:13:04 +0100 | [diff] [blame] | 75 | lmb_init_and_reserve_range(&images->lmb, (phys_addr_t)mem_start, |
| 76 | mem_size, NULL); |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 77 | } |
| 78 | #else |
| 79 | #define lmb_reserve(lmb, base, size) |
Simon Glass | d9d7c20 | 2022-09-06 20:26:50 -0600 | [diff] [blame] | 80 | static inline void boot_start_lmb(struct bootm_headers *images) { } |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 81 | #endif |
| 82 | |
Simon Glass | 0914011 | 2020-05-10 11:40:03 -0600 | [diff] [blame] | 83 | static int bootm_start(struct cmd_tbl *cmdtp, int flag, int argc, |
| 84 | char *const argv[]) |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 85 | { |
| 86 | memset((void *)&images, 0, sizeof(images)); |
Simon Glass | bfebc8c | 2017-08-03 12:22:13 -0600 | [diff] [blame] | 87 | images.verify = env_get_yesno("verify"); |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 88 | |
| 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 Reynes | 9d46e63 | 2022-03-28 22:57:00 +0200 | [diff] [blame] | 97 | static 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 | |
| 109 | static 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 Glass | 0914011 | 2020-05-10 11:40:03 -0600 | [diff] [blame] | 124 | static int bootm_find_os(struct cmd_tbl *cmdtp, int flag, int argc, |
| 125 | char *const argv[]) |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 126 | { |
| 127 | const void *os_hdr; |
| 128 | bool ep_found = false; |
Simon Glass | 90268b8 | 2014-10-19 21:11:24 -0600 | [diff] [blame] | 129 | int ret; |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 130 | |
| 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 Rini | c76c93a | 2019-05-23 07:14:07 -0400 | [diff] [blame] | 141 | #if CONFIG_IS_ENABLED(LEGACY_IMAGE_FORMAT) |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 142 | 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 Glass | 90268b8 | 2014-10-19 21:11:24 -0600 | [diff] [blame] | 149 | images.os.arch = image_get_arch(os_hdr); |
Bo Lv | 4a46502 | 2023-02-28 05:51:47 +0000 | [diff] [blame] | 150 | #ifdef CONFIG_AMLOGIC_MODIFY |
| 151 | if (images.os.arch == IH_ARCH_ARM) { |
Bo Lv | ae6e705 | 2024-04-26 18:05:18 +0800 | [diff] [blame] | 152 | env_set("initrd_high", "0D000000"); |
| 153 | env_set("fdt_high", "0D000000"); |
Bo Lv | 4a46502 | 2023-02-28 05:51:47 +0000 | [diff] [blame] | 154 | } |
| 155 | #endif |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 156 | break; |
| 157 | #endif |
Simon Glass | bf371b4 | 2021-09-25 19:43:20 -0600 | [diff] [blame] | 158 | #if CONFIG_IS_ENABLED(FIT) |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 159 | 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 Glass | 90268b8 | 2014-10-19 21:11:24 -0600 | [diff] [blame] | 183 | 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 Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 190 | 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 Lv | 4a46502 | 2023-02-28 05:51:47 +0000 | [diff] [blame] | 202 | #ifdef CONFIG_AMLOGIC_MODIFY |
Bo Lv | cc44551 | 2024-03-21 13:48:45 +0800 | [diff] [blame] | 203 | #ifdef CONFIG_MODIFY_INITRD_HIGH |
| 204 | env_set("initrd_high", "0D000000"); |
| 205 | #endif |
Bo Lv | 4a46502 | 2023-02-28 05:51:47 +0000 | [diff] [blame] | 206 | if (image_get_magic((image_header_t *)images.os.image_start) == IH_MAGIC) { |
Bo Lv | 6a9c296 | 2024-03-27 11:23:21 +0800 | [diff] [blame] | 207 | #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 Lv | 4a46502 | 2023-02-28 05:51:47 +0000 | [diff] [blame] | 223 | #else |
| 224 | env_set("initrd_high", "0D000000"); |
Bo Lv | 4a46502 | 2023-02-28 05:51:47 +0000 | [diff] [blame] | 225 | 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 Lv | 65d8679 | 2024-08-30 11:02:03 +0800 | [diff] [blame] | 234 | images.os.comp = image_get_comp(os_hdr + sizeof(sizeof(boot_img_hdr_t))); |
Bo Lv | 4a46502 | 2023-02-28 05:51:47 +0000 | [diff] [blame] | 235 | 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 Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 248 | images.os.type = IH_TYPE_KERNEL; |
Eugeniu Rosca | 829ceb2 | 2019-04-08 17:35:27 +0200 | [diff] [blame] | 249 | images.os.comp = android_image_get_kcomp(os_hdr); |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 250 | images.os.os = IH_OS_LINUX; |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 251 | |
| 252 | images.os.end = android_image_get_end(os_hdr); |
| 253 | images.os.load = android_image_get_kload(os_hdr); |
Ahmad Draidi | 86f4695 | 2014-10-23 20:50:07 +0300 | [diff] [blame] | 254 | images.ep = images.os.load; |
| 255 | ep_found = true; |
Bo Lv | 4a46502 | 2023-02-28 05:51:47 +0000 | [diff] [blame] | 256 | #endif |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 257 | break; |
| 258 | #endif |
| 259 | default: |
| 260 | puts("ERROR: unknown image format type!\n"); |
| 261 | return 1; |
| 262 | } |
| 263 | |
Simon Glass | 90268b8 | 2014-10-19 21:11:24 -0600 | [diff] [blame] | 264 | /* If we have a valid setup.bin, we will use that for entry (x86) */ |
Simon Glass | 5bda35c | 2014-10-10 08:21:57 -0600 | [diff] [blame] | 265 | if (images.os.arch == IH_ARCH_I386 || |
| 266 | images.os.arch == IH_ARCH_X86_64) { |
Simon Glass | 90268b8 | 2014-10-19 21:11:24 -0600 | [diff] [blame] | 267 | 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 Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 276 | images.ep = image_get_ep(&images.legacy_hdr_os_copy); |
Simon Glass | bf371b4 | 2021-09-25 19:43:20 -0600 | [diff] [blame] | 277 | #if CONFIG_IS_ENABLED(FIT) |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 278 | } 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 Vasut | 487b5fa | 2018-06-13 06:13:33 +0200 | [diff] [blame] | 294 | 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 Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 311 | } |
| 312 | |
Simon Glass | 7a80de4 | 2016-02-24 09:14:42 -0700 | [diff] [blame] | 313 | images.os.start = map_to_sysmem(os_hdr); |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 314 | |
| 315 | return 0; |
| 316 | } |
| 317 | |
Bo Lv | 81aadc3 | 2024-02-28 20:18:44 +0800 | [diff] [blame] | 318 | /* |
| 319 | * load dtb overlay partition to mem |
| 320 | */ |
| 321 | #if defined(CONFIG_OF_LIBFDT_OVERLAY) && defined(CONFIG_AMLOGIC_MODIFY) |
| 322 | static 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 Kim | 545af0c | 2025-05-08 14:48:45 +0900 | [diff] [blame] | 329 | #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 Lv | 81aadc3 | 2024-02-28 20:18:44 +0800 | [diff] [blame] | 342 | |
| 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 Kim | 545af0c | 2025-05-08 14:48:45 +0900 | [diff] [blame] | 352 | #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 Lv | 81aadc3 | 2024-02-28 20:18:44 +0800 | [diff] [blame] | 360 | /* |
| 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 | |
| 400 | static 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 | |
| 418 | static 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 Apsite | d52e857 | 2015-05-21 09:52:49 -0400 | [diff] [blame] | 480 | /** |
| 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 Kristo | fbde758 | 2020-06-12 15:41:20 +0300 | [diff] [blame] | 485 | * @start: OS image start address |
| 486 | * @size: OS image size |
Karl Apsite | d52e857 | 2015-05-21 09:52:49 -0400 | [diff] [blame] | 487 | * |
| 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 Kristo | fbde758 | 2020-06-12 15:41:20 +0300 | [diff] [blame] | 498 | int bootm_find_images(int flag, int argc, char *const argv[], ulong start, |
| 499 | ulong size) |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 500 | { |
| 501 | int ret; |
| 502 | |
Bo Lv | 81aadc3 | 2024-02-28 20:18:44 +0800 | [diff] [blame] | 503 | #if defined(CONFIG_OF_LIBFDT_OVERLAY) && defined(CONFIG_AMLOGIC_MODIFY) |
| 504 | u32 fdto_totalsize = 0; |
| 505 | #endif |
| 506 | |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 507 | /* 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 Kristo | fbde758 | 2020-06-12 15:41:20 +0300 | [diff] [blame] | 515 | /* check if ramdisk overlaps OS image */ |
| 516 | if (images.rd_start && (((ulong)images.rd_start >= start && |
Jaehoon Chung | ef4f4f1 | 2020-10-21 14:17:03 +0900 | [diff] [blame] | 517 | (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 Kristo | fbde758 | 2020-06-12 15:41:20 +0300 | [diff] [blame] | 522 | printf("ERROR: RD image overlaps OS image (OS=0x%lx..0x%lx)\n", |
| 523 | start, start + size); |
| 524 | return 1; |
| 525 | } |
| 526 | |
Simon Glass | 0c303f9 | 2021-09-25 19:43:21 -0600 | [diff] [blame] | 527 | #if CONFIG_IS_ENABLED(OF_LIBFDT) |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 528 | /* 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 Kristo | fbde758 | 2020-06-12 15:41:20 +0300 | [diff] [blame] | 535 | |
| 536 | /* check if FDT overlaps OS image */ |
| 537 | if (images.ft_addr && |
| 538 | (((ulong)images.ft_addr >= start && |
Pali Rohár | 5acfdfb | 2022-08-27 14:48:10 +0200 | [diff] [blame] | 539 | (ulong)images.ft_addr < start + size) || |
Tero Kristo | fbde758 | 2020-06-12 15:41:20 +0300 | [diff] [blame] | 540 | ((ulong)images.ft_addr + images.ft_len >= start && |
Pali Rohár | 5acfdfb | 2022-08-27 14:48:10 +0200 | [diff] [blame] | 541 | (ulong)images.ft_addr + images.ft_len < start + size))) { |
Tero Kristo | fbde758 | 2020-06-12 15:41:20 +0300 | [diff] [blame] | 542 | printf("ERROR: FDT image overlaps OS image (OS=0x%lx..0x%lx)\n", |
| 543 | start, start + size); |
| 544 | return 1; |
| 545 | } |
| 546 | |
Simon Goldschmidt | 596be5f | 2018-12-17 20:14:42 +0100 | [diff] [blame] | 547 | if (CONFIG_IS_ENABLED(CMD_FDT)) |
| 548 | set_working_fdt_addr(map_to_sysmem(images.ft_addr)); |
Bo Lv | 81aadc3 | 2024-02-28 20:18:44 +0800 | [diff] [blame] | 549 | |
| 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 Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 557 | #endif |
| 558 | |
Simon Glass | bf371b4 | 2021-09-25 19:43:20 -0600 | [diff] [blame] | 559 | #if CONFIG_IS_ENABLED(FIT) |
Simon Glass | 4ed37ab | 2021-09-25 07:03:20 -0600 | [diff] [blame] | 560 | 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 Simek | 62afc60 | 2016-05-17 14:03:50 +0200 | [diff] [blame] | 568 | } |
Michal Simek | 62afc60 | 2016-05-17 14:03:50 +0200 | [diff] [blame] | 569 | |
Karl Apsite | 84a07db | 2015-05-21 09:52:48 -0400 | [diff] [blame] | 570 | /* 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 Apsite | 84a07db | 2015-05-21 09:52:48 -0400 | [diff] [blame] | 577 | #endif |
| 578 | |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 579 | return 0; |
| 580 | } |
| 581 | |
Simon Glass | 0914011 | 2020-05-10 11:40:03 -0600 | [diff] [blame] | 582 | static int bootm_find_other(struct cmd_tbl *cmdtp, int flag, int argc, |
| 583 | char *const argv[]) |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 584 | { |
| 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 Kristo | fbde758 | 2020-06-12 15:41:20 +0300 | [diff] [blame] | 590 | return bootm_find_images(flag, argc, argv, 0, 0); |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 591 | |
| 592 | return 0; |
| 593 | } |
Simon Glass | 40e5975 | 2014-12-02 13:17:30 -0700 | [diff] [blame] | 594 | #endif /* USE_HOSTC */ |
| 595 | |
Julius Werner | 2090854 | 2019-07-24 19:37:54 -0700 | [diff] [blame] | 596 | #if !defined(USE_HOSTCC) || defined(CONFIG_FIT_SIGNATURE) |
Simon Glass | 3086c05 | 2014-12-02 13:17:37 -0700 | [diff] [blame] | 597 | /** |
| 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 Rini | c45568c | 2022-06-25 19:29:46 -0400 | [diff] [blame] | 606 | * @buf_size: Number of bytes the decompresion buffer was |
Julius Werner | 2090854 | 2019-07-24 19:37:54 -0700 | [diff] [blame] | 607 | * @ret: errno error code received from compression library |
Heinrich Schuchardt | 185f812 | 2022-01-19 18:05:50 +0100 | [diff] [blame] | 608 | * Return: Appropriate BOOTM_ERR_ error code |
Simon Glass | 3086c05 | 2014-12-02 13:17:37 -0700 | [diff] [blame] | 609 | */ |
Tom Rini | c45568c | 2022-06-25 19:29:46 -0400 | [diff] [blame] | 610 | static int handle_decomp_error(int comp_type, size_t uncomp_size, |
| 611 | size_t buf_size, int ret) |
Simon Glass | 40e5975 | 2014-12-02 13:17:30 -0700 | [diff] [blame] | 612 | { |
Simon Glass | 3086c05 | 2014-12-02 13:17:37 -0700 | [diff] [blame] | 613 | const char *name = genimg_get_comp_name(comp_type); |
| 614 | |
Julius Werner | 2090854 | 2019-07-24 19:37:54 -0700 | [diff] [blame] | 615 | /* ENOSYS means unimplemented compression type, don't reset. */ |
| 616 | if (ret == -ENOSYS) |
| 617 | return BOOTM_ERR_UNIMPLEMENTED; |
| 618 | |
Tom Rini | c45568c | 2022-06-25 19:29:46 -0400 | [diff] [blame] | 619 | if (uncomp_size >= buf_size) |
Simon Glass | 3086c05 | 2014-12-02 13:17:37 -0700 | [diff] [blame] | 620 | printf("Image too large: increase CONFIG_SYS_BOOTM_LEN\n"); |
Simon Glass | 40e5975 | 2014-12-02 13:17:30 -0700 | [diff] [blame] | 621 | else |
Simon Glass | 3086c05 | 2014-12-02 13:17:37 -0700 | [diff] [blame] | 622 | 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 Glass | 40e5975 | 2014-12-02 13:17:30 -0700 | [diff] [blame] | 630 | #ifndef USE_HOSTCC |
| 631 | bootstage_error(BOOTSTAGE_ID_DECOMP_IMAGE); |
| 632 | #endif |
| 633 | |
| 634 | return BOOTM_ERR_RESET; |
| 635 | } |
Julius Werner | 2090854 | 2019-07-24 19:37:54 -0700 | [diff] [blame] | 636 | #endif |
Simon Glass | 2b164f1 | 2014-06-12 07:24:52 -0600 | [diff] [blame] | 637 | |
Simon Glass | ce1400f | 2014-06-12 07:24:53 -0600 | [diff] [blame] | 638 | #ifndef USE_HOSTCC |
Simon Glass | d9d7c20 | 2022-09-06 20:26:50 -0600 | [diff] [blame] | 639 | static int bootm_load_os(struct bootm_headers *images, int boot_progress) |
Simon Glass | 2b164f1 | 2014-06-12 07:24:52 -0600 | [diff] [blame] | 640 | { |
Simon Glass | da79b2f | 2022-09-06 20:26:51 -0600 | [diff] [blame] | 641 | struct image_info os = images->os; |
Simon Glass | 2b164f1 | 2014-06-12 07:24:52 -0600 | [diff] [blame] | 642 | ulong load = os.load; |
Tom Rini | cc95535 | 2018-05-01 12:32:37 -0400 | [diff] [blame] | 643 | ulong load_end; |
Simon Glass | 2b164f1 | 2014-06-12 07:24:52 -0600 | [diff] [blame] | 644 | 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'Donoghue | bbac922 | 2018-04-15 11:48:17 +0100 | [diff] [blame] | 648 | ulong flush_start = ALIGN_DOWN(load, ARCH_DMA_MINALIGN); |
Simon Glass | 2b164f1 | 2014-06-12 07:24:52 -0600 | [diff] [blame] | 649 | 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 Werner | 2090854 | 2019-07-24 19:37:54 -0700 | [diff] [blame] | 655 | 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 Glass | 2b164f1 | 2014-06-12 07:24:52 -0600 | [diff] [blame] | 658 | if (err) { |
Tom Rini | c45568c | 2022-06-25 19:29:46 -0400 | [diff] [blame] | 659 | err = handle_decomp_error(os.comp, load_end - load, |
| 660 | CONFIG_SYS_BOOTM_LEN, err); |
Simon Glass | 2b164f1 | 2014-06-12 07:24:52 -0600 | [diff] [blame] | 661 | bootstage_error(BOOTSTAGE_ID_DECOMP_IMAGE); |
| 662 | return err; |
| 663 | } |
Bo Lv | da8d5b7 | 2023-07-31 14:58:21 +0800 | [diff] [blame] | 664 | |
| 665 | #ifdef CONFIG_AMLOGIC_MODIFY |
Bo Lv | 77426d6 | 2023-08-11 19:05:38 +0800 | [diff] [blame] | 666 | extern uint32_t get_rsv_mem_size(void); |
| 667 | if (load_end >= IOTRACE_LOAD_ADDR && load < get_rsv_mem_size()) |
Bo Lv | da8d5b7 | 2023-07-31 14:58:21 +0800 | [diff] [blame] | 668 | printf("[Warning] kernel overlap iotrace, please reset decompress addr\n"); |
| 669 | #endif |
| 670 | |
Heinrich Schuchardt | 21d3946 | 2020-08-30 11:34:12 +0200 | [diff] [blame] | 671 | /* We need the decompressed image size in the next steps */ |
| 672 | images->os.image_len = load_end - load; |
Bryan O'Donoghue | bbac922 | 2018-04-15 11:48:17 +0100 | [diff] [blame] | 673 | |
Trent Piepho | b4353b3 | 2019-03-27 23:50:09 +0000 | [diff] [blame] | 674 | flush_cache(flush_start, ALIGN(load_end, ARCH_DMA_MINALIGN) - flush_start); |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 675 | |
Bo Lv | 65d8679 | 2024-08-30 11:02:03 +0800 | [diff] [blame] | 676 | printf(" kernel loaded at 0x%08lx, end = 0x%08lx\n", load, load_end); |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 677 | bootstage_mark(BOOTSTAGE_ID_KERNEL_LOADED); |
| 678 | |
Simon Glass | 2b164f1 | 2014-06-12 07:24:52 -0600 | [diff] [blame] | 679 | no_overlap = (os.comp == IH_COMP_NONE && load == image_start); |
| 680 | |
Tom Rini | cc95535 | 2018-05-01 12:32:37 -0400 | [diff] [blame] | 681 | if (!no_overlap && load < blob_end && load_end > blob_start) { |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 682 | 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 Rini | cc95535 | 2018-05-01 12:32:37 -0400 | [diff] [blame] | 685 | load_end); |
Bo Lv | 4a46502 | 2023-02-28 05:51:47 +0000 | [diff] [blame] | 686 | #ifndef CONFIG_ANDROID_BOOT_IMAGE |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 687 | /* 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 Lv | 4a46502 | 2023-02-28 05:51:47 +0000 | [diff] [blame] | 698 | #endif |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 699 | } |
| 700 | |
Tom Rini | cc95535 | 2018-05-01 12:32:37 -0400 | [diff] [blame] | 701 | lmb_reserve(&images->lmb, images->os.load, (load_end - |
| 702 | images->os.load)); |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 703 | return 0; |
| 704 | } |
| 705 | |
| 706 | /** |
| 707 | * bootm_disable_interrupts() - Disable interrupts in preparation for load/boot |
| 708 | * |
Heinrich Schuchardt | 185f812 | 2022-01-19 18:05:50 +0100 | [diff] [blame] | 709 | * Return: interrupt flag (0 if interrupts were disabled, non-zero if they were |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 710 | * enabled) |
| 711 | */ |
| 712 | ulong 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 Nortmann | 4917c06 | 2015-09-14 15:29:45 +0200 | [diff] [blame] | 725 | # ifndef CONFIG_DM_ETH |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 726 | eth_unregister(eth_get_dev()); |
Bernhard Nortmann | 4917c06 | 2015-09-14 15:29:45 +0200 | [diff] [blame] | 727 | # endif |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 728 | #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 Glass | 6cd92b1 | 2020-11-05 10:33:42 -0700 | [diff] [blame] | 745 | #define CONSOLE_ARG "console=" |
Sean Anderson | ba9aa40 | 2022-05-19 18:26:05 -0400 | [diff] [blame] | 746 | #define NULL_CONSOLE (CONSOLE_ARG "ttynull") |
| 747 | #define CONSOLE_ARG_SIZE sizeof(NULL_CONSOLE) |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 748 | |
Simon Glass | b6386f3 | 2020-11-05 10:33:43 -0700 | [diff] [blame] | 749 | /** |
| 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 Schuchardt | 185f812 | 2022-01-19 18:05:50 +0100 | [diff] [blame] | 757 | * Return: 0 if OK, -ENOSPC if @maxlen is too small |
Simon Glass | b6386f3 | 2020-11-05 10:33:43 -0700 | [diff] [blame] | 758 | */ |
| 759 | static int fixup_silent_linux(char *buf, int maxlen) |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 760 | { |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 761 | int want_silent; |
Simon Glass | b6386f3 | 2020-11-05 10:33:43 -0700 | [diff] [blame] | 762 | char *cmdline; |
| 763 | int size; |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 764 | |
Simon Glass | b6386f3 | 2020-11-05 10:33:43 -0700 | [diff] [blame] | 765 | /* |
| 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 Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 774 | /* |
| 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 Glass | bfebc8c | 2017-08-03 12:22:13 -0600 | [diff] [blame] | 781 | want_silent = env_get_yesno("silent_linux"); |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 782 | if (want_silent == 0) |
Simon Glass | 4ae4264 | 2020-11-05 10:33:39 -0700 | [diff] [blame] | 783 | return 0; |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 784 | else if (want_silent == -1 && !(gd->flags & GD_FLG_SILENT)) |
Simon Glass | 4ae4264 | 2020-11-05 10:33:39 -0700 | [diff] [blame] | 785 | return 0; |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 786 | |
| 787 | debug("before silent fix-up: %s\n", cmdline); |
Simon Glass | b6386f3 | 2020-11-05 10:33:43 -0700 | [diff] [blame] | 788 | if (*cmdline) { |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 789 | char *start = strstr(cmdline, CONSOLE_ARG); |
| 790 | |
Simon Glass | b6386f3 | 2020-11-05 10:33:43 -0700 | [diff] [blame] | 791 | /* Check space for maximum possible new command line */ |
| 792 | if (size + CONSOLE_ARG_SIZE > maxlen) |
Simon Glass | 4ae4264 | 2020-11-05 10:33:39 -0700 | [diff] [blame] | 793 | return -ENOSPC; |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 794 | |
| 795 | if (start) { |
| 796 | char *end = strchr(start, ' '); |
Simon Glass | 6cd92b1 | 2020-11-05 10:33:42 -0700 | [diff] [blame] | 797 | int start_bytes; |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 798 | |
Sean Anderson | ba9aa40 | 2022-05-19 18:26:05 -0400 | [diff] [blame] | 799 | start_bytes = start - cmdline; |
Simon Glass | 6cd92b1 | 2020-11-05 10:33:42 -0700 | [diff] [blame] | 800 | strncpy(buf, cmdline, start_bytes); |
Sean Anderson | ba9aa40 | 2022-05-19 18:26:05 -0400 | [diff] [blame] | 801 | strncpy(buf + start_bytes, NULL_CONSOLE, CONSOLE_ARG_SIZE); |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 802 | if (end) |
Sean Anderson | ba9aa40 | 2022-05-19 18:26:05 -0400 | [diff] [blame] | 803 | strcpy(buf + start_bytes + CONSOLE_ARG_SIZE - 1, end); |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 804 | else |
Sean Anderson | ba9aa40 | 2022-05-19 18:26:05 -0400 | [diff] [blame] | 805 | buf[start_bytes + CONSOLE_ARG_SIZE] = '\0'; |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 806 | } else { |
Sean Anderson | ba9aa40 | 2022-05-19 18:26:05 -0400 | [diff] [blame] | 807 | sprintf(buf, "%s %s", cmdline, NULL_CONSOLE); |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 808 | } |
Simon Glass | b6386f3 | 2020-11-05 10:33:43 -0700 | [diff] [blame] | 809 | if (buf + strlen(buf) >= cmdline) |
| 810 | return -ENOSPC; |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 811 | } else { |
Sean Anderson | ba9aa40 | 2022-05-19 18:26:05 -0400 | [diff] [blame] | 812 | if (maxlen < CONSOLE_ARG_SIZE) |
Simon Glass | b6386f3 | 2020-11-05 10:33:43 -0700 | [diff] [blame] | 813 | return -ENOSPC; |
Sean Anderson | ba9aa40 | 2022-05-19 18:26:05 -0400 | [diff] [blame] | 814 | strcpy(buf, NULL_CONSOLE); |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 815 | } |
Simon Glass | b6386f3 | 2020-11-05 10:33:43 -0700 | [diff] [blame] | 816 | debug("after silent fix-up: %s\n", buf); |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 817 | |
Simon Glass | b6386f3 | 2020-11-05 10:33:43 -0700 | [diff] [blame] | 818 | return 0; |
| 819 | } |
| 820 | |
Simon Glass | 51bb338 | 2020-11-05 10:33:48 -0700 | [diff] [blame] | 821 | /** |
| 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 Schuchardt | 185f812 | 2022-01-19 18:05:50 +0100 | [diff] [blame] | 828 | * Return: 0 if OK, -ENOSPC if @maxlen is too small |
Simon Glass | 51bb338 | 2020-11-05 10:33:48 -0700 | [diff] [blame] | 829 | */ |
| 830 | static 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 Glass | 4448fe8 | 2020-11-05 10:33:45 -0700 | [diff] [blame] | 848 | int 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 Lv | aa183f8 | 2023-07-29 13:30:00 +0800 | [diff] [blame] | 855 | (flags & BOOTM_CL_SILENT) && |
| 856 | !IS_ENABLED(CONFIG_AMLOGIC_MODIFY)) { |
Simon Glass | 4448fe8 | 2020-11-05 10:33:45 -0700 | [diff] [blame] | 857 | ret = fixup_silent_linux(buf, maxlen); |
| 858 | if (ret) |
| 859 | return log_msg_ret("silent", ret); |
| 860 | } |
Simon Glass | a8d6962 | 2021-03-15 18:11:23 +1300 | [diff] [blame] | 861 | if (IS_ENABLED(CONFIG_BOOTARGS_SUBST) && IS_ENABLED(CONFIG_CMDLINE) && |
| 862 | (flags & BOOTM_CL_SUBST)) { |
Simon Glass | 51bb338 | 2020-11-05 10:33:48 -0700 | [diff] [blame] | 863 | ret = process_subst(buf, maxlen); |
| 864 | if (ret) |
Simon Glass | 185756e | 2021-02-06 09:57:35 -0700 | [diff] [blame] | 865 | return log_msg_ret("subst", ret); |
Simon Glass | 51bb338 | 2020-11-05 10:33:48 -0700 | [diff] [blame] | 866 | } |
Simon Glass | 4448fe8 | 2020-11-05 10:33:45 -0700 | [diff] [blame] | 867 | |
| 868 | return 0; |
| 869 | } |
| 870 | |
Simon Glass | b3c0167 | 2020-11-05 10:33:44 -0700 | [diff] [blame] | 871 | int bootm_process_cmdline_env(int flags) |
Simon Glass | b6386f3 | 2020-11-05 10:33:43 -0700 | [diff] [blame] | 872 | { |
| 873 | const int maxlen = MAX_CMDLINE_SIZE; |
Simon Glass | b3c0167 | 2020-11-05 10:33:44 -0700 | [diff] [blame] | 874 | bool do_silent; |
Simon Glass | b6386f3 | 2020-11-05 10:33:43 -0700 | [diff] [blame] | 875 | 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 Glass | b3c0167 | 2020-11-05 10:33:44 -0700 | [diff] [blame] | 881 | !IS_ENABLED(CONFIG_SILENT_U_BOOT_ONLY) && (flags & BOOTM_CL_SILENT); |
Simon Glass | 51bb338 | 2020-11-05 10:33:48 -0700 | [diff] [blame] | 882 | if (!do_silent && !IS_ENABLED(CONFIG_BOOTARGS_SUBST)) |
Simon Glass | b6386f3 | 2020-11-05 10:33:43 -0700 | [diff] [blame] | 883 | 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 Glass | 4448fe8 | 2020-11-05 10:33:45 -0700 | [diff] [blame] | 895 | ret = bootm_process_cmdline(buf, maxlen, flags); |
Simon Glass | b6386f3 | 2020-11-05 10:33:43 -0700 | [diff] [blame] | 896 | 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 Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 906 | free(buf); |
Simon Glass | b6386f3 | 2020-11-05 10:33:43 -0700 | [diff] [blame] | 907 | if (ret) |
| 908 | return log_msg_ret("env", ret); |
Simon Glass | 4ae4264 | 2020-11-05 10:33:39 -0700 | [diff] [blame] | 909 | |
| 910 | return 0; |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 911 | } |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 912 | |
| 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 Schuchardt | 185f812 | 2022-01-19 18:05:50 +0100 | [diff] [blame] | 933 | * Return: 0 if ok, something else on error. Some errors will cause this |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 934 | * 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 Glass | 0914011 | 2020-05-10 11:40:03 -0600 | [diff] [blame] | 938 | int do_bootm_states(struct cmd_tbl *cmdtp, int flag, int argc, |
Simon Glass | d9d7c20 | 2022-09-06 20:26:50 -0600 | [diff] [blame] | 939 | char *const argv[], int states, struct bootm_headers *images, |
Simon Glass | 0914011 | 2020-05-10 11:40:03 -0600 | [diff] [blame] | 940 | int boot_progress) |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 941 | { |
| 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 Reynes | 9d46e63 | 2022-03-28 22:57:00 +0200 | [diff] [blame] | 955 | if (!ret && (states & BOOTM_STATE_PRE_LOAD)) |
| 956 | ret = bootm_pre_load(cmdtp, flag, argc, argv); |
| 957 | |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 958 | if (!ret && (states & BOOTM_STATE_FINDOS)) |
| 959 | ret = bootm_find_os(cmdtp, flag, argc, argv); |
| 960 | |
Zubair Lutfullah Kakakhel | ba07984 | 2016-09-09 09:18:58 +0100 | [diff] [blame] | 961 | if (!ret && (states & BOOTM_STATE_FINDOTHER)) |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 962 | ret = bootm_find_other(cmdtp, flag, argc, argv); |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 963 | |
dongqing.li | 994a05e | 2023-10-17 09:19:27 +0800 | [diff] [blame] | 964 | #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 Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 971 | /* Load the OS */ |
| 972 | if (!ret && (states & BOOTM_STATE_LOADOS)) { |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 973 | iflag = bootm_disable_interrupts(); |
Tom Rini | cc95535 | 2018-05-01 12:32:37 -0400 | [diff] [blame] | 974 | ret = bootm_load_os(images, 0); |
| 975 | if (ret && ret != BOOTM_ERR_OVERLAP) |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 976 | goto err; |
| 977 | else if (ret == BOOTM_ERR_OVERLAP) |
| 978 | ret = 0; |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 979 | } |
| 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 Glass | 018f530 | 2017-08-03 12:22:10 -0600 | [diff] [blame] | 989 | env_set_hex("initrd_start", images->initrd_start); |
| 990 | env_set_hex("initrd_end", images->initrd_end); |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 991 | } |
| 992 | } |
| 993 | #endif |
Simon Glass | 0c303f9 | 2021-09-25 19:43:21 -0600 | [diff] [blame] | 994 | #if CONFIG_IS_ENABLED(OF_LIBFDT) && defined(CONFIG_LMB) |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 995 | 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 Li | f674018 | 2023-03-27 15:45:23 +0800 | [diff] [blame] | 1002 | #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 Wang | d7a42e7 | 2024-07-04 14:32:25 +0800 | [diff] [blame] | 1011 | |
| 1012 | /* memtag region protect */ |
| 1013 | #ifdef CONFIG_CMD_MEMTAG |
| 1014 | run_command("memtag check", 0); |
| 1015 | #endif |
Hangyu Li | f674018 | 2023-03-27 15:45:23 +0800 | [diff] [blame] | 1016 | #endif |
| 1017 | |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 1018 | /* 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 Palacios | 19e8649 | 2016-07-11 12:34:37 +0200 | [diff] [blame] | 1034 | |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 1035 | /* 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 Palacios | 19e8649 | 2016-07-11 12:34:37 +0200 | [diff] [blame] | 1040 | if (!ret && (states & BOOTM_STATE_OS_PREP)) { |
Simon Glass | 51bb338 | 2020-11-05 10:33:48 -0700 | [diff] [blame] | 1041 | ret = bootm_process_cmdline_env(images->os.os == IH_OS_LINUX); |
Simon Glass | d9477a0 | 2020-11-05 10:33:41 -0700 | [diff] [blame] | 1042 | if (ret) { |
| 1043 | printf("Cmdline setup failed (err=%d)\n", ret); |
| 1044 | ret = CMD_RET_FAILURE; |
| 1045 | goto err; |
Simon Glass | 4ae4264 | 2020-11-05 10:33:39 -0700 | [diff] [blame] | 1046 | } |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 1047 | ret = boot_fn(BOOTM_STATE_OS_PREP, argc, argv, images); |
Hector Palacios | 19e8649 | 2016-07-11 12:34:37 +0200 | [diff] [blame] | 1048 | } |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 1049 | |
| 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 Glass | 00caae6 | 2017-08-03 12:22:12 -0600 | [diff] [blame] | 1053 | char *cmd_list = env_get("fakegocmd"); |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 1054 | |
| 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 Glass | 13819f0 | 2022-10-11 09:47:07 -0600 | [diff] [blame] | 1064 | printf("subcommand failed (err=%d)\n", ret); |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 1065 | 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 */ |
| 1074 | err: |
| 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 Rini | c76c93a | 2019-05-23 07:14:07 -0400 | [diff] [blame] | 1086 | #if CONFIG_IS_ENABLED(LEGACY_IMAGE_FORMAT) |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 1087 | /** |
| 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 Glass | f3543e6 | 2022-09-06 20:26:52 -0600 | [diff] [blame] | 1099 | static struct legacy_img_hdr *image_get_kernel(ulong img_addr, int verify) |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 1100 | { |
Simon Glass | f3543e6 | 2022-09-06 20:26:52 -0600 | [diff] [blame] | 1101 | struct legacy_img_hdr *hdr = (struct legacy_img_hdr *)img_addr; |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 1102 | |
| 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 Glass | 0914011 | 2020-05-10 11:40:03 -0600 | [diff] [blame] | 1151 | static const void *boot_get_kernel(struct cmd_tbl *cmdtp, int flag, int argc, |
Simon Glass | d9d7c20 | 2022-09-06 20:26:50 -0600 | [diff] [blame] | 1152 | char *const argv[], struct bootm_headers *images, |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 1153 | ulong *os_data, ulong *os_len) |
| 1154 | { |
Tom Rini | c76c93a | 2019-05-23 07:14:07 -0400 | [diff] [blame] | 1155 | #if CONFIG_IS_ENABLED(LEGACY_IMAGE_FORMAT) |
Simon Glass | f3543e6 | 2022-09-06 20:26:52 -0600 | [diff] [blame] | 1156 | struct legacy_img_hdr *hdr; |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 1157 | #endif |
| 1158 | ulong img_addr; |
| 1159 | const void *buf; |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 1160 | const char *fit_uname_config = NULL; |
| 1161 | const char *fit_uname_kernel = NULL; |
Simon Glass | bf371b4 | 2021-09-25 19:43:20 -0600 | [diff] [blame] | 1162 | #if CONFIG_IS_ENABLED(FIT) |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 1163 | int os_noffset; |
| 1164 | #endif |
| 1165 | |
Bo Lv | 4a46502 | 2023-02-28 05:51:47 +0000 | [diff] [blame] | 1166 | #ifdef CONFIG_AMLOGIC_MODIFY |
Xindong Xu | ac88caf | 2024-10-28 17:10:12 +0800 | [diff] [blame] | 1167 | #ifndef CONFIG_AVB2 |
Bo Lv | 4a46502 | 2023-02-28 05:51:47 +0000 | [diff] [blame] | 1168 | #ifdef CONFIG_AML_ANTIROLLBACK |
| 1169 | boot_img_hdr_t **tmp_img_hdr = (boot_img_hdr_t **)&buf; |
| 1170 | #endif |
Xindong Xu | ac88caf | 2024-10-28 17:10:12 +0800 | [diff] [blame] | 1171 | #endif |
| 1172 | |
Bo Lv | 4a46502 | 2023-02-28 05:51:47 +0000 | [diff] [blame] | 1173 | #endif |
| 1174 | |
Bryan Wu | e6c88a6 | 2014-08-15 16:51:39 -0700 | [diff] [blame] | 1175 | img_addr = genimg_get_kernel_addr_fit(argc < 1 ? NULL : argv[0], |
| 1176 | &fit_uname_config, |
| 1177 | &fit_uname_kernel); |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 1178 | |
Philippe Reynes | 9d46e63 | 2022-03-28 22:57:00 +0200 | [diff] [blame] | 1179 | if (CONFIG_IS_ENABLED(CMD_BOOTM_PRE_LOAD)) |
| 1180 | img_addr += image_load_offset; |
| 1181 | |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 1182 | bootstage_mark(BOOTSTAGE_ID_CHECK_MAGIC); |
| 1183 | |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 1184 | /* 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 Rini | c76c93a | 2019-05-23 07:14:07 -0400 | [diff] [blame] | 1188 | #if CONFIG_IS_ENABLED(LEGACY_IMAGE_FORMAT) |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 1189 | 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 Glass | f3543e6 | 2022-09-06 20:26:52 -0600 | [diff] [blame] | 1223 | sizeof(struct legacy_img_hdr)); |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 1224 | |
| 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 Glass | bf371b4 | 2021-09-25 19:43:20 -0600 | [diff] [blame] | 1232 | #if CONFIG_IS_ENABLED(FIT) |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 1233 | case IMAGE_FORMAT_FIT: |
Simon Glass | 126cc86 | 2014-06-12 07:24:47 -0600 | [diff] [blame] | 1234 | os_noffset = fit_image_load(images, img_addr, |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 1235 | &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 Lv | 4a46502 | 2023-02-28 05:51:47 +0000 | [diff] [blame] | 1251 | |
| 1252 | #ifndef CONFIG_AMLOGIC_MODIFY |
Simon Glass | 07c0cd7 | 2014-06-12 07:24:48 -0600 | [diff] [blame] | 1253 | if (android_image_get_kernel(buf, images->verify, |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 1254 | os_data, os_len)) |
| 1255 | return NULL; |
Bo Lv | 4a46502 | 2023-02-28 05:51:47 +0000 | [diff] [blame] | 1256 | #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 Xu | ac88caf | 2024-10-28 17:10:12 +0800 | [diff] [blame] | 1265 | #ifndef CONFIG_AVB2 |
Bo Lv | 4a46502 | 2023-02-28 05:51:47 +0000 | [diff] [blame] | 1266 | #ifdef CONFIG_AML_ANTIROLLBACK |
| 1267 | if (!check_antirollback((*tmp_img_hdr)->kernel_version)) { |
| 1268 | *os_len = 0; |
| 1269 | return NULL; |
| 1270 | } |
| 1271 | #endif |
Xindong Xu | ac88caf | 2024-10-28 17:10:12 +0800 | [diff] [blame] | 1272 | #endif |
Bo Lv | 4a46502 | 2023-02-28 05:51:47 +0000 | [diff] [blame] | 1273 | #endif |
Simon Glass | b639640 | 2014-06-12 07:24:46 -0600 | [diff] [blame] | 1274 | 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 Schuchardt | f6c6df7 | 2019-01-08 18:13:06 +0100 | [diff] [blame] | 1287 | |
| 1288 | /** |
| 1289 | * switch_to_non_secure_mode() - switch to non-secure mode |
| 1290 | * |
| 1291 | * This routine is overridden by architectures requiring this feature. |
| 1292 | */ |
| 1293 | void __weak switch_to_non_secure_mode(void) |
| 1294 | { |
| 1295 | } |
| 1296 | |
Simon Glass | ce1400f | 2014-06-12 07:24:53 -0600 | [diff] [blame] | 1297 | #else /* USE_HOSTCC */ |
| 1298 | |
Fabrice Fontaine | 93e0788 | 2019-05-03 22:37:05 +0200 | [diff] [blame] | 1299 | #if defined(CONFIG_FIT_SIGNATURE) |
Simon Glass | 8a9d037 | 2020-03-18 11:44:02 -0600 | [diff] [blame] | 1300 | static int bootm_host_load_image(const void *fit, int req_image_type, |
| 1301 | int cfg_noffset) |
Simon Glass | ce1400f | 2014-06-12 07:24:53 -0600 | [diff] [blame] | 1302 | { |
| 1303 | const char *fit_uname_config = NULL; |
| 1304 | ulong data, len; |
Simon Glass | d9d7c20 | 2022-09-06 20:26:50 -0600 | [diff] [blame] | 1305 | struct bootm_headers images; |
Simon Glass | ce1400f | 2014-06-12 07:24:53 -0600 | [diff] [blame] | 1306 | int noffset; |
Tom Rini | c45568c | 2022-06-25 19:29:46 -0400 | [diff] [blame] | 1307 | ulong load_end, buf_size; |
Simon Glass | ce1400f | 2014-06-12 07:24:53 -0600 | [diff] [blame] | 1308 | uint8_t image_type; |
Daniel Golle | 0cd57f2 | 2022-08-27 04:14:42 +0100 | [diff] [blame] | 1309 | uint8_t image_comp; |
Simon Glass | ce1400f | 2014-06-12 07:24:53 -0600 | [diff] [blame] | 1310 | void *load_buf; |
| 1311 | int ret; |
| 1312 | |
Simon Glass | 8a9d037 | 2020-03-18 11:44:02 -0600 | [diff] [blame] | 1313 | fit_uname_config = fdt_get_name(fit, cfg_noffset, NULL); |
Simon Glass | ce1400f | 2014-06-12 07:24:53 -0600 | [diff] [blame] | 1314 | 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 Golle | 88de6c5 | 2022-08-27 04:17:28 +0100 | [diff] [blame] | 1327 | if (fit_image_get_comp(fit, noffset, &image_comp)) |
| 1328 | image_comp = IH_COMP_NONE; |
Simon Glass | ce1400f | 2014-06-12 07:24:53 -0600 | [diff] [blame] | 1329 | |
| 1330 | /* Allow the image to expand by a factor of 4, should be safe */ |
Tom Rini | c45568c | 2022-06-25 19:29:46 -0400 | [diff] [blame] | 1331 | buf_size = (1 << 20) + len * 4; |
| 1332 | load_buf = malloc(buf_size); |
Daniel Golle | 0cd57f2 | 2022-08-27 04:14:42 +0100 | [diff] [blame] | 1333 | ret = image_decomp(image_comp, 0, data, image_type, load_buf, |
Tom Rini | c45568c | 2022-06-25 19:29:46 -0400 | [diff] [blame] | 1334 | (void *)data, len, buf_size, &load_end); |
Simon Glass | ce1400f | 2014-06-12 07:24:53 -0600 | [diff] [blame] | 1335 | free(load_buf); |
Simon Glass | 081cc19 | 2014-12-02 13:17:33 -0700 | [diff] [blame] | 1336 | |
Julius Werner | 2090854 | 2019-07-24 19:37:54 -0700 | [diff] [blame] | 1337 | if (ret) { |
Daniel Golle | 0cd57f2 | 2022-08-27 04:14:42 +0100 | [diff] [blame] | 1338 | ret = handle_decomp_error(image_comp, load_end - 0, buf_size, ret); |
Julius Werner | 2090854 | 2019-07-24 19:37:54 -0700 | [diff] [blame] | 1339 | if (ret != BOOTM_ERR_UNIMPLEMENTED) |
| 1340 | return ret; |
| 1341 | } |
Simon Glass | ce1400f | 2014-06-12 07:24:53 -0600 | [diff] [blame] | 1342 | |
| 1343 | return 0; |
| 1344 | } |
| 1345 | |
| 1346 | int 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 Glass | 8a9d037 | 2020-03-18 11:44:02 -0600 | [diff] [blame] | 1359 | ret = bootm_host_load_image(fit, image_types[i], cfg_noffset); |
Simon Glass | ce1400f | 2014-06-12 07:24:53 -0600 | [diff] [blame] | 1360 | if (!err && ret && ret != -ENOENT) |
| 1361 | err = ret; |
| 1362 | } |
| 1363 | |
| 1364 | /* Return the first error we found */ |
| 1365 | return err; |
| 1366 | } |
Fabrice Fontaine | 93e0788 | 2019-05-03 22:37:05 +0200 | [diff] [blame] | 1367 | #endif |
Simon Glass | ea51a62 | 2014-06-12 07:24:51 -0600 | [diff] [blame] | 1368 | |
| 1369 | #endif /* ndef USE_HOSTCC */ |