1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * (C) Copyright 2000-2009 4 * Wolfgang Denk, DENX Software Engineering, wd@denx.de. 5 */ 6 7 #ifndef USE_HOSTCC 8 #include <common.h> 9 #include <bootstage.h> 10 #include <bzlib.h> 11 #include <errno.h> 12 #include <fdt_support.h> 13 #include <lmb.h> 14 #include <malloc.h> 15 #include <mapmem.h> 16 #include <asm/io.h> 17 #include <linux/lzo.h> 18 #include <lzma/LzmaTypes.h> 19 #include <lzma/LzmaDec.h> 20 #include <lzma/LzmaTools.h> 21 #if defined(CONFIG_CMD_USB) 22 #include <usb.h> 23 #endif 24 #else 25 #include "mkimage.h" 26 #endif 27 28 #include <command.h> 29 #include <bootm.h> 30 #include <image.h> 31 32 #ifndef CONFIG_SYS_BOOTM_LEN 33 /* use 8MByte as default max gunzip size */ 34 #define CONFIG_SYS_BOOTM_LEN 0x800000 35 #endif 36 37 #define IH_INITRD_ARCH IH_ARCH_DEFAULT 38 39 #ifndef USE_HOSTCC 40 41 DECLARE_GLOBAL_DATA_PTR; 42 43 bootm_headers_t images; /* pointers to os/initrd/fdt images */ 44 45 static const void *boot_get_kernel(cmd_tbl_t *cmdtp, int flag, int argc, 46 char * const argv[], bootm_headers_t *images, 47 ulong *os_data, ulong *os_len); 48 49 __weak void board_quiesce_devices(void) 50 { 51 } 52 53 #ifdef CONFIG_LMB 54 static void boot_start_lmb(bootm_headers_t *images) 55 { 56 ulong mem_start; 57 phys_size_t mem_size; 58 59 lmb_init(&images->lmb); 60 61 mem_start = env_get_bootm_low(); 62 mem_size = env_get_bootm_size(); 63 64 lmb_add(&images->lmb, (phys_addr_t)mem_start, mem_size); 65 66 arch_lmb_reserve(&images->lmb); 67 board_lmb_reserve(&images->lmb); 68 } 69 #else 70 #define lmb_reserve(lmb, base, size) 71 static inline void boot_start_lmb(bootm_headers_t *images) { } 72 #endif 73 74 static int bootm_start(cmd_tbl_t *cmdtp, int flag, int argc, 75 char * const argv[]) 76 { 77 memset((void *)&images, 0, sizeof(images)); 78 images.verify = env_get_yesno("verify"); 79 80 boot_start_lmb(&images); 81 82 bootstage_mark_name(BOOTSTAGE_ID_BOOTM_START, "bootm_start"); 83 images.state = BOOTM_STATE_START; 84 85 return 0; 86 } 87 88 static int bootm_find_os(cmd_tbl_t *cmdtp, int flag, int argc, 89 char * const argv[]) 90 { 91 const void *os_hdr; 92 bool ep_found = false; 93 int ret; 94 95 /* get kernel image header, start address and length */ 96 os_hdr = boot_get_kernel(cmdtp, flag, argc, argv, 97 &images, &images.os.image_start, &images.os.image_len); 98 if (images.os.image_len == 0) { 99 puts("ERROR: can't get kernel image!\n"); 100 return 1; 101 } 102 103 /* get image parameters */ 104 switch (genimg_get_format(os_hdr)) { 105 #if defined(CONFIG_IMAGE_FORMAT_LEGACY) 106 case IMAGE_FORMAT_LEGACY: 107 images.os.type = image_get_type(os_hdr); 108 images.os.comp = image_get_comp(os_hdr); 109 images.os.os = image_get_os(os_hdr); 110 111 images.os.end = image_get_image_end(os_hdr); 112 images.os.load = image_get_load(os_hdr); 113 images.os.arch = image_get_arch(os_hdr); 114 break; 115 #endif 116 #if IMAGE_ENABLE_FIT 117 case IMAGE_FORMAT_FIT: 118 if (fit_image_get_type(images.fit_hdr_os, 119 images.fit_noffset_os, 120 &images.os.type)) { 121 puts("Can't get image type!\n"); 122 bootstage_error(BOOTSTAGE_ID_FIT_TYPE); 123 return 1; 124 } 125 126 if (fit_image_get_comp(images.fit_hdr_os, 127 images.fit_noffset_os, 128 &images.os.comp)) { 129 puts("Can't get image compression!\n"); 130 bootstage_error(BOOTSTAGE_ID_FIT_COMPRESSION); 131 return 1; 132 } 133 134 if (fit_image_get_os(images.fit_hdr_os, images.fit_noffset_os, 135 &images.os.os)) { 136 puts("Can't get image OS!\n"); 137 bootstage_error(BOOTSTAGE_ID_FIT_OS); 138 return 1; 139 } 140 141 if (fit_image_get_arch(images.fit_hdr_os, 142 images.fit_noffset_os, 143 &images.os.arch)) { 144 puts("Can't get image ARCH!\n"); 145 return 1; 146 } 147 148 images.os.end = fit_get_end(images.fit_hdr_os); 149 150 if (fit_image_get_load(images.fit_hdr_os, images.fit_noffset_os, 151 &images.os.load)) { 152 puts("Can't get image load address!\n"); 153 bootstage_error(BOOTSTAGE_ID_FIT_LOADADDR); 154 return 1; 155 } 156 break; 157 #endif 158 #ifdef CONFIG_ANDROID_BOOT_IMAGE 159 case IMAGE_FORMAT_ANDROID: 160 images.os.type = IH_TYPE_KERNEL; 161 images.os.comp = IH_COMP_NONE; 162 images.os.os = IH_OS_LINUX; 163 164 images.os.end = android_image_get_end(os_hdr); 165 images.os.load = android_image_get_kload(os_hdr); 166 images.ep = images.os.load; 167 ep_found = true; 168 break; 169 #endif 170 default: 171 puts("ERROR: unknown image format type!\n"); 172 return 1; 173 } 174 175 /* If we have a valid setup.bin, we will use that for entry (x86) */ 176 if (images.os.arch == IH_ARCH_I386 || 177 images.os.arch == IH_ARCH_X86_64) { 178 ulong len; 179 180 ret = boot_get_setup(&images, IH_ARCH_I386, &images.ep, &len); 181 if (ret < 0 && ret != -ENOENT) { 182 puts("Could not find a valid setup.bin for x86\n"); 183 return 1; 184 } 185 /* Kernel entry point is the setup.bin */ 186 } else if (images.legacy_hdr_valid) { 187 images.ep = image_get_ep(&images.legacy_hdr_os_copy); 188 #if IMAGE_ENABLE_FIT 189 } else if (images.fit_uname_os) { 190 int ret; 191 192 ret = fit_image_get_entry(images.fit_hdr_os, 193 images.fit_noffset_os, &images.ep); 194 if (ret) { 195 puts("Can't get entry point property!\n"); 196 return 1; 197 } 198 #endif 199 } else if (!ep_found) { 200 puts("Could not find kernel entry point!\n"); 201 return 1; 202 } 203 204 if (images.os.type == IH_TYPE_KERNEL_NOLOAD) { 205 if (CONFIG_IS_ENABLED(CMD_BOOTI) && 206 images.os.arch == IH_ARCH_ARM64) { 207 ulong image_addr; 208 ulong image_size; 209 210 ret = booti_setup(images.os.image_start, &image_addr, 211 &image_size, true); 212 if (ret != 0) 213 return 1; 214 215 images.os.type = IH_TYPE_KERNEL; 216 images.os.load = image_addr; 217 images.ep = image_addr; 218 } else { 219 images.os.load = images.os.image_start; 220 images.ep += images.os.image_start; 221 } 222 } 223 224 images.os.start = map_to_sysmem(os_hdr); 225 226 return 0; 227 } 228 229 /** 230 * bootm_find_images - wrapper to find and locate various images 231 * @flag: Ignored Argument 232 * @argc: command argument count 233 * @argv: command argument list 234 * 235 * boot_find_images() will attempt to load an available ramdisk, 236 * flattened device tree, as well as specifically marked 237 * "loadable" images (loadables are FIT only) 238 * 239 * Note: bootm_find_images will skip an image if it is not found 240 * 241 * @return: 242 * 0, if all existing images were loaded correctly 243 * 1, if an image is found but corrupted, or invalid 244 */ 245 int bootm_find_images(int flag, int argc, char * const argv[]) 246 { 247 int ret; 248 249 /* find ramdisk */ 250 ret = boot_get_ramdisk(argc, argv, &images, IH_INITRD_ARCH, 251 &images.rd_start, &images.rd_end); 252 if (ret) { 253 puts("Ramdisk image is corrupt or invalid\n"); 254 return 1; 255 } 256 257 #if IMAGE_ENABLE_OF_LIBFDT 258 /* find flattened device tree */ 259 ret = boot_get_fdt(flag, argc, argv, IH_ARCH_DEFAULT, &images, 260 &images.ft_addr, &images.ft_len); 261 if (ret) { 262 puts("Could not find a valid device tree\n"); 263 return 1; 264 } 265 set_working_fdt_addr((ulong)images.ft_addr); 266 #endif 267 268 #if IMAGE_ENABLE_FIT 269 #if defined(CONFIG_FPGA) 270 /* find bitstreams */ 271 ret = boot_get_fpga(argc, argv, &images, IH_ARCH_DEFAULT, 272 NULL, NULL); 273 if (ret) { 274 printf("FPGA image is corrupted or invalid\n"); 275 return 1; 276 } 277 #endif 278 279 /* find all of the loadables */ 280 ret = boot_get_loadable(argc, argv, &images, IH_ARCH_DEFAULT, 281 NULL, NULL); 282 if (ret) { 283 printf("Loadable(s) is corrupt or invalid\n"); 284 return 1; 285 } 286 #endif 287 288 return 0; 289 } 290 291 static int bootm_find_other(cmd_tbl_t *cmdtp, int flag, int argc, 292 char * const argv[]) 293 { 294 if (((images.os.type == IH_TYPE_KERNEL) || 295 (images.os.type == IH_TYPE_KERNEL_NOLOAD) || 296 (images.os.type == IH_TYPE_MULTI)) && 297 (images.os.os == IH_OS_LINUX || 298 images.os.os == IH_OS_VXWORKS)) 299 return bootm_find_images(flag, argc, argv); 300 301 return 0; 302 } 303 #endif /* USE_HOSTC */ 304 305 /** 306 * print_decomp_msg() - Print a suitable decompression/loading message 307 * 308 * @type: OS type (IH_OS_...) 309 * @comp_type: Compression type being used (IH_COMP_...) 310 * @is_xip: true if the load address matches the image start 311 */ 312 static void print_decomp_msg(int comp_type, int type, bool is_xip) 313 { 314 const char *name = genimg_get_type_name(type); 315 316 if (comp_type == IH_COMP_NONE) 317 printf(" %s %s ... ", is_xip ? "XIP" : "Loading", name); 318 else 319 printf(" Uncompressing %s ... ", name); 320 } 321 322 /** 323 * handle_decomp_error() - display a decompression error 324 * 325 * This function tries to produce a useful message. In the case where the 326 * uncompressed size is the same as the available space, we can assume that 327 * the image is too large for the buffer. 328 * 329 * @comp_type: Compression type being used (IH_COMP_...) 330 * @uncomp_size: Number of bytes uncompressed 331 * @unc_len: Amount of space available for decompression 332 * @ret: Error code to report 333 * @return BOOTM_ERR_RESET, indicating that the board must be reset 334 */ 335 static int handle_decomp_error(int comp_type, size_t uncomp_size, 336 size_t unc_len, int ret) 337 { 338 const char *name = genimg_get_comp_name(comp_type); 339 340 if (uncomp_size >= unc_len) 341 printf("Image too large: increase CONFIG_SYS_BOOTM_LEN\n"); 342 else 343 printf("%s: uncompress error %d\n", name, ret); 344 345 /* 346 * The decompression routines are now safe, so will not write beyond 347 * their bounds. Probably it is not necessary to reset, but maintain 348 * the current behaviour for now. 349 */ 350 printf("Must RESET board to recover\n"); 351 #ifndef USE_HOSTCC 352 bootstage_error(BOOTSTAGE_ID_DECOMP_IMAGE); 353 #endif 354 355 return BOOTM_ERR_RESET; 356 } 357 358 int bootm_decomp_image(int comp, ulong load, ulong image_start, int type, 359 void *load_buf, void *image_buf, ulong image_len, 360 uint unc_len, ulong *load_end) 361 { 362 int ret = 0; 363 364 *load_end = load; 365 print_decomp_msg(comp, type, load == image_start); 366 367 /* 368 * Load the image to the right place, decompressing if needed. After 369 * this, image_len will be set to the number of uncompressed bytes 370 * loaded, ret will be non-zero on error. 371 */ 372 switch (comp) { 373 case IH_COMP_NONE: 374 if (load == image_start) 375 break; 376 if (image_len <= unc_len) 377 memmove_wd(load_buf, image_buf, image_len, CHUNKSZ); 378 else 379 ret = 1; 380 break; 381 #ifdef CONFIG_GZIP 382 case IH_COMP_GZIP: { 383 ret = gunzip(load_buf, unc_len, image_buf, &image_len); 384 break; 385 } 386 #endif /* CONFIG_GZIP */ 387 #ifdef CONFIG_BZIP2 388 case IH_COMP_BZIP2: { 389 uint size = unc_len; 390 391 /* 392 * If we've got less than 4 MB of malloc() space, 393 * use slower decompression algorithm which requires 394 * at most 2300 KB of memory. 395 */ 396 ret = BZ2_bzBuffToBuffDecompress(load_buf, &size, 397 image_buf, image_len, 398 CONFIG_SYS_MALLOC_LEN < (4096 * 1024), 0); 399 image_len = size; 400 break; 401 } 402 #endif /* CONFIG_BZIP2 */ 403 #ifdef CONFIG_LZMA 404 case IH_COMP_LZMA: { 405 SizeT lzma_len = unc_len; 406 407 ret = lzmaBuffToBuffDecompress(load_buf, &lzma_len, 408 image_buf, image_len); 409 image_len = lzma_len; 410 break; 411 } 412 #endif /* CONFIG_LZMA */ 413 #ifdef CONFIG_LZO 414 case IH_COMP_LZO: { 415 size_t size = unc_len; 416 417 ret = lzop_decompress(image_buf, image_len, load_buf, &size); 418 image_len = size; 419 break; 420 } 421 #endif /* CONFIG_LZO */ 422 #ifdef CONFIG_LZ4 423 case IH_COMP_LZ4: { 424 size_t size = unc_len; 425 426 ret = ulz4fn(image_buf, image_len, load_buf, &size); 427 image_len = size; 428 break; 429 } 430 #endif /* CONFIG_LZ4 */ 431 default: 432 printf("Unimplemented compression type %d\n", comp); 433 return BOOTM_ERR_UNIMPLEMENTED; 434 } 435 436 if (ret) 437 return handle_decomp_error(comp, image_len, unc_len, ret); 438 *load_end = load + image_len; 439 440 puts("OK\n"); 441 442 return 0; 443 } 444 445 #ifndef USE_HOSTCC 446 static int bootm_load_os(bootm_headers_t *images, int boot_progress) 447 { 448 image_info_t os = images->os; 449 ulong load = os.load; 450 ulong load_end; 451 ulong blob_start = os.start; 452 ulong blob_end = os.end; 453 ulong image_start = os.image_start; 454 ulong image_len = os.image_len; 455 ulong flush_start = ALIGN_DOWN(load, ARCH_DMA_MINALIGN); 456 ulong flush_len; 457 bool no_overlap; 458 void *load_buf, *image_buf; 459 int err; 460 461 load_buf = map_sysmem(load, 0); 462 image_buf = map_sysmem(os.image_start, image_len); 463 err = bootm_decomp_image(os.comp, load, os.image_start, os.type, 464 load_buf, image_buf, image_len, 465 CONFIG_SYS_BOOTM_LEN, &load_end); 466 if (err) { 467 bootstage_error(BOOTSTAGE_ID_DECOMP_IMAGE); 468 return err; 469 } 470 471 flush_len = load_end - load; 472 if (flush_start < load) 473 flush_len += load - flush_start; 474 475 flush_cache(flush_start, ALIGN(flush_len, ARCH_DMA_MINALIGN)); 476 477 debug(" kernel loaded at 0x%08lx, end = 0x%08lx\n", load, load_end); 478 bootstage_mark(BOOTSTAGE_ID_KERNEL_LOADED); 479 480 no_overlap = (os.comp == IH_COMP_NONE && load == image_start); 481 482 if (!no_overlap && load < blob_end && load_end > blob_start) { 483 debug("images.os.start = 0x%lX, images.os.end = 0x%lx\n", 484 blob_start, blob_end); 485 debug("images.os.load = 0x%lx, load_end = 0x%lx\n", load, 486 load_end); 487 488 /* Check what type of image this is. */ 489 if (images->legacy_hdr_valid) { 490 if (image_get_type(&images->legacy_hdr_os_copy) 491 == IH_TYPE_MULTI) 492 puts("WARNING: legacy format multi component image overwritten\n"); 493 return BOOTM_ERR_OVERLAP; 494 } else { 495 puts("ERROR: new format image overwritten - must RESET the board to recover\n"); 496 bootstage_error(BOOTSTAGE_ID_OVERWRITTEN); 497 return BOOTM_ERR_RESET; 498 } 499 } 500 501 lmb_reserve(&images->lmb, images->os.load, (load_end - 502 images->os.load)); 503 return 0; 504 } 505 506 /** 507 * bootm_disable_interrupts() - Disable interrupts in preparation for load/boot 508 * 509 * @return interrupt flag (0 if interrupts were disabled, non-zero if they were 510 * enabled) 511 */ 512 ulong bootm_disable_interrupts(void) 513 { 514 ulong iflag; 515 516 /* 517 * We have reached the point of no return: we are going to 518 * overwrite all exception vector code, so we cannot easily 519 * recover from any failures any more... 520 */ 521 iflag = disable_interrupts(); 522 #ifdef CONFIG_NETCONSOLE 523 /* Stop the ethernet stack if NetConsole could have left it up */ 524 eth_halt(); 525 # ifndef CONFIG_DM_ETH 526 eth_unregister(eth_get_dev()); 527 # endif 528 #endif 529 530 #if defined(CONFIG_CMD_USB) 531 /* 532 * turn off USB to prevent the host controller from writing to the 533 * SDRAM while Linux is booting. This could happen (at least for OHCI 534 * controller), because the HCCA (Host Controller Communication Area) 535 * lies within the SDRAM and the host controller writes continously to 536 * this area (as busmaster!). The HccaFrameNumber is for example 537 * updated every 1 ms within the HCCA structure in SDRAM! For more 538 * details see the OpenHCI specification. 539 */ 540 usb_stop(); 541 #endif 542 return iflag; 543 } 544 545 #if defined(CONFIG_SILENT_CONSOLE) && !defined(CONFIG_SILENT_U_BOOT_ONLY) 546 547 #define CONSOLE_ARG "console=" 548 #define CONSOLE_ARG_LEN (sizeof(CONSOLE_ARG) - 1) 549 550 static void fixup_silent_linux(void) 551 { 552 char *buf; 553 const char *env_val; 554 char *cmdline = env_get("bootargs"); 555 int want_silent; 556 557 /* 558 * Only fix cmdline when requested. The environment variable can be: 559 * 560 * no - we never fixup 561 * yes - we always fixup 562 * unset - we rely on the console silent flag 563 */ 564 want_silent = env_get_yesno("silent_linux"); 565 if (want_silent == 0) 566 return; 567 else if (want_silent == -1 && !(gd->flags & GD_FLG_SILENT)) 568 return; 569 570 debug("before silent fix-up: %s\n", cmdline); 571 if (cmdline && (cmdline[0] != '\0')) { 572 char *start = strstr(cmdline, CONSOLE_ARG); 573 574 /* Allocate space for maximum possible new command line */ 575 buf = malloc(strlen(cmdline) + 1 + CONSOLE_ARG_LEN + 1); 576 if (!buf) { 577 debug("%s: out of memory\n", __func__); 578 return; 579 } 580 581 if (start) { 582 char *end = strchr(start, ' '); 583 int num_start_bytes = start - cmdline + CONSOLE_ARG_LEN; 584 585 strncpy(buf, cmdline, num_start_bytes); 586 if (end) 587 strcpy(buf + num_start_bytes, end); 588 else 589 buf[num_start_bytes] = '\0'; 590 } else { 591 sprintf(buf, "%s %s", cmdline, CONSOLE_ARG); 592 } 593 env_val = buf; 594 } else { 595 buf = NULL; 596 env_val = CONSOLE_ARG; 597 } 598 599 env_set("bootargs", env_val); 600 debug("after silent fix-up: %s\n", env_val); 601 free(buf); 602 } 603 #endif /* CONFIG_SILENT_CONSOLE */ 604 605 /** 606 * Execute selected states of the bootm command. 607 * 608 * Note the arguments to this state must be the first argument, Any 'bootm' 609 * or sub-command arguments must have already been taken. 610 * 611 * Note that if states contains more than one flag it MUST contain 612 * BOOTM_STATE_START, since this handles and consumes the command line args. 613 * 614 * Also note that aside from boot_os_fn functions and bootm_load_os no other 615 * functions we store the return value of in 'ret' may use a negative return 616 * value, without special handling. 617 * 618 * @param cmdtp Pointer to bootm command table entry 619 * @param flag Command flags (CMD_FLAG_...) 620 * @param argc Number of subcommand arguments (0 = no arguments) 621 * @param argv Arguments 622 * @param states Mask containing states to run (BOOTM_STATE_...) 623 * @param images Image header information 624 * @param boot_progress 1 to show boot progress, 0 to not do this 625 * @return 0 if ok, something else on error. Some errors will cause this 626 * function to perform a reboot! If states contains BOOTM_STATE_OS_GO 627 * then the intent is to boot an OS, so this function will not return 628 * unless the image type is standalone. 629 */ 630 int do_bootm_states(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[], 631 int states, bootm_headers_t *images, int boot_progress) 632 { 633 boot_os_fn *boot_fn; 634 ulong iflag = 0; 635 int ret = 0, need_boot_fn; 636 637 images->state |= states; 638 639 /* 640 * Work through the states and see how far we get. We stop on 641 * any error. 642 */ 643 if (states & BOOTM_STATE_START) 644 ret = bootm_start(cmdtp, flag, argc, argv); 645 646 if (!ret && (states & BOOTM_STATE_FINDOS)) 647 ret = bootm_find_os(cmdtp, flag, argc, argv); 648 649 if (!ret && (states & BOOTM_STATE_FINDOTHER)) 650 ret = bootm_find_other(cmdtp, flag, argc, argv); 651 652 /* Load the OS */ 653 if (!ret && (states & BOOTM_STATE_LOADOS)) { 654 iflag = bootm_disable_interrupts(); 655 ret = bootm_load_os(images, 0); 656 if (ret && ret != BOOTM_ERR_OVERLAP) 657 goto err; 658 else if (ret == BOOTM_ERR_OVERLAP) 659 ret = 0; 660 } 661 662 /* Relocate the ramdisk */ 663 #ifdef CONFIG_SYS_BOOT_RAMDISK_HIGH 664 if (!ret && (states & BOOTM_STATE_RAMDISK)) { 665 ulong rd_len = images->rd_end - images->rd_start; 666 667 ret = boot_ramdisk_high(&images->lmb, images->rd_start, 668 rd_len, &images->initrd_start, &images->initrd_end); 669 if (!ret) { 670 env_set_hex("initrd_start", images->initrd_start); 671 env_set_hex("initrd_end", images->initrd_end); 672 } 673 } 674 #endif 675 #if IMAGE_ENABLE_OF_LIBFDT && defined(CONFIG_LMB) 676 if (!ret && (states & BOOTM_STATE_FDT)) { 677 boot_fdt_add_mem_rsv_regions(&images->lmb, images->ft_addr); 678 ret = boot_relocate_fdt(&images->lmb, &images->ft_addr, 679 &images->ft_len); 680 } 681 #endif 682 683 /* From now on, we need the OS boot function */ 684 if (ret) 685 return ret; 686 boot_fn = bootm_os_get_boot_func(images->os.os); 687 need_boot_fn = states & (BOOTM_STATE_OS_CMDLINE | 688 BOOTM_STATE_OS_BD_T | BOOTM_STATE_OS_PREP | 689 BOOTM_STATE_OS_FAKE_GO | BOOTM_STATE_OS_GO); 690 if (boot_fn == NULL && need_boot_fn) { 691 if (iflag) 692 enable_interrupts(); 693 printf("ERROR: booting os '%s' (%d) is not supported\n", 694 genimg_get_os_name(images->os.os), images->os.os); 695 bootstage_error(BOOTSTAGE_ID_CHECK_BOOT_OS); 696 return 1; 697 } 698 699 700 /* Call various other states that are not generally used */ 701 if (!ret && (states & BOOTM_STATE_OS_CMDLINE)) 702 ret = boot_fn(BOOTM_STATE_OS_CMDLINE, argc, argv, images); 703 if (!ret && (states & BOOTM_STATE_OS_BD_T)) 704 ret = boot_fn(BOOTM_STATE_OS_BD_T, argc, argv, images); 705 if (!ret && (states & BOOTM_STATE_OS_PREP)) { 706 #if defined(CONFIG_SILENT_CONSOLE) && !defined(CONFIG_SILENT_U_BOOT_ONLY) 707 if (images->os.os == IH_OS_LINUX) 708 fixup_silent_linux(); 709 #endif 710 ret = boot_fn(BOOTM_STATE_OS_PREP, argc, argv, images); 711 } 712 713 #ifdef CONFIG_TRACE 714 /* Pretend to run the OS, then run a user command */ 715 if (!ret && (states & BOOTM_STATE_OS_FAKE_GO)) { 716 char *cmd_list = env_get("fakegocmd"); 717 718 ret = boot_selected_os(argc, argv, BOOTM_STATE_OS_FAKE_GO, 719 images, boot_fn); 720 if (!ret && cmd_list) 721 ret = run_command_list(cmd_list, -1, flag); 722 } 723 #endif 724 725 /* Check for unsupported subcommand. */ 726 if (ret) { 727 puts("subcommand not supported\n"); 728 return ret; 729 } 730 731 /* Now run the OS! We hope this doesn't return */ 732 if (!ret && (states & BOOTM_STATE_OS_GO)) 733 ret = boot_selected_os(argc, argv, BOOTM_STATE_OS_GO, 734 images, boot_fn); 735 736 /* Deal with any fallout */ 737 err: 738 if (iflag) 739 enable_interrupts(); 740 741 if (ret == BOOTM_ERR_UNIMPLEMENTED) 742 bootstage_error(BOOTSTAGE_ID_DECOMP_UNIMPL); 743 else if (ret == BOOTM_ERR_RESET) 744 do_reset(cmdtp, flag, argc, argv); 745 746 return ret; 747 } 748 749 #if defined(CONFIG_IMAGE_FORMAT_LEGACY) 750 /** 751 * image_get_kernel - verify legacy format kernel image 752 * @img_addr: in RAM address of the legacy format image to be verified 753 * @verify: data CRC verification flag 754 * 755 * image_get_kernel() verifies legacy image integrity and returns pointer to 756 * legacy image header if image verification was completed successfully. 757 * 758 * returns: 759 * pointer to a legacy image header if valid image was found 760 * otherwise return NULL 761 */ 762 static image_header_t *image_get_kernel(ulong img_addr, int verify) 763 { 764 image_header_t *hdr = (image_header_t *)img_addr; 765 766 if (!image_check_magic(hdr)) { 767 puts("Bad Magic Number\n"); 768 bootstage_error(BOOTSTAGE_ID_CHECK_MAGIC); 769 return NULL; 770 } 771 bootstage_mark(BOOTSTAGE_ID_CHECK_HEADER); 772 773 if (!image_check_hcrc(hdr)) { 774 puts("Bad Header Checksum\n"); 775 bootstage_error(BOOTSTAGE_ID_CHECK_HEADER); 776 return NULL; 777 } 778 779 bootstage_mark(BOOTSTAGE_ID_CHECK_CHECKSUM); 780 image_print_contents(hdr); 781 782 if (verify) { 783 puts(" Verifying Checksum ... "); 784 if (!image_check_dcrc(hdr)) { 785 printf("Bad Data CRC\n"); 786 bootstage_error(BOOTSTAGE_ID_CHECK_CHECKSUM); 787 return NULL; 788 } 789 puts("OK\n"); 790 } 791 bootstage_mark(BOOTSTAGE_ID_CHECK_ARCH); 792 793 if (!image_check_target_arch(hdr)) { 794 printf("Unsupported Architecture 0x%x\n", image_get_arch(hdr)); 795 bootstage_error(BOOTSTAGE_ID_CHECK_ARCH); 796 return NULL; 797 } 798 return hdr; 799 } 800 #endif 801 802 /** 803 * boot_get_kernel - find kernel image 804 * @os_data: pointer to a ulong variable, will hold os data start address 805 * @os_len: pointer to a ulong variable, will hold os data length 806 * 807 * boot_get_kernel() tries to find a kernel image, verifies its integrity 808 * and locates kernel data. 809 * 810 * returns: 811 * pointer to image header if valid image was found, plus kernel start 812 * address and length, otherwise NULL 813 */ 814 static const void *boot_get_kernel(cmd_tbl_t *cmdtp, int flag, int argc, 815 char * const argv[], bootm_headers_t *images, 816 ulong *os_data, ulong *os_len) 817 { 818 #if defined(CONFIG_IMAGE_FORMAT_LEGACY) 819 image_header_t *hdr; 820 #endif 821 ulong img_addr; 822 const void *buf; 823 const char *fit_uname_config = NULL; 824 const char *fit_uname_kernel = NULL; 825 #if IMAGE_ENABLE_FIT 826 int os_noffset; 827 #endif 828 829 img_addr = genimg_get_kernel_addr_fit(argc < 1 ? NULL : argv[0], 830 &fit_uname_config, 831 &fit_uname_kernel); 832 833 bootstage_mark(BOOTSTAGE_ID_CHECK_MAGIC); 834 835 /* check image type, for FIT images get FIT kernel node */ 836 *os_data = *os_len = 0; 837 buf = map_sysmem(img_addr, 0); 838 switch (genimg_get_format(buf)) { 839 #if defined(CONFIG_IMAGE_FORMAT_LEGACY) 840 case IMAGE_FORMAT_LEGACY: 841 printf("## Booting kernel from Legacy Image at %08lx ...\n", 842 img_addr); 843 hdr = image_get_kernel(img_addr, images->verify); 844 if (!hdr) 845 return NULL; 846 bootstage_mark(BOOTSTAGE_ID_CHECK_IMAGETYPE); 847 848 /* get os_data and os_len */ 849 switch (image_get_type(hdr)) { 850 case IH_TYPE_KERNEL: 851 case IH_TYPE_KERNEL_NOLOAD: 852 *os_data = image_get_data(hdr); 853 *os_len = image_get_data_size(hdr); 854 break; 855 case IH_TYPE_MULTI: 856 image_multi_getimg(hdr, 0, os_data, os_len); 857 break; 858 case IH_TYPE_STANDALONE: 859 *os_data = image_get_data(hdr); 860 *os_len = image_get_data_size(hdr); 861 break; 862 default: 863 printf("Wrong Image Type for %s command\n", 864 cmdtp->name); 865 bootstage_error(BOOTSTAGE_ID_CHECK_IMAGETYPE); 866 return NULL; 867 } 868 869 /* 870 * copy image header to allow for image overwrites during 871 * kernel decompression. 872 */ 873 memmove(&images->legacy_hdr_os_copy, hdr, 874 sizeof(image_header_t)); 875 876 /* save pointer to image header */ 877 images->legacy_hdr_os = hdr; 878 879 images->legacy_hdr_valid = 1; 880 bootstage_mark(BOOTSTAGE_ID_DECOMP_IMAGE); 881 break; 882 #endif 883 #if IMAGE_ENABLE_FIT 884 case IMAGE_FORMAT_FIT: 885 os_noffset = fit_image_load(images, img_addr, 886 &fit_uname_kernel, &fit_uname_config, 887 IH_ARCH_DEFAULT, IH_TYPE_KERNEL, 888 BOOTSTAGE_ID_FIT_KERNEL_START, 889 FIT_LOAD_IGNORED, os_data, os_len); 890 if (os_noffset < 0) 891 return NULL; 892 893 images->fit_hdr_os = map_sysmem(img_addr, 0); 894 images->fit_uname_os = fit_uname_kernel; 895 images->fit_uname_cfg = fit_uname_config; 896 images->fit_noffset_os = os_noffset; 897 break; 898 #endif 899 #ifdef CONFIG_ANDROID_BOOT_IMAGE 900 case IMAGE_FORMAT_ANDROID: 901 printf("## Booting Android Image at 0x%08lx ...\n", img_addr); 902 if (android_image_get_kernel(buf, images->verify, 903 os_data, os_len)) 904 return NULL; 905 break; 906 #endif 907 default: 908 printf("Wrong Image Format for %s command\n", cmdtp->name); 909 bootstage_error(BOOTSTAGE_ID_FIT_KERNEL_INFO); 910 return NULL; 911 } 912 913 debug(" kernel data at 0x%08lx, len = 0x%08lx (%ld)\n", 914 *os_data, *os_len, *os_len); 915 916 return buf; 917 } 918 #else /* USE_HOSTCC */ 919 920 void memmove_wd(void *to, void *from, size_t len, ulong chunksz) 921 { 922 memmove(to, from, len); 923 } 924 925 static int bootm_host_load_image(const void *fit, int req_image_type) 926 { 927 const char *fit_uname_config = NULL; 928 ulong data, len; 929 bootm_headers_t images; 930 int noffset; 931 ulong load_end; 932 uint8_t image_type; 933 uint8_t imape_comp; 934 void *load_buf; 935 int ret; 936 937 memset(&images, '\0', sizeof(images)); 938 images.verify = 1; 939 noffset = fit_image_load(&images, (ulong)fit, 940 NULL, &fit_uname_config, 941 IH_ARCH_DEFAULT, req_image_type, -1, 942 FIT_LOAD_IGNORED, &data, &len); 943 if (noffset < 0) 944 return noffset; 945 if (fit_image_get_type(fit, noffset, &image_type)) { 946 puts("Can't get image type!\n"); 947 return -EINVAL; 948 } 949 950 if (fit_image_get_comp(fit, noffset, &imape_comp)) { 951 puts("Can't get image compression!\n"); 952 return -EINVAL; 953 } 954 955 /* Allow the image to expand by a factor of 4, should be safe */ 956 load_buf = malloc((1 << 20) + len * 4); 957 ret = bootm_decomp_image(imape_comp, 0, data, image_type, load_buf, 958 (void *)data, len, CONFIG_SYS_BOOTM_LEN, 959 &load_end); 960 free(load_buf); 961 962 if (ret && ret != BOOTM_ERR_UNIMPLEMENTED) 963 return ret; 964 965 return 0; 966 } 967 968 int bootm_host_load_images(const void *fit, int cfg_noffset) 969 { 970 static uint8_t image_types[] = { 971 IH_TYPE_KERNEL, 972 IH_TYPE_FLATDT, 973 IH_TYPE_RAMDISK, 974 }; 975 int err = 0; 976 int i; 977 978 for (i = 0; i < ARRAY_SIZE(image_types); i++) { 979 int ret; 980 981 ret = bootm_host_load_image(fit, image_types[i]); 982 if (!err && ret && ret != -ENOENT) 983 err = ret; 984 } 985 986 /* Return the first error we found */ 987 return err; 988 } 989 990 #endif /* ndef USE_HOSTCC */ 991