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