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