common/spl/spl.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * (C) Copyright 2010
   4  * Texas Instruments, <www.ti.com>
   5  *
   6  * Aneesh V <aneesh@ti.com>
   7  */
   8
   9 #include <common.h>
  10 #include <bloblist.h>
  11 #include <binman_sym.h>
  12 #include <dm.h>
  13 #include <handoff.h>
  14 #include <hang.h>
  15 #include <irq_func.h>
  16 #include <serial.h>
  17 #include <spl.h>
  18 #include <asm/u-boot.h>
  19 #include <nand.h>
  20 #include <fat.h>
  21 #include <u-boot/crc.h>
  22 #include <version.h>
  23 #include <image.h>
  24 #include <malloc.h>
  25 #include <mapmem.h>
  26 #include <dm/root.h>
  27 #include <linux/compiler.h>
  28 #include <fdt_support.h>
  29 #include <bootcount.h>
  30 #include <wdt.h>
  31
  32 DECLARE_GLOBAL_DATA_PTR;
  33
  34 #ifndef CONFIG_SYS_UBOOT_START
  35 #define CONFIG_SYS_UBOOT_START  CONFIG_SYS_TEXT_BASE
  36 #endif
  37 #ifndef CONFIG_SYS_MONITOR_LEN
  38 /* Unknown U-Boot size, let's assume it will not be more than 200 KB */
  39 #define CONFIG_SYS_MONITOR_LEN  (200 * 1024)
  40 #endif
  41
  42 u32 *boot_params_ptr = NULL;
  43
  44 /* See spl.h for information about this */
  45 binman_sym_declare(ulong, u_boot_any, image_pos);
  46 binman_sym_declare(ulong, u_boot_any, size);
  47
  48 #ifdef CONFIG_TPL
  49 binman_sym_declare(ulong, spl, image_pos);
  50 binman_sym_declare(ulong, spl, size);
  51 #endif
  52
  53 /* Define board data structure */
  54 static bd_t bdata __attribute__ ((section(".data")));
  55
  56 /*
  57  * Board-specific Platform code can reimplement show_boot_progress () if needed
  58  */
  59 __weak void show_boot_progress(int val) {}
  60
  61 #if defined(CONFIG_SPL_OS_BOOT) || CONFIG_IS_ENABLED(HANDOFF)
  62 /* weak, default platform-specific function to initialize dram banks */
  63 __weak int dram_init_banksize(void)
  64 {
  65         return 0;
  66 }
  67 #endif
  68
  69 /*
  70  * Default function to determine if u-boot or the OS should
  71  * be started. This implementation always returns 1.
  72  *
  73  * Please implement your own board specific funcion to do this.
  74  *
  75  * RETURN
  76  * 0 to not start u-boot
  77  * positive if u-boot should start
  78  */
  79 #ifdef CONFIG_SPL_OS_BOOT
  80 __weak int spl_start_uboot(void)
  81 {
  82         puts(SPL_TPL_PROMPT
  83              "Please implement spl_start_uboot() for your board\n");
  84         puts(SPL_TPL_PROMPT "Direct Linux boot not active!\n");
  85         return 1;
  86 }
  87
  88 /*
  89  * Weak default function for arch specific zImage check. Return zero
  90  * and fill start and end address if image is recognized.
  91  */
  92 int __weak bootz_setup(ulong image, ulong *start, ulong *end)
  93 {
  94          return 1;
  95 }
  96 #endif
  97
  98 /* Weak default function for arch/board-specific fixups to the spl_image_info */
  99 void __weak spl_perform_fixups(struct spl_image_info *spl_image)
 100 {
 101 }
 102
 103 void spl_fixup_fdt(void)
 104 {
 105 #if defined(CONFIG_SPL_OF_LIBFDT) && defined(CONFIG_SYS_SPL_ARGS_ADDR)
 106         void *fdt_blob = (void *)CONFIG_SYS_SPL_ARGS_ADDR;
 107         int err;
 108
 109         err = fdt_check_header(fdt_blob);
 110         if (err < 0) {
 111                 printf("fdt_root: %s\n", fdt_strerror(err));
 112                 return;
 113         }
 114
 115         /* fixup the memory dt node */
 116         err = fdt_shrink_to_minimum(fdt_blob, 0);
 117         if (err == 0) {
 118                 printf(SPL_TPL_PROMPT "fdt_shrink_to_minimum err - %d\n", err);
 119                 return;
 120         }
 121
 122         err = arch_fixup_fdt(fdt_blob);
 123         if (err) {
 124                 printf(SPL_TPL_PROMPT "arch_fixup_fdt err - %d\n", err);
 125                 return;
 126         }
 127 #endif
 128 }
 129
 130 ulong spl_get_image_pos(void)
 131 {
 132         return spl_phase() == PHASE_TPL ?
 133                 binman_sym(ulong, spl, image_pos) :
 134                 binman_sym(ulong, u_boot_any, image_pos);
 135 }
 136
 137 ulong spl_get_image_size(void)
 138 {
 139         return spl_phase() == PHASE_TPL ?
 140                 binman_sym(ulong, spl, size) :
 141                 binman_sym(ulong, u_boot_any, size);
 142 }
 143
 144 /*
 145  * Weak default function for board specific cleanup/preparation before
 146  * Linux boot. Some boards/platforms might not need it, so just provide
 147  * an empty stub here.
 148  */
 149 __weak void spl_board_prepare_for_linux(void)
 150 {
 151         /* Nothing to do! */
 152 }
 153
 154 __weak void spl_board_prepare_for_boot(void)
 155 {
 156         /* Nothing to do! */
 157 }
 158
 159 __weak struct image_header *spl_get_load_buffer(ssize_t offset, size_t size)
 160 {
 161         return (struct image_header *)(CONFIG_SYS_TEXT_BASE + offset);
 162 }
 163
 164 void spl_set_header_raw_uboot(struct spl_image_info *spl_image)
 165 {
 166         ulong u_boot_pos = binman_sym(ulong, u_boot_any, image_pos);
 167
 168         spl_image->size = CONFIG_SYS_MONITOR_LEN;
 169
 170         /*
 171          * Binman error cases: address of the end of the previous region or the
 172          * start of the image's entry area (usually 0) if there is no previous
 173          * region.
 174          */
 175         if (u_boot_pos && u_boot_pos != BINMAN_SYM_MISSING) {
 176                 /* Binman does not support separated entry addresses */
 177                 spl_image->entry_point = u_boot_pos;
 178                 spl_image->load_addr = u_boot_pos;
 179         } else {
 180                 spl_image->entry_point = CONFIG_SYS_UBOOT_START;
 181                 spl_image->load_addr = CONFIG_SYS_TEXT_BASE;
 182         }
 183         spl_image->os = IH_OS_U_BOOT;
 184         spl_image->name = "U-Boot";
 185 }
 186
 187 #ifdef CONFIG_SPL_LOAD_FIT_FULL
 188 /* Parse and load full fitImage in SPL */
 189 static int spl_load_fit_image(struct spl_image_info *spl_image,
 190                               const struct image_header *header)
 191 {
 192         bootm_headers_t images;
 193         const char *fit_uname_config = NULL;
 194         const char *fit_uname_fdt = FIT_FDT_PROP;
 195         const char *uname;
 196         ulong fw_data = 0, dt_data = 0, img_data = 0;
 197         ulong fw_len = 0, dt_len = 0, img_len = 0;
 198         int idx, conf_noffset;
 199         int ret;
 200
 201 #ifdef CONFIG_SPL_FIT_SIGNATURE
 202         images.verify = 1;
 203 #endif
 204         ret = fit_image_load(&images, (ulong)header,
 205                              NULL, &fit_uname_config,
 206                              IH_ARCH_DEFAULT, IH_TYPE_STANDALONE, -1,
 207                              FIT_LOAD_REQUIRED, &fw_data, &fw_len);
 208         if (ret < 0)
 209                 return ret;
 210
 211         spl_image->size = fw_len;
 212         spl_image->entry_point = fw_data;
 213         spl_image->load_addr = fw_data;
 214         spl_image->os = IH_OS_U_BOOT;
 215         spl_image->name = "U-Boot";
 216
 217         debug(SPL_TPL_PROMPT "payload image: %32s load addr: 0x%lx size: %d\n",
 218               spl_image->name, spl_image->load_addr, spl_image->size);
 219
 220 #ifdef CONFIG_SPL_FIT_SIGNATURE
 221         images.verify = 1;
 222 #endif
 223         ret = fit_image_load(&images, (ulong)header,
 224                        &fit_uname_fdt, &fit_uname_config,
 225                        IH_ARCH_DEFAULT, IH_TYPE_FLATDT, -1,
 226                        FIT_LOAD_OPTIONAL, &dt_data, &dt_len);
 227         if (ret >= 0)
 228                 spl_image->fdt_addr = (void *)dt_data;
 229
 230         conf_noffset = fit_conf_get_node((const void *)header,
 231                                          fit_uname_config);
 232         if (conf_noffset <= 0)
 233                 return 0;
 234
 235         for (idx = 0;
 236              uname = fdt_stringlist_get((const void *)header, conf_noffset,
 237                                         FIT_LOADABLE_PROP, idx,
 238                                 NULL), uname;
 239              idx++)
 240         {
 241 #ifdef CONFIG_SPL_FIT_SIGNATURE
 242                 images.verify = 1;
 243 #endif
 244                 ret = fit_image_load(&images, (ulong)header,
 245                                      &uname, &fit_uname_config,
 246                                      IH_ARCH_DEFAULT, IH_TYPE_LOADABLE, -1,
 247                                      FIT_LOAD_OPTIONAL_NON_ZERO,
 248                                      &img_data, &img_len);
 249                 if (ret < 0)
 250                         return ret;
 251         }
 252
 253         return 0;
 254 }
 255 #endif
 256
 257 __weak int spl_parse_legacy_header(struct spl_image_info *spl_image,
 258                                    const struct image_header *header)
 259 {
 260         /* LEGACY image not supported */
 261         debug("Legacy boot image support not enabled, proceeding to other boot methods\n");
 262         return -EINVAL;
 263 }
 264
 265 int spl_parse_image_header(struct spl_image_info *spl_image,
 266                            const struct image_header *header)
 267 {
 268 #ifdef CONFIG_SPL_LOAD_FIT_FULL
 269         int ret = spl_load_fit_image(spl_image, header);
 270
 271         if (!ret)
 272                 return ret;
 273 #endif
 274         if (image_get_magic(header) == IH_MAGIC) {
 275                 int ret;
 276
 277                 ret = spl_parse_legacy_header(spl_image, header);
 278                 if (ret)
 279                         return ret;
 280         } else {
 281 #ifdef CONFIG_SPL_PANIC_ON_RAW_IMAGE
 282                 /*
 283                  * CONFIG_SPL_PANIC_ON_RAW_IMAGE is defined when the
 284                  * code which loads images in SPL cannot guarantee that
 285                  * absolutely all read errors will be reported.
 286                  * An example is the LPC32XX MLC NAND driver, which
 287                  * will consider that a completely unreadable NAND block
 288                  * is bad, and thus should be skipped silently.
 289                  */
 290                 panic("** no mkimage signature but raw image not supported");
 291 #endif
 292
 293 #ifdef CONFIG_SPL_OS_BOOT
 294                 ulong start, end;
 295
 296                 if (!bootz_setup((ulong)header, &start, &end)) {
 297                         spl_image->name = "Linux";
 298                         spl_image->os = IH_OS_LINUX;
 299                         spl_image->load_addr = CONFIG_SYS_LOAD_ADDR;
 300                         spl_image->entry_point = CONFIG_SYS_LOAD_ADDR;
 301                         spl_image->size = end - start;
 302                         debug(SPL_TPL_PROMPT
 303                               "payload zImage, load addr: 0x%lx size: %d\n",
 304                               spl_image->load_addr, spl_image->size);
 305                         return 0;
 306                 }
 307 #endif
 308
 309 #ifdef CONFIG_SPL_RAW_IMAGE_SUPPORT
 310                 /* Signature not found - assume u-boot.bin */
 311                 debug("mkimage signature not found - ih_magic = %x\n",
 312                         header->ih_magic);
 313                 spl_set_header_raw_uboot(spl_image);
 314 #else
 315                 /* RAW image not supported, proceed to other boot methods. */
 316                 debug("Raw boot image support not enabled, proceeding to other boot methods\n");
 317                 return -EINVAL;
 318 #endif
 319         }
 320
 321         return 0;
 322 }
 323
 324 __weak void __noreturn jump_to_image_no_args(struct spl_image_info *spl_image)
 325 {
 326         typedef void __noreturn (*image_entry_noargs_t)(void);
 327
 328         image_entry_noargs_t image_entry =
 329                 (image_entry_noargs_t)spl_image->entry_point;
 330
 331         debug("image entry point: 0x%lx\n", spl_image->entry_point);
 332         image_entry();
 333 }
 334
 335 #if CONFIG_IS_ENABLED(HANDOFF)
 336 /**
 337  * Set up the SPL hand-off information
 338  *
 339  * This is initially empty (zero) but can be written by
 340  */
 341 static int setup_spl_handoff(void)
 342 {
 343         struct spl_handoff *ho;
 344
 345         ho = bloblist_ensure(BLOBLISTT_SPL_HANDOFF, sizeof(struct spl_handoff));
 346         if (!ho)
 347                 return -ENOENT;
 348
 349         return 0;
 350 }
 351
 352 __weak int handoff_arch_save(struct spl_handoff *ho)
 353 {
 354         return 0;
 355 }
 356
 357 static int write_spl_handoff(void)
 358 {
 359         struct spl_handoff *ho;
 360         int ret;
 361
 362         ho = bloblist_find(BLOBLISTT_SPL_HANDOFF, sizeof(struct spl_handoff));
 363         if (!ho)
 364                 return -ENOENT;
 365         handoff_save_dram(ho);
 366         ret = handoff_arch_save(ho);
 367         if (ret)
 368                 return ret;
 369         debug(SPL_TPL_PROMPT "Wrote SPL handoff\n");
 370
 371         return 0;
 372 }
 373 #else
 374 static inline int setup_spl_handoff(void) { return 0; }
 375 static inline int write_spl_handoff(void) { return 0; }
 376
 377 #endif /* HANDOFF */
 378
 379 static int spl_common_init(bool setup_malloc)
 380 {
 381         int ret;
 382
 383 #if CONFIG_VAL(SYS_MALLOC_F_LEN)
 384         if (setup_malloc) {
 385 #ifdef CONFIG_MALLOC_F_ADDR
 386                 gd->malloc_base = CONFIG_MALLOC_F_ADDR;
 387 #endif
 388                 gd->malloc_limit = CONFIG_VAL(SYS_MALLOC_F_LEN);
 389                 gd->malloc_ptr = 0;
 390         }
 391 #endif
 392         ret = bootstage_init(u_boot_first_phase());
 393         if (ret) {
 394                 debug("%s: Failed to set up bootstage: ret=%d\n", __func__,
 395                       ret);
 396                 return ret;
 397         }
 398 #ifdef CONFIG_BOOTSTAGE_STASH
 399         if (!u_boot_first_phase()) {
 400                 const void *stash = map_sysmem(CONFIG_BOOTSTAGE_STASH_ADDR,
 401                                                CONFIG_BOOTSTAGE_STASH_SIZE);
 402
 403                 ret = bootstage_unstash(stash, CONFIG_BOOTSTAGE_STASH_SIZE);
 404                 if (ret)
 405                         debug("%s: Failed to unstash bootstage: ret=%d\n",
 406                               __func__, ret);
 407         }
 408 #endif /* CONFIG_BOOTSTAGE_STASH */
 409         bootstage_mark_name(spl_phase() == PHASE_TPL ? BOOTSTAGE_ID_START_TPL :
 410                             BOOTSTAGE_ID_START_SPL, SPL_TPL_NAME);
 411 #if CONFIG_IS_ENABLED(LOG)
 412         ret = log_init();
 413         if (ret) {
 414                 debug("%s: Failed to set up logging\n", __func__);
 415                 return ret;
 416         }
 417 #endif
 418         if (CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)) {
 419                 ret = fdtdec_setup();
 420                 if (ret) {
 421                         debug("fdtdec_setup() returned error %d\n", ret);
 422                         return ret;
 423                 }
 424         }
 425         if (CONFIG_IS_ENABLED(DM)) {
 426                 bootstage_start(BOOTSTATE_ID_ACCUM_DM_SPL,
 427                                 spl_phase() == PHASE_TPL ? "dm tpl" : "dm_spl");
 428                 /* With CONFIG_SPL_OF_PLATDATA, bring in all devices */
 429                 ret = dm_init_and_scan(!CONFIG_IS_ENABLED(OF_PLATDATA));
 430                 bootstage_accum(BOOTSTATE_ID_ACCUM_DM_SPL);
 431                 if (ret) {
 432                         debug("dm_init_and_scan() returned error %d\n", ret);
 433                         return ret;
 434                 }
 435         }
 436
 437         return 0;
 438 }
 439
 440 void spl_set_bd(void)
 441 {
 442         /*
 443          * NOTE: On some platforms (e.g. x86) bdata may be in flash and not
 444          * writeable.
 445          */
 446         if (!gd->bd)
 447                 gd->bd = &bdata;
 448 }
 449
 450 int spl_early_init(void)
 451 {
 452         int ret;
 453
 454         debug("%s\n", __func__);
 455
 456         ret = spl_common_init(true);
 457         if (ret)
 458                 return ret;
 459         gd->flags |= GD_FLG_SPL_EARLY_INIT;
 460
 461         return 0;
 462 }
 463
 464 int spl_init(void)
 465 {
 466         int ret;
 467         bool setup_malloc = !(IS_ENABLED(CONFIG_SPL_STACK_R) &&
 468                         IS_ENABLED(CONFIG_SPL_SYS_MALLOC_SIMPLE));
 469
 470         debug("%s\n", __func__);
 471
 472         if (!(gd->flags & GD_FLG_SPL_EARLY_INIT)) {
 473                 ret = spl_common_init(setup_malloc);
 474                 if (ret)
 475                         return ret;
 476         }
 477         gd->flags |= GD_FLG_SPL_INIT;
 478
 479         return 0;
 480 }
 481
 482 #ifndef BOOT_DEVICE_NONE
 483 #define BOOT_DEVICE_NONE 0xdeadbeef
 484 #endif
 485
 486 __weak void board_boot_order(u32 *spl_boot_list)
 487 {
 488         spl_boot_list[0] = spl_boot_device();
 489 }
 490
 491 static struct spl_image_loader *spl_ll_find_loader(uint boot_device)
 492 {
 493         struct spl_image_loader *drv =
 494                 ll_entry_start(struct spl_image_loader, spl_image_loader);
 495         const int n_ents =
 496                 ll_entry_count(struct spl_image_loader, spl_image_loader);
 497         struct spl_image_loader *entry;
 498
 499         for (entry = drv; entry != drv + n_ents; entry++) {
 500                 if (boot_device == entry->boot_device)
 501                         return entry;
 502         }
 503
 504         /* Not found */
 505         return NULL;
 506 }
 507
 508 static int spl_load_image(struct spl_image_info *spl_image,
 509                           struct spl_image_loader *loader)
 510 {
 511         int ret;
 512         struct spl_boot_device bootdev;
 513
 514         bootdev.boot_device = loader->boot_device;
 515         bootdev.boot_device_name = NULL;
 516
 517         ret = loader->load_image(spl_image, &bootdev);
 518 #ifdef CONFIG_SPL_LEGACY_IMAGE_CRC_CHECK
 519         if (!ret && spl_image->dcrc_length) {
 520                 /* check data crc */
 521                 ulong dcrc = crc32_wd(0, (unsigned char *)spl_image->dcrc_data,
 522                                       spl_image->dcrc_length, CHUNKSZ_CRC32);
 523                 if (dcrc != spl_image->dcrc) {
 524                         puts("SPL: Image data CRC check failed!\n");
 525                         ret = -EINVAL;
 526                 }
 527         }
 528 #endif
 529         return ret;
 530 }
 531
 532 /**
 533  * boot_from_devices() - Try loading a booting U-Boot from a list of devices
 534  *
 535  * @spl_image: Place to put the image details if successful
 536  * @spl_boot_list: List of boot devices to try
 537  * @count: Number of elements in spl_boot_list
 538  * @return 0 if OK, -ve on error
 539  */
 540 static int boot_from_devices(struct spl_image_info *spl_image,
 541                              u32 spl_boot_list[], int count)
 542 {
 543         int i;
 544
 545         for (i = 0; i < count && spl_boot_list[i] != BOOT_DEVICE_NONE; i++) {
 546                 struct spl_image_loader *loader;
 547
 548                 loader = spl_ll_find_loader(spl_boot_list[i]);
 549 #if defined(CONFIG_SPL_SERIAL_SUPPORT) && defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
 550                 if (loader)
 551                         printf("Trying to boot from %s\n", loader->name);
 552                 else
 553                         puts(SPL_TPL_PROMPT "Unsupported Boot Device!\n");
 554 #endif
 555                 if (loader && !spl_load_image(spl_image, loader)) {
 556                         spl_image->boot_device = spl_boot_list[i];
 557                         return 0;
 558                 }
 559         }
 560
 561         return -ENODEV;
 562 }
 563
 564 #if defined(CONFIG_SPL_FRAMEWORK_BOARD_INIT_F)
 565 void board_init_f(ulong dummy)
 566 {
 567         if (CONFIG_IS_ENABLED(OF_CONTROL)) {
 568                 int ret;
 569
 570                 ret = spl_early_init();
 571                 if (ret) {
 572                         debug("spl_early_init() failed: %d\n", ret);
 573                         hang();
 574                 }
 575         }
 576
 577         preloader_console_init();
 578 }
 579 #endif
 580
 581 void board_init_r(gd_t *dummy1, ulong dummy2)
 582 {
 583         u32 spl_boot_list[] = {
 584                 BOOT_DEVICE_NONE,
 585                 BOOT_DEVICE_NONE,
 586                 BOOT_DEVICE_NONE,
 587                 BOOT_DEVICE_NONE,
 588                 BOOT_DEVICE_NONE,
 589         };
 590         struct spl_image_info spl_image;
 591         int ret;
 592
 593         debug(">>" SPL_TPL_PROMPT "board_init_r()\n");
 594
 595         spl_set_bd();
 596
 597 #if defined(CONFIG_SYS_SPL_MALLOC_START)
 598         mem_malloc_init(CONFIG_SYS_SPL_MALLOC_START,
 599                         CONFIG_SYS_SPL_MALLOC_SIZE);
 600         gd->flags |= GD_FLG_FULL_MALLOC_INIT;
 601 #endif
 602         if (!(gd->flags & GD_FLG_SPL_INIT)) {
 603                 if (spl_init())
 604                         hang();
 605         }
 606 #if !defined(CONFIG_PPC) && !defined(CONFIG_ARCH_MX6)
 607         /*
 608          * timer_init() does not exist on PPC systems. The timer is initialized
 609          * and enabled (decrementer) in interrupt_init() here.
 610          */
 611         timer_init();
 612 #endif
 613         if (CONFIG_IS_ENABLED(BLOBLIST)) {
 614                 ret = bloblist_init();
 615                 if (ret) {
 616                         debug("%s: Failed to set up bloblist: ret=%d\n",
 617                               __func__, ret);
 618                         puts(SPL_TPL_PROMPT "Cannot set up bloblist\n");
 619                         hang();
 620                 }
 621         }
 622         if (CONFIG_IS_ENABLED(HANDOFF)) {
 623                 int ret;
 624
 625                 ret = setup_spl_handoff();
 626                 if (ret) {
 627                         puts(SPL_TPL_PROMPT "Cannot set up SPL handoff\n");
 628                         hang();
 629                 }
 630         }
 631
 632 #if CONFIG_IS_ENABLED(BOARD_INIT)
 633         spl_board_init();
 634 #endif
 635
 636 #if defined(CONFIG_SPL_WATCHDOG_SUPPORT) && CONFIG_IS_ENABLED(WDT)
 637         initr_watchdog();
 638 #endif
 639
 640         if (IS_ENABLED(CONFIG_SPL_OS_BOOT) || CONFIG_IS_ENABLED(HANDOFF))
 641                 dram_init_banksize();
 642
 643         bootcount_inc();
 644
 645         memset(&spl_image, '\0', sizeof(spl_image));
 646 #ifdef CONFIG_SYS_SPL_ARGS_ADDR
 647         spl_image.arg = (void *)CONFIG_SYS_SPL_ARGS_ADDR;
 648 #endif
 649         spl_image.boot_device = BOOT_DEVICE_NONE;
 650         board_boot_order(spl_boot_list);
 651
 652         if (boot_from_devices(&spl_image, spl_boot_list,
 653                               ARRAY_SIZE(spl_boot_list))) {
 654                 puts(SPL_TPL_PROMPT "failed to boot from all boot devices\n");
 655                 hang();
 656         }
 657
 658         spl_perform_fixups(&spl_image);
 659         if (CONFIG_IS_ENABLED(HANDOFF)) {
 660                 ret = write_spl_handoff();
 661                 if (ret)
 662                         printf(SPL_TPL_PROMPT
 663                                "SPL hand-off write failed (err=%d)\n", ret);
 664         }
 665         if (CONFIG_IS_ENABLED(BLOBLIST)) {
 666                 ret = bloblist_finish();
 667                 if (ret)
 668                         printf("Warning: Failed to finish bloblist (ret=%d)\n",
 669                                ret);
 670         }
 671
 672 #ifdef CONFIG_CPU_V7M
 673         spl_image.entry_point |= 0x1;
 674 #endif
 675         switch (spl_image.os) {
 676         case IH_OS_U_BOOT:
 677                 debug("Jumping to U-Boot\n");
 678                 break;
 679 #if CONFIG_IS_ENABLED(ATF)
 680         case IH_OS_ARM_TRUSTED_FIRMWARE:
 681                 debug("Jumping to U-Boot via ARM Trusted Firmware\n");
 682                 spl_invoke_atf(&spl_image);
 683                 break;
 684 #endif
 685 #if CONFIG_IS_ENABLED(OPTEE)
 686         case IH_OS_TEE:
 687                 debug("Jumping to U-Boot via OP-TEE\n");
 688                 spl_optee_entry(NULL, NULL, spl_image.fdt_addr,
 689                                 (void *)spl_image.entry_point);
 690                 break;
 691 #endif
 692 #if CONFIG_IS_ENABLED(OPENSBI)
 693         case IH_OS_OPENSBI:
 694                 debug("Jumping to U-Boot via RISC-V OpenSBI\n");
 695                 spl_invoke_opensbi(&spl_image);
 696                 break;
 697 #endif
 698 #ifdef CONFIG_SPL_OS_BOOT
 699         case IH_OS_LINUX:
 700                 debug("Jumping to Linux\n");
 701                 spl_fixup_fdt();
 702                 spl_board_prepare_for_linux();
 703                 jump_to_image_linux(&spl_image);
 704 #endif
 705         default:
 706                 debug("Unsupported OS image.. Jumping nevertheless..\n");
 707         }
 708 #if CONFIG_VAL(SYS_MALLOC_F_LEN) && !defined(CONFIG_SYS_SPL_MALLOC_SIZE)
 709         debug("SPL malloc() used 0x%lx bytes (%ld KB)\n", gd->malloc_ptr,
 710               gd->malloc_ptr / 1024);
 711 #endif
 712         bootstage_mark_name(spl_phase() == PHASE_TPL ? BOOTSTAGE_ID_END_TPL :
 713                             BOOTSTAGE_ID_END_SPL, "end " SPL_TPL_NAME);
 714 #ifdef CONFIG_BOOTSTAGE_STASH
 715         ret = bootstage_stash((void *)CONFIG_BOOTSTAGE_STASH_ADDR,
 716                               CONFIG_BOOTSTAGE_STASH_SIZE);
 717         if (ret)
 718                 debug("Failed to stash bootstage: err=%d\n", ret);
 719 #endif
 720
 721         debug("loaded - jumping to U-Boot...\n");
 722         spl_board_prepare_for_boot();
 723         jump_to_image_no_args(&spl_image);
 724 }
 725
 726 /*
 727  * This requires UART clocks to be enabled.  In order for this to work the
 728  * caller must ensure that the gd pointer is valid.
 729  */
 730 void preloader_console_init(void)
 731 {
 732 #ifdef CONFIG_SPL_SERIAL_SUPPORT
 733         gd->baudrate = CONFIG_BAUDRATE;
 734
 735         serial_init();          /* serial communications setup */
 736
 737         gd->have_console = 1;
 738
 739 #if CONFIG_IS_ENABLED(BANNER_PRINT)
 740         puts("\nU-Boot " SPL_TPL_NAME " " PLAIN_VERSION " (" U_BOOT_DATE " - "
 741              U_BOOT_TIME " " U_BOOT_TZ ")\n");
 742 #endif
 743 #ifdef CONFIG_SPL_DISPLAY_PRINT
 744         spl_display_print();
 745 #endif
 746 #endif
 747 }
 748
 749 /**
 750  * This function is called before the stack is changed from initial stack to
 751  * relocated stack. It tries to dump the stack size used
 752  */
 753 __weak void spl_relocate_stack_check(void)
 754 {
 755 #if CONFIG_IS_ENABLED(SYS_REPORT_STACK_F_USAGE)
 756         ulong init_sp = gd->start_addr_sp;
 757         ulong stack_bottom = init_sp - CONFIG_VAL(SIZE_LIMIT_PROVIDE_STACK);
 758         u8 *ptr = (u8 *)stack_bottom;
 759         ulong i;
 760
 761         for (i = 0; i < CONFIG_VAL(SIZE_LIMIT_PROVIDE_STACK); i++) {
 762                 if (*ptr != CONFIG_VAL(SYS_STACK_F_CHECK_BYTE))
 763                         break;
 764                 ptr++;
 765         }
 766         printf("SPL initial stack usage: %lu bytes\n",
 767                CONFIG_VAL(SIZE_LIMIT_PROVIDE_STACK) - i);
 768 #endif
 769 }
 770
 771 /**
 772  * spl_relocate_stack_gd() - Relocate stack ready for board_init_r() execution
 773  *
 774  * Sometimes board_init_f() runs with a stack in SRAM but we want to use SDRAM
 775  * for the main board_init_r() execution. This is typically because we need
 776  * more stack space for things like the MMC sub-system.
 777  *
 778  * This function calculates the stack position, copies the global_data into
 779  * place, sets the new gd (except for ARM, for which setting GD within a C
 780  * function may not always work) and returns the new stack position. The
 781  * caller is responsible for setting up the sp register and, in the case
 782  * of ARM, setting up gd.
 783  *
 784  * All of this is done using the same layout and alignments as done in
 785  * board_init_f_init_reserve() / board_init_f_alloc_reserve().
 786  *
 787  * @return new stack location, or 0 to use the same stack
 788  */
 789 ulong spl_relocate_stack_gd(void)
 790 {
 791 #ifdef CONFIG_SPL_STACK_R
 792         gd_t *new_gd;
 793         ulong ptr = CONFIG_SPL_STACK_R_ADDR;
 794
 795         if (CONFIG_IS_ENABLED(SYS_REPORT_STACK_F_USAGE))
 796                 spl_relocate_stack_check();
 797
 798 #if defined(CONFIG_SPL_SYS_MALLOC_SIMPLE) && CONFIG_VAL(SYS_MALLOC_F_LEN)
 799         if (CONFIG_SPL_STACK_R_MALLOC_SIMPLE_LEN) {
 800                 debug("SPL malloc() before relocation used 0x%lx bytes (%ld KB)\n",
 801                       gd->malloc_ptr, gd->malloc_ptr / 1024);
 802                 ptr -= CONFIG_SPL_STACK_R_MALLOC_SIMPLE_LEN;
 803                 gd->malloc_base = ptr;
 804                 gd->malloc_limit = CONFIG_SPL_STACK_R_MALLOC_SIMPLE_LEN;
 805                 gd->malloc_ptr = 0;
 806         }
 807 #endif
 808         /* Get stack position: use 8-byte alignment for ABI compliance */
 809         ptr = CONFIG_SPL_STACK_R_ADDR - roundup(sizeof(gd_t),16);
 810         new_gd = (gd_t *)ptr;
 811         memcpy(new_gd, (void *)gd, sizeof(gd_t));
 812 #if CONFIG_IS_ENABLED(DM)
 813         dm_fixup_for_gd_move(new_gd);
 814 #endif
 815 #if !defined(CONFIG_ARM) && !defined(CONFIG_RISCV)
 816         gd = new_gd;
 817 #endif
 818         return ptr;
 819 #else
 820         return 0;
 821 #endif
 822 }
 823
 824 #if defined(CONFIG_BOOTCOUNT_LIMIT) && !defined(CONFIG_SPL_BOOTCOUNT_LIMIT)
 825 void bootcount_store(ulong a)
 826 {
 827 }
 828
 829 ulong bootcount_load(void)
 830 {
 831         return 0;
 832 }
 833 #endif