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