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_board_header(struct spl_image_info *spl_image,
 304                                   const void *image_header, size_t size)
 305 {
 306         return -EINVAL;
 307 }
 308
 309 __weak int spl_parse_legacy_header(struct spl_image_info *spl_image,
 310                                    const struct image_header *header)
 311 {
 312         /* LEGACY image not supported */
 313         debug("Legacy boot image support not enabled, proceeding to other boot methods\n");
 314         return -EINVAL;
 315 }
 316
 317 int spl_parse_image_header(struct spl_image_info *spl_image,
 318                            const struct image_header *header)
 319 {
 320 #if CONFIG_IS_ENABLED(LOAD_FIT_FULL)
 321         int ret = spl_load_fit_image(spl_image, header);
 322
 323         if (!ret)
 324                 return ret;
 325 #endif
 326         if (image_get_magic(header) == IH_MAGIC) {
 327                 int ret;
 328
 329                 ret = spl_parse_legacy_header(spl_image, header);
 330                 if (ret)
 331                         return ret;
 332         } else {
 333 #ifdef CONFIG_SPL_PANIC_ON_RAW_IMAGE
 334                 /*
 335                  * CONFIG_SPL_PANIC_ON_RAW_IMAGE is defined when the
 336                  * code which loads images in SPL cannot guarantee that
 337                  * absolutely all read errors will be reported.
 338                  * An example is the LPC32XX MLC NAND driver, which
 339                  * will consider that a completely unreadable NAND block
 340                  * is bad, and thus should be skipped silently.
 341                  */
 342                 panic("** no mkimage signature but raw image not supported");
 343 #endif
 344
 345 #ifdef CONFIG_SPL_OS_BOOT
 346                 ulong start, end;
 347
 348                 if (!bootz_setup((ulong)header, &start, &end)) {
 349                         spl_image->name = "Linux";
 350                         spl_image->os = IH_OS_LINUX;
 351                         spl_image->load_addr = CONFIG_SYS_LOAD_ADDR;
 352                         spl_image->entry_point = CONFIG_SYS_LOAD_ADDR;
 353                         spl_image->size = end - start;
 354                         debug(SPL_TPL_PROMPT
 355                               "payload zImage, load addr: 0x%lx size: %d\n",
 356                               spl_image->load_addr, spl_image->size);
 357                         return 0;
 358                 }
 359 #endif
 360
 361                 if (!spl_parse_board_header(spl_image, (const void *)header, sizeof(*header)))
 362                         return 0;
 363
 364 #ifdef CONFIG_SPL_RAW_IMAGE_SUPPORT
 365                 /* Signature not found - assume u-boot.bin */
 366                 debug("mkimage signature not found - ih_magic = %x\n",
 367                         header->ih_magic);
 368                 spl_set_header_raw_uboot(spl_image);
 369 #else
 370                 /* RAW image not supported, proceed to other boot methods. */
 371                 debug("Raw boot image support not enabled, proceeding to other boot methods\n");
 372                 return -EINVAL;
 373 #endif
 374         }
 375
 376         return 0;
 377 }
 378
 379 __weak void __noreturn jump_to_image_no_args(struct spl_image_info *spl_image)
 380 {
 381         typedef void __noreturn (*image_entry_noargs_t)(void);
 382
 383         image_entry_noargs_t image_entry =
 384                 (image_entry_noargs_t)spl_image->entry_point;
 385
 386         debug("image entry point: 0x%lx\n", spl_image->entry_point);
 387         image_entry();
 388 }
 389
 390 #if CONFIG_IS_ENABLED(HANDOFF)
 391 /**
 392  * Set up the SPL hand-off information
 393  *
 394  * This is initially empty (zero) but can be written by
 395  */
 396 static int setup_spl_handoff(void)
 397 {
 398         struct spl_handoff *ho;
 399
 400         ho = bloblist_ensure(BLOBLISTT_SPL_HANDOFF, sizeof(struct spl_handoff));
 401         if (!ho)
 402                 return -ENOENT;
 403
 404         return 0;
 405 }
 406
 407 __weak int handoff_arch_save(struct spl_handoff *ho)
 408 {
 409         return 0;
 410 }
 411
 412 static int write_spl_handoff(void)
 413 {
 414         struct spl_handoff *ho;
 415         int ret;
 416
 417         ho = bloblist_find(BLOBLISTT_SPL_HANDOFF, sizeof(struct spl_handoff));
 418         if (!ho)
 419                 return -ENOENT;
 420         handoff_save_dram(ho);
 421         ret = handoff_arch_save(ho);
 422         if (ret)
 423                 return ret;
 424         debug(SPL_TPL_PROMPT "Wrote SPL handoff\n");
 425
 426         return 0;
 427 }
 428 #else
 429 static inline int setup_spl_handoff(void) { return 0; }
 430 static inline int write_spl_handoff(void) { return 0; }
 431
 432 #endif /* HANDOFF */
 433
 434 /**
 435  * get_bootstage_id() - Get the bootstage ID to emit
 436  *
 437  * @start: true if this is for starting SPL, false for ending it
 438  * @return bootstage ID to use
 439  */
 440 static enum bootstage_id get_bootstage_id(bool start)
 441 {
 442         enum u_boot_phase phase = spl_phase();
 443
 444         if (IS_ENABLED(CONFIG_TPL_BUILD) && phase == PHASE_TPL)
 445                 return start ? BOOTSTAGE_ID_START_TPL : BOOTSTAGE_ID_END_TPL;
 446         else
 447                 return start ? BOOTSTAGE_ID_START_SPL : BOOTSTAGE_ID_END_SPL;
 448 }
 449
 450 static int spl_common_init(bool setup_malloc)
 451 {
 452         int ret;
 453
 454 #if CONFIG_VAL(SYS_MALLOC_F_LEN)
 455         if (setup_malloc) {
 456 #ifdef CONFIG_MALLOC_F_ADDR
 457                 gd->malloc_base = CONFIG_MALLOC_F_ADDR;
 458 #endif
 459                 gd->malloc_limit = CONFIG_VAL(SYS_MALLOC_F_LEN);
 460                 gd->malloc_ptr = 0;
 461         }
 462 #endif
 463         ret = bootstage_init(u_boot_first_phase());
 464         if (ret) {
 465                 debug("%s: Failed to set up bootstage: ret=%d\n", __func__,
 466                       ret);
 467                 return ret;
 468         }
 469 #ifdef CONFIG_BOOTSTAGE_STASH
 470         if (!u_boot_first_phase()) {
 471                 const void *stash = map_sysmem(CONFIG_BOOTSTAGE_STASH_ADDR,
 472                                                CONFIG_BOOTSTAGE_STASH_SIZE);
 473
 474                 ret = bootstage_unstash(stash, CONFIG_BOOTSTAGE_STASH_SIZE);
 475                 if (ret)
 476                         debug("%s: Failed to unstash bootstage: ret=%d\n",
 477                               __func__, ret);
 478         }
 479 #endif /* CONFIG_BOOTSTAGE_STASH */
 480         bootstage_mark_name(get_bootstage_id(true),
 481                             spl_phase_name(spl_phase()));
 482 #if CONFIG_IS_ENABLED(LOG)
 483         ret = log_init();
 484         if (ret) {
 485                 debug("%s: Failed to set up logging\n", __func__);
 486                 return ret;
 487         }
 488 #endif
 489         if (CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)) {
 490                 ret = fdtdec_setup();
 491                 if (ret) {
 492                         debug("fdtdec_setup() returned error %d\n", ret);
 493                         return ret;
 494                 }
 495         }
 496         if (CONFIG_IS_ENABLED(DM)) {
 497                 bootstage_start(BOOTSTAGE_ID_ACCUM_DM_SPL,
 498                                 spl_phase() == PHASE_TPL ? "dm tpl" : "dm_spl");
 499                 /* With CONFIG_SPL_OF_PLATDATA, bring in all devices */
 500                 ret = dm_init_and_scan(!CONFIG_IS_ENABLED(OF_PLATDATA));
 501                 bootstage_accum(BOOTSTAGE_ID_ACCUM_DM_SPL);
 502                 if (ret) {
 503                         debug("dm_init_and_scan() returned error %d\n", ret);
 504                         return ret;
 505                 }
 506         }
 507
 508         return 0;
 509 }
 510
 511 void spl_set_bd(void)
 512 {
 513         /*
 514          * NOTE: On some platforms (e.g. x86) bdata may be in flash and not
 515          * writeable.
 516          */
 517         if (!gd->bd)
 518                 gd->bd = &bdata;
 519 }
 520
 521 int spl_early_init(void)
 522 {
 523         int ret;
 524
 525         debug("%s\n", __func__);
 526
 527         ret = spl_common_init(true);
 528         if (ret)
 529                 return ret;
 530         gd->flags |= GD_FLG_SPL_EARLY_INIT;
 531
 532         return 0;
 533 }
 534
 535 int spl_init(void)
 536 {
 537         int ret;
 538         bool setup_malloc = !(IS_ENABLED(CONFIG_SPL_STACK_R) &&
 539                         IS_ENABLED(CONFIG_SPL_SYS_MALLOC_SIMPLE));
 540
 541         debug("%s\n", __func__);
 542
 543         if (!(gd->flags & GD_FLG_SPL_EARLY_INIT)) {
 544                 ret = spl_common_init(setup_malloc);
 545                 if (ret)
 546                         return ret;
 547         }
 548         gd->flags |= GD_FLG_SPL_INIT;
 549
 550         return 0;
 551 }
 552
 553 #ifndef BOOT_DEVICE_NONE
 554 #define BOOT_DEVICE_NONE 0xdeadbeef
 555 #endif
 556
 557 __weak void board_boot_order(u32 *spl_boot_list)
 558 {
 559         spl_boot_list[0] = spl_boot_device();
 560 }
 561
 562 static struct spl_image_loader *spl_ll_find_loader(uint boot_device)
 563 {
 564         struct spl_image_loader *drv =
 565                 ll_entry_start(struct spl_image_loader, spl_image_loader);
 566         const int n_ents =
 567                 ll_entry_count(struct spl_image_loader, spl_image_loader);
 568         struct spl_image_loader *entry;
 569
 570         for (entry = drv; entry != drv + n_ents; entry++) {
 571                 if (boot_device == entry->boot_device)
 572                         return entry;
 573         }
 574
 575         /* Not found */
 576         return NULL;
 577 }
 578
 579 static int spl_load_image(struct spl_image_info *spl_image,
 580                           struct spl_image_loader *loader)
 581 {
 582         int ret;
 583         struct spl_boot_device bootdev;
 584
 585         bootdev.boot_device = loader->boot_device;
 586         bootdev.boot_device_name = NULL;
 587
 588         ret = loader->load_image(spl_image, &bootdev);
 589 #ifdef CONFIG_SPL_LEGACY_IMAGE_CRC_CHECK
 590         if (!ret && spl_image->dcrc_length) {
 591                 /* check data crc */
 592                 ulong dcrc = crc32_wd(0, (unsigned char *)spl_image->dcrc_data,
 593                                       spl_image->dcrc_length, CHUNKSZ_CRC32);
 594                 if (dcrc != spl_image->dcrc) {
 595                         puts("SPL: Image data CRC check failed!\n");
 596                         ret = -EINVAL;
 597                 }
 598         }
 599 #endif
 600         return ret;
 601 }
 602
 603 /**
 604  * boot_from_devices() - Try loading a booting U-Boot from a list of devices
 605  *
 606  * @spl_image: Place to put the image details if successful
 607  * @spl_boot_list: List of boot devices to try
 608  * @count: Number of elements in spl_boot_list
 609  * @return 0 if OK, -ENODEV if there were no boot devices
 610  *      if CONFIG_SHOW_ERRORS is enabled, returns -ENXIO if there were
 611  *      devices but none worked
 612  */
 613 static int boot_from_devices(struct spl_image_info *spl_image,
 614                              u32 spl_boot_list[], int count)
 615 {
 616         int ret = -ENODEV;
 617         int i;
 618
 619         for (i = 0; i < count && spl_boot_list[i] != BOOT_DEVICE_NONE; i++) {
 620                 struct spl_image_loader *loader;
 621                 int bootdev = spl_boot_list[i];
 622
 623                 if (CONFIG_IS_ENABLED(SHOW_ERRORS))
 624                         ret = -ENXIO;
 625                 loader = spl_ll_find_loader(bootdev);
 626                 if (CONFIG_IS_ENABLED(SERIAL) &&
 627                     CONFIG_IS_ENABLED(LIBCOMMON_SUPPORT) &&
 628                     !IS_ENABLED(CONFIG_SILENT_CONSOLE)) {
 629                         if (loader)
 630                                 printf("Trying to boot from %s\n",
 631                                        spl_loader_name(loader));
 632                         else if (CONFIG_IS_ENABLED(SHOW_ERRORS))
 633                                 printf(SPL_TPL_PROMPT
 634                                        "Unsupported Boot Device %d\n", bootdev);
 635                         else
 636                                 puts(SPL_TPL_PROMPT "Unsupported Boot Device!\n");
 637                 }
 638                 if (loader && !spl_load_image(spl_image, loader)) {
 639                         spl_image->boot_device = bootdev;
 640                         return 0;
 641                 }
 642         }
 643
 644         return ret;
 645 }
 646
 647 #if defined(CONFIG_SPL_FRAMEWORK_BOARD_INIT_F)
 648 void board_init_f(ulong dummy)
 649 {
 650         if (CONFIG_IS_ENABLED(OF_CONTROL)) {
 651                 int ret;
 652
 653                 ret = spl_early_init();
 654                 if (ret) {
 655                         debug("spl_early_init() failed: %d\n", ret);
 656                         hang();
 657                 }
 658         }
 659
 660         preloader_console_init();
 661 }
 662 #endif
 663
 664 void board_init_r(gd_t *dummy1, ulong dummy2)
 665 {
 666         u32 spl_boot_list[] = {
 667                 BOOT_DEVICE_NONE,
 668                 BOOT_DEVICE_NONE,
 669                 BOOT_DEVICE_NONE,
 670                 BOOT_DEVICE_NONE,
 671                 BOOT_DEVICE_NONE,
 672         };
 673         struct spl_image_info spl_image;
 674         int ret;
 675
 676         debug(">>" SPL_TPL_PROMPT "board_init_r()\n");
 677
 678         spl_set_bd();
 679
 680 #if defined(CONFIG_SYS_SPL_MALLOC_START)
 681         mem_malloc_init(CONFIG_SYS_SPL_MALLOC_START,
 682                         CONFIG_SYS_SPL_MALLOC_SIZE);
 683         gd->flags |= GD_FLG_FULL_MALLOC_INIT;
 684 #endif
 685         if (!(gd->flags & GD_FLG_SPL_INIT)) {
 686                 if (spl_init())
 687                         hang();
 688         }
 689 #if !defined(CONFIG_PPC) && !defined(CONFIG_ARCH_MX6)
 690         /*
 691          * timer_init() does not exist on PPC systems. The timer is initialized
 692          * and enabled (decrementer) in interrupt_init() here.
 693          */
 694         timer_init();
 695 #endif
 696         if (CONFIG_IS_ENABLED(BLOBLIST)) {
 697                 ret = bloblist_init();
 698                 if (ret) {
 699                         debug("%s: Failed to set up bloblist: ret=%d\n",
 700                               __func__, ret);
 701                         puts(SPL_TPL_PROMPT "Cannot set up bloblist\n");
 702                         hang();
 703                 }
 704         }
 705         if (CONFIG_IS_ENABLED(HANDOFF)) {
 706                 int ret;
 707
 708                 ret = setup_spl_handoff();
 709                 if (ret) {
 710                         puts(SPL_TPL_PROMPT "Cannot set up SPL handoff\n");
 711                         hang();
 712                 }
 713         }
 714
 715 #if CONFIG_IS_ENABLED(BOARD_INIT)
 716         spl_board_init();
 717 #endif
 718
 719 #if defined(CONFIG_SPL_WATCHDOG) && CONFIG_IS_ENABLED(WDT)
 720         initr_watchdog();
 721 #endif
 722
 723         if (IS_ENABLED(CONFIG_SPL_OS_BOOT) || CONFIG_IS_ENABLED(HANDOFF) ||
 724             IS_ENABLED(CONFIG_SPL_ATF))
 725                 dram_init_banksize();
 726
 727         bootcount_inc();
 728
 729         memset(&spl_image, '\0', sizeof(spl_image));
 730 #ifdef CONFIG_SYS_SPL_ARGS_ADDR
 731         spl_image.arg = (void *)CONFIG_SYS_SPL_ARGS_ADDR;
 732 #endif
 733         spl_image.boot_device = BOOT_DEVICE_NONE;
 734         board_boot_order(spl_boot_list);
 735
 736         ret = boot_from_devices(&spl_image, spl_boot_list,
 737                                 ARRAY_SIZE(spl_boot_list));
 738         if (ret) {
 739                 if (CONFIG_IS_ENABLED(SHOW_ERRORS) &&
 740                     CONFIG_IS_ENABLED(LIBCOMMON_SUPPORT))
 741                         printf(SPL_TPL_PROMPT "failed to boot from all boot devices (err=%d)\n",
 742                                ret);
 743                 else
 744                         puts(SPL_TPL_PROMPT "failed to boot from all boot devices\n");
 745                 hang();
 746         }
 747
 748         spl_perform_fixups(&spl_image);
 749         if (CONFIG_IS_ENABLED(HANDOFF)) {
 750                 ret = write_spl_handoff();
 751                 if (ret)
 752                         printf(SPL_TPL_PROMPT
 753                                "SPL hand-off write failed (err=%d)\n", ret);
 754         }
 755         if (CONFIG_IS_ENABLED(BLOBLIST)) {
 756                 ret = bloblist_finish();
 757                 if (ret)
 758                         printf("Warning: Failed to finish bloblist (ret=%d)\n",
 759                                ret);
 760         }
 761
 762 #ifdef CONFIG_CPU_V7M
 763         spl_image.entry_point |= 0x1;
 764 #endif
 765         switch (spl_image.os) {
 766         case IH_OS_U_BOOT:
 767                 debug("Jumping to %s...\n", spl_phase_name(spl_next_phase()));
 768                 break;
 769 #if CONFIG_IS_ENABLED(ATF)
 770         case IH_OS_ARM_TRUSTED_FIRMWARE:
 771                 debug("Jumping to U-Boot via ARM Trusted Firmware\n");
 772                 spl_fixup_fdt(spl_image.fdt_addr);
 773                 spl_invoke_atf(&spl_image);
 774                 break;
 775 #endif
 776 #if CONFIG_IS_ENABLED(OPTEE)
 777         case IH_OS_TEE:
 778                 debug("Jumping to U-Boot via OP-TEE\n");
 779                 spl_board_prepare_for_optee(spl_image.fdt_addr);
 780                 spl_optee_entry(NULL, NULL, spl_image.fdt_addr,
 781                                 (void *)spl_image.entry_point);
 782                 break;
 783 #endif
 784 #if CONFIG_IS_ENABLED(OPENSBI)
 785         case IH_OS_OPENSBI:
 786                 debug("Jumping to U-Boot via RISC-V OpenSBI\n");
 787                 spl_invoke_opensbi(&spl_image);
 788                 break;
 789 #endif
 790 #ifdef CONFIG_SPL_OS_BOOT
 791         case IH_OS_LINUX:
 792                 debug("Jumping to Linux\n");
 793 #if defined(CONFIG_SYS_SPL_ARGS_ADDR)
 794                 spl_fixup_fdt((void *)CONFIG_SYS_SPL_ARGS_ADDR);
 795 #endif
 796                 spl_board_prepare_for_linux();
 797                 jump_to_image_linux(&spl_image);
 798 #endif
 799         default:
 800                 debug("Unsupported OS image.. Jumping nevertheless..\n");
 801         }
 802 #if CONFIG_VAL(SYS_MALLOC_F_LEN) && !defined(CONFIG_SYS_SPL_MALLOC_SIZE)
 803         debug("SPL malloc() used 0x%lx bytes (%ld KB)\n", gd->malloc_ptr,
 804               gd->malloc_ptr / 1024);
 805 #endif
 806         bootstage_mark_name(get_bootstage_id(false), "end phase");
 807 #ifdef CONFIG_BOOTSTAGE_STASH
 808         ret = bootstage_stash((void *)CONFIG_BOOTSTAGE_STASH_ADDR,
 809                               CONFIG_BOOTSTAGE_STASH_SIZE);
 810         if (ret)
 811                 debug("Failed to stash bootstage: err=%d\n", ret);
 812 #endif
 813
 814         spl_board_prepare_for_boot();
 815         jump_to_image_no_args(&spl_image);
 816 }
 817
 818 /*
 819  * This requires UART clocks to be enabled.  In order for this to work the
 820  * caller must ensure that the gd pointer is valid.
 821  */
 822 void preloader_console_init(void)
 823 {
 824 #ifdef CONFIG_SPL_SERIAL
 825         gd->baudrate = CONFIG_BAUDRATE;
 826
 827         serial_init();          /* serial communications setup */
 828
 829         gd->have_console = 1;
 830
 831 #if CONFIG_IS_ENABLED(BANNER_PRINT)
 832         puts("\nU-Boot " SPL_TPL_NAME " " PLAIN_VERSION " (" U_BOOT_DATE " - "
 833              U_BOOT_TIME " " U_BOOT_TZ ")\n");
 834 #endif
 835 #ifdef CONFIG_SPL_DISPLAY_PRINT
 836         spl_display_print();
 837 #endif
 838 #endif
 839 }
 840
 841 /**
 842  * This function is called before the stack is changed from initial stack to
 843  * relocated stack. It tries to dump the stack size used
 844  */
 845 __weak void spl_relocate_stack_check(void)
 846 {
 847 #if CONFIG_IS_ENABLED(SYS_REPORT_STACK_F_USAGE)
 848         ulong init_sp = gd->start_addr_sp;
 849         ulong stack_bottom = init_sp - CONFIG_VAL(SIZE_LIMIT_PROVIDE_STACK);
 850         u8 *ptr = (u8 *)stack_bottom;
 851         ulong i;
 852
 853         for (i = 0; i < CONFIG_VAL(SIZE_LIMIT_PROVIDE_STACK); i++) {
 854                 if (*ptr != CONFIG_VAL(SYS_STACK_F_CHECK_BYTE))
 855                         break;
 856                 ptr++;
 857         }
 858         printf("SPL initial stack usage: %lu bytes\n",
 859                CONFIG_VAL(SIZE_LIMIT_PROVIDE_STACK) - i);
 860 #endif
 861 }
 862
 863 /**
 864  * spl_relocate_stack_gd() - Relocate stack ready for board_init_r() execution
 865  *
 866  * Sometimes board_init_f() runs with a stack in SRAM but we want to use SDRAM
 867  * for the main board_init_r() execution. This is typically because we need
 868  * more stack space for things like the MMC sub-system.
 869  *
 870  * This function calculates the stack position, copies the global_data into
 871  * place, sets the new gd (except for ARM, for which setting GD within a C
 872  * function may not always work) and returns the new stack position. The
 873  * caller is responsible for setting up the sp register and, in the case
 874  * of ARM, setting up gd.
 875  *
 876  * All of this is done using the same layout and alignments as done in
 877  * board_init_f_init_reserve() / board_init_f_alloc_reserve().
 878  *
 879  * @return new stack location, or 0 to use the same stack
 880  */
 881 ulong spl_relocate_stack_gd(void)
 882 {
 883 #ifdef CONFIG_SPL_STACK_R
 884         gd_t *new_gd;
 885         ulong ptr = CONFIG_SPL_STACK_R_ADDR;
 886
 887         if (CONFIG_IS_ENABLED(SYS_REPORT_STACK_F_USAGE))
 888                 spl_relocate_stack_check();
 889
 890 #if defined(CONFIG_SPL_SYS_MALLOC_SIMPLE) && CONFIG_VAL(SYS_MALLOC_F_LEN)
 891         if (CONFIG_SPL_STACK_R_MALLOC_SIMPLE_LEN) {
 892                 debug("SPL malloc() before relocation used 0x%lx bytes (%ld KB)\n",
 893                       gd->malloc_ptr, gd->malloc_ptr / 1024);
 894                 ptr -= CONFIG_SPL_STACK_R_MALLOC_SIMPLE_LEN;
 895                 gd->malloc_base = ptr;
 896                 gd->malloc_limit = CONFIG_SPL_STACK_R_MALLOC_SIMPLE_LEN;
 897                 gd->malloc_ptr = 0;
 898         }
 899 #endif
 900         /* Get stack position: use 8-byte alignment for ABI compliance */
 901         ptr = CONFIG_SPL_STACK_R_ADDR - roundup(sizeof(gd_t),16);
 902         new_gd = (gd_t *)ptr;
 903         memcpy(new_gd, (void *)gd, sizeof(gd_t));
 904 #if CONFIG_IS_ENABLED(DM)
 905         dm_fixup_for_gd_move(new_gd);
 906 #endif
 907 #if !defined(CONFIG_ARM) && !defined(CONFIG_RISCV)
 908         gd = new_gd;
 909 #endif
 910         return ptr;
 911 #else
 912         return 0;
 913 #endif
 914 }
 915
 916 #if defined(CONFIG_BOOTCOUNT_LIMIT) && \
 917         ((!defined(CONFIG_TPL_BUILD) && !defined(CONFIG_SPL_BOOTCOUNT_LIMIT)) || \
 918          (defined(CONFIG_TPL_BUILD) && !defined(CONFIG_TPL_BOOTCOUNT_LIMIT)))
 919 void bootcount_store(ulong a)
 920 {
 921 }
 922
 923 ulong bootcount_load(void)
 924 {
 925         return 0;
 926 }
 927 #endif