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