common/spl/spl.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * (C) Copyright 2010
   4  * Texas Instruments, <www.ti.com>
   5  *
   6  * Aneesh V <aneesh@ti.com>
   7  */
   8
   9 #include <common.h>
  10 #include <bloblist.h>
  11 #include <binman_sym.h>
  12 #include <dm.h>
  13 #include <spl.h>
  14 #include <asm/u-boot.h>
  15 #include <nand.h>
  16 #include <fat.h>
  17 #include <version.h>
  18 #include <image.h>
  19 #include <malloc.h>
  20 #include <dm/root.h>
  21 #include <linux/compiler.h>
  22 #include <fdt_support.h>
  23 #include <bootcount.h>
  24
  25 DECLARE_GLOBAL_DATA_PTR;
  26
  27 #ifndef CONFIG_SYS_UBOOT_START
  28 #define CONFIG_SYS_UBOOT_START  CONFIG_SYS_TEXT_BASE
  29 #endif
  30 #ifndef CONFIG_SYS_MONITOR_LEN
  31 /* Unknown U-Boot size, let's assume it will not be more than 200 KB */
  32 #define CONFIG_SYS_MONITOR_LEN  (200 * 1024)
  33 #endif
  34
  35 u32 *boot_params_ptr = NULL;
  36
  37 /* See spl.h for information about this */
  38 binman_sym_declare(ulong, u_boot_any, image_pos);
  39
  40 /* Define board data structure */
  41 static bd_t bdata __attribute__ ((section(".data")));
  42
  43 /*
  44  * Board-specific Platform code can reimplement show_boot_progress () if needed
  45  */
  46 __weak void show_boot_progress(int val) {}
  47
  48 /*
  49  * Default function to determine if u-boot or the OS should
  50  * be started. This implementation always returns 1.
  51  *
  52  * Please implement your own board specific funcion to do this.
  53  *
  54  * RETURN
  55  * 0 to not start u-boot
  56  * positive if u-boot should start
  57  */
  58 #ifdef CONFIG_SPL_OS_BOOT
  59 __weak int spl_start_uboot(void)
  60 {
  61         puts(SPL_TPL_PROMPT
  62              "Please implement spl_start_uboot() for your board\n");
  63         puts(SPL_TPL_PROMPT "Direct Linux boot not active!\n");
  64         return 1;
  65 }
  66
  67 /* weak default platform specific function to initialize
  68  * dram banks
  69  */
  70 __weak int dram_init_banksize(void)
  71 {
  72         return 0;
  73 }
  74
  75 /*
  76  * Weak default function for arch specific zImage check. Return zero
  77  * and fill start and end address if image is recognized.
  78  */
  79 int __weak bootz_setup(ulong image, ulong *start, ulong *end)
  80 {
  81          return 1;
  82 }
  83 #endif
  84
  85 /* Weak default function for arch/board-specific fixups to the spl_image_info */
  86 void __weak spl_perform_fixups(struct spl_image_info *spl_image)
  87 {
  88 }
  89
  90 void spl_fixup_fdt(void)
  91 {
  92 #if defined(CONFIG_SPL_OF_LIBFDT) && defined(CONFIG_SYS_SPL_ARGS_ADDR)
  93         void *fdt_blob = (void *)CONFIG_SYS_SPL_ARGS_ADDR;
  94         int err;
  95
  96         err = fdt_check_header(fdt_blob);
  97         if (err < 0) {
  98                 printf("fdt_root: %s\n", fdt_strerror(err));
  99                 return;
 100         }
 101
 102         /* fixup the memory dt node */
 103         err = fdt_shrink_to_minimum(fdt_blob, 0);
 104         if (err == 0) {
 105                 printf(SPL_TPL_PROMPT "fdt_shrink_to_minimum err - %d\n", err);
 106                 return;
 107         }
 108
 109         err = arch_fixup_fdt(fdt_blob);
 110         if (err) {
 111                 printf(SPL_TPL_PROMPT "arch_fixup_fdt err - %d\n", err);
 112                 return;
 113         }
 114 #endif
 115 }
 116
 117 /*
 118  * Weak default function for board specific cleanup/preparation before
 119  * Linux boot. Some boards/platforms might not need it, so just provide
 120  * an empty stub here.
 121  */
 122 __weak void spl_board_prepare_for_linux(void)
 123 {
 124         /* Nothing to do! */
 125 }
 126
 127 __weak void spl_board_prepare_for_boot(void)
 128 {
 129         /* Nothing to do! */
 130 }
 131
 132 __weak struct image_header *spl_get_load_buffer(ssize_t offset, size_t size)
 133 {
 134         return (struct image_header *)(CONFIG_SYS_TEXT_BASE + offset);
 135 }
 136
 137 void spl_set_header_raw_uboot(struct spl_image_info *spl_image)
 138 {
 139         ulong u_boot_pos = binman_sym(ulong, u_boot_any, image_pos);
 140
 141         spl_image->size = CONFIG_SYS_MONITOR_LEN;
 142
 143         /*
 144          * Binman error cases: address of the end of the previous region or the
 145          * start of the image's entry area (usually 0) if there is no previous
 146          * region.
 147          */
 148         if (u_boot_pos && u_boot_pos != BINMAN_SYM_MISSING) {
 149                 /* Binman does not support separated entry addresses */
 150                 spl_image->entry_point = u_boot_pos;
 151                 spl_image->load_addr = u_boot_pos;
 152         } else {
 153                 spl_image->entry_point = CONFIG_SYS_UBOOT_START;
 154                 spl_image->load_addr = CONFIG_SYS_TEXT_BASE;
 155         }
 156         spl_image->os = IH_OS_U_BOOT;
 157         spl_image->name = "U-Boot";
 158 }
 159
 160 #ifdef CONFIG_SPL_LOAD_FIT_FULL
 161 /* Parse and load full fitImage in SPL */
 162 static int spl_load_fit_image(struct spl_image_info *spl_image,
 163                               const struct image_header *header)
 164 {
 165         bootm_headers_t images;
 166         const char *fit_uname_config = NULL;
 167         const char *fit_uname_fdt = FIT_FDT_PROP;
 168         const char *uname;
 169         ulong fw_data = 0, dt_data = 0, img_data = 0;
 170         ulong fw_len = 0, dt_len = 0, img_len = 0;
 171         int idx, conf_noffset;
 172         int ret;
 173
 174 #ifdef CONFIG_SPL_FIT_SIGNATURE
 175         images.verify = 1;
 176 #endif
 177         ret = fit_image_load(&images, (ulong)header,
 178                              NULL, &fit_uname_config,
 179                              IH_ARCH_DEFAULT, IH_TYPE_STANDALONE, -1,
 180                              FIT_LOAD_REQUIRED, &fw_data, &fw_len);
 181         if (ret < 0)
 182                 return ret;
 183
 184         spl_image->size = fw_len;
 185         spl_image->entry_point = fw_data;
 186         spl_image->load_addr = fw_data;
 187         spl_image->os = IH_OS_U_BOOT;
 188         spl_image->name = "U-Boot";
 189
 190         debug(SPL_TPL_PROMPT "payload image: %32s load addr: 0x%lx size: %d\n",
 191               spl_image->name, spl_image->load_addr, spl_image->size);
 192
 193 #ifdef CONFIG_SPL_FIT_SIGNATURE
 194         images.verify = 1;
 195 #endif
 196         fit_image_load(&images, (ulong)header,
 197                        &fit_uname_fdt, &fit_uname_config,
 198                        IH_ARCH_DEFAULT, IH_TYPE_FLATDT, -1,
 199                        FIT_LOAD_OPTIONAL, &dt_data, &dt_len);
 200
 201         conf_noffset = fit_conf_get_node((const void *)header,
 202                                          fit_uname_config);
 203         if (conf_noffset <= 0)
 204                 return 0;
 205
 206         for (idx = 0;
 207              uname = fdt_stringlist_get((const void *)header, conf_noffset,
 208                                         FIT_LOADABLE_PROP, idx,
 209                                 NULL), uname;
 210              idx++)
 211         {
 212 #ifdef CONFIG_SPL_FIT_SIGNATURE
 213                 images.verify = 1;
 214 #endif
 215                 ret = fit_image_load(&images, (ulong)header,
 216                                      &uname, &fit_uname_config,
 217                                      IH_ARCH_DEFAULT, IH_TYPE_LOADABLE, -1,
 218                                      FIT_LOAD_OPTIONAL_NON_ZERO,
 219                                      &img_data, &img_len);
 220                 if (ret < 0)
 221                         return ret;
 222         }
 223
 224         return 0;
 225 }
 226 #endif
 227
 228 int spl_parse_image_header(struct spl_image_info *spl_image,
 229                            const struct image_header *header)
 230 {
 231 #ifdef CONFIG_SPL_LOAD_FIT_FULL
 232         int ret = spl_load_fit_image(spl_image, header);
 233
 234         if (!ret)
 235                 return ret;
 236 #endif
 237         if (image_get_magic(header) == IH_MAGIC) {
 238 #ifdef CONFIG_SPL_LEGACY_IMAGE_SUPPORT
 239                 u32 header_size = sizeof(struct image_header);
 240
 241                 if (spl_image->flags & SPL_COPY_PAYLOAD_ONLY) {
 242                         /*
 243                          * On some system (e.g. powerpc), the load-address and
 244                          * entry-point is located at address 0. We can't load
 245                          * to 0-0x40. So skip header in this case.
 246                          */
 247                         spl_image->load_addr = image_get_load(header);
 248                         spl_image->entry_point = image_get_ep(header);
 249                         spl_image->size = image_get_data_size(header);
 250                 } else {
 251                         spl_image->entry_point = image_get_load(header);
 252                         /* Load including the header */
 253                         spl_image->load_addr = spl_image->entry_point -
 254                                 header_size;
 255                         spl_image->size = image_get_data_size(header) +
 256                                 header_size;
 257                 }
 258                 spl_image->os = image_get_os(header);
 259                 spl_image->name = image_get_name(header);
 260                 debug(SPL_TPL_PROMPT
 261                       "payload image: %32s load addr: 0x%lx size: %d\n",
 262                       spl_image->name, spl_image->load_addr, spl_image->size);
 263 #else
 264                 /* LEGACY image not supported */
 265                 debug("Legacy boot image support not enabled, proceeding to other boot methods\n");
 266                 return -EINVAL;
 267 #endif
 268         } else {
 269 #ifdef CONFIG_SPL_PANIC_ON_RAW_IMAGE
 270                 /*
 271                  * CONFIG_SPL_PANIC_ON_RAW_IMAGE is defined when the
 272                  * code which loads images in SPL cannot guarantee that
 273                  * absolutely all read errors will be reported.
 274                  * An example is the LPC32XX MLC NAND driver, which
 275                  * will consider that a completely unreadable NAND block
 276                  * is bad, and thus should be skipped silently.
 277                  */
 278                 panic("** no mkimage signature but raw image not supported");
 279 #endif
 280
 281 #ifdef CONFIG_SPL_OS_BOOT
 282                 ulong start, end;
 283
 284                 if (!bootz_setup((ulong)header, &start, &end)) {
 285                         spl_image->name = "Linux";
 286                         spl_image->os = IH_OS_LINUX;
 287                         spl_image->load_addr = CONFIG_SYS_LOAD_ADDR;
 288                         spl_image->entry_point = CONFIG_SYS_LOAD_ADDR;
 289                         spl_image->size = end - start;
 290                         debug(SPL_TPL_PROMPT
 291                               "payload zImage, load addr: 0x%lx size: %d\n",
 292                               spl_image->load_addr, spl_image->size);
 293                         return 0;
 294                 }
 295 #endif
 296
 297 #ifdef CONFIG_SPL_RAW_IMAGE_SUPPORT
 298                 /* Signature not found - assume u-boot.bin */
 299                 debug("mkimage signature not found - ih_magic = %x\n",
 300                         header->ih_magic);
 301                 spl_set_header_raw_uboot(spl_image);
 302 #else
 303                 /* RAW image not supported, proceed to other boot methods. */
 304                 debug("Raw boot image support not enabled, proceeding to other boot methods\n");
 305                 return -EINVAL;
 306 #endif
 307         }
 308
 309         return 0;
 310 }
 311
 312 __weak void __noreturn jump_to_image_no_args(struct spl_image_info *spl_image)
 313 {
 314         typedef void __noreturn (*image_entry_noargs_t)(void);
 315
 316         image_entry_noargs_t image_entry =
 317                 (image_entry_noargs_t)spl_image->entry_point;
 318
 319         debug("image entry point: 0x%lx\n", spl_image->entry_point);
 320         image_entry();
 321 }
 322
 323 static int spl_common_init(bool setup_malloc)
 324 {
 325         int ret;
 326
 327 #if CONFIG_VAL(SYS_MALLOC_F_LEN)
 328         if (setup_malloc) {
 329 #ifdef CONFIG_MALLOC_F_ADDR
 330                 gd->malloc_base = CONFIG_MALLOC_F_ADDR;
 331 #endif
 332                 gd->malloc_limit = CONFIG_VAL(SYS_MALLOC_F_LEN);
 333                 gd->malloc_ptr = 0;
 334         }
 335 #endif
 336         ret = bootstage_init(true);
 337         if (ret) {
 338                 debug("%s: Failed to set up bootstage: ret=%d\n", __func__,
 339                       ret);
 340                 return ret;
 341         }
 342         bootstage_mark_name(BOOTSTAGE_ID_START_SPL, "spl");
 343 #if CONFIG_IS_ENABLED(LOG)
 344         ret = log_init();
 345         if (ret) {
 346                 debug("%s: Failed to set up logging\n", __func__);
 347                 return ret;
 348         }
 349 #endif
 350         if (CONFIG_IS_ENABLED(BLOBLIST)) {
 351                 ret = bloblist_init();
 352                 if (ret) {
 353                         debug("%s: Failed to set up bloblist: ret=%d\n",
 354                               __func__, ret);
 355                         return ret;
 356                 }
 357         }
 358         if (CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)) {
 359                 ret = fdtdec_setup();
 360                 if (ret) {
 361                         debug("fdtdec_setup() returned error %d\n", ret);
 362                         return ret;
 363                 }
 364         }
 365         if (CONFIG_IS_ENABLED(DM)) {
 366                 bootstage_start(BOOTSTATE_ID_ACCUM_DM_SPL, "dm_spl");
 367                 /* With CONFIG_SPL_OF_PLATDATA, bring in all devices */
 368                 ret = dm_init_and_scan(!CONFIG_IS_ENABLED(OF_PLATDATA));
 369                 bootstage_accum(BOOTSTATE_ID_ACCUM_DM_SPL);
 370                 if (ret) {
 371                         debug("dm_init_and_scan() returned error %d\n", ret);
 372                         return ret;
 373                 }
 374         }
 375
 376         return 0;
 377 }
 378
 379 void spl_set_bd(void)
 380 {
 381         if (!gd->bd)
 382                 gd->bd = &bdata;
 383 }
 384
 385 int spl_early_init(void)
 386 {
 387         int ret;
 388
 389         debug("%s\n", __func__);
 390
 391         ret = spl_common_init(true);
 392         if (ret)
 393                 return ret;
 394         gd->flags |= GD_FLG_SPL_EARLY_INIT;
 395
 396         return 0;
 397 }
 398
 399 int spl_init(void)
 400 {
 401         int ret;
 402         bool setup_malloc = !(IS_ENABLED(CONFIG_SPL_STACK_R) &&
 403                         IS_ENABLED(CONFIG_SPL_SYS_MALLOC_SIMPLE));
 404
 405         debug("%s\n", __func__);
 406
 407         if (!(gd->flags & GD_FLG_SPL_EARLY_INIT)) {
 408                 ret = spl_common_init(setup_malloc);
 409                 if (ret)
 410                         return ret;
 411         }
 412         gd->flags |= GD_FLG_SPL_INIT;
 413
 414         return 0;
 415 }
 416
 417 #ifndef BOOT_DEVICE_NONE
 418 #define BOOT_DEVICE_NONE 0xdeadbeef
 419 #endif
 420
 421 __weak void board_boot_order(u32 *spl_boot_list)
 422 {
 423         spl_boot_list[0] = spl_boot_device();
 424 }
 425
 426 static struct spl_image_loader *spl_ll_find_loader(uint boot_device)
 427 {
 428         struct spl_image_loader *drv =
 429                 ll_entry_start(struct spl_image_loader, spl_image_loader);
 430         const int n_ents =
 431                 ll_entry_count(struct spl_image_loader, spl_image_loader);
 432         struct spl_image_loader *entry;
 433
 434         for (entry = drv; entry != drv + n_ents; entry++) {
 435                 if (boot_device == entry->boot_device)
 436                         return entry;
 437         }
 438
 439         /* Not found */
 440         return NULL;
 441 }
 442
 443 static int spl_load_image(struct spl_image_info *spl_image,
 444                           struct spl_image_loader *loader)
 445 {
 446         struct spl_boot_device bootdev;
 447
 448         bootdev.boot_device = loader->boot_device;
 449         bootdev.boot_device_name = NULL;
 450
 451         return loader->load_image(spl_image, &bootdev);
 452 }
 453
 454 /**
 455  * boot_from_devices() - Try loading an booting U-Boot from a list of devices
 456  *
 457  * @spl_image: Place to put the image details if successful
 458  * @spl_boot_list: List of boot devices to try
 459  * @count: Number of elements in spl_boot_list
 460  * @return 0 if OK, -ve on error
 461  */
 462 static int boot_from_devices(struct spl_image_info *spl_image,
 463                              u32 spl_boot_list[], int count)
 464 {
 465         int i;
 466
 467         for (i = 0; i < count && spl_boot_list[i] != BOOT_DEVICE_NONE; i++) {
 468                 struct spl_image_loader *loader;
 469
 470                 loader = spl_ll_find_loader(spl_boot_list[i]);
 471 #if defined(CONFIG_SPL_SERIAL_SUPPORT) && defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
 472                 if (loader)
 473                         printf("Trying to boot from %s\n", loader->name);
 474                 else
 475                         puts(SPL_TPL_PROMPT "Unsupported Boot Device!\n");
 476 #endif
 477                 if (loader && !spl_load_image(spl_image, loader)) {
 478                         spl_image->boot_device = spl_boot_list[i];
 479                         return 0;
 480                 }
 481         }
 482
 483         return -ENODEV;
 484 }
 485
 486 void board_init_r(gd_t *dummy1, ulong dummy2)
 487 {
 488         u32 spl_boot_list[] = {
 489                 BOOT_DEVICE_NONE,
 490                 BOOT_DEVICE_NONE,
 491                 BOOT_DEVICE_NONE,
 492                 BOOT_DEVICE_NONE,
 493                 BOOT_DEVICE_NONE,
 494         };
 495         struct spl_image_info spl_image;
 496         int ret;
 497
 498         debug(">>" SPL_TPL_PROMPT "board_init_r()\n");
 499
 500         spl_set_bd();
 501
 502 #ifdef CONFIG_SPL_OS_BOOT
 503         dram_init_banksize();
 504 #endif
 505
 506 #if defined(CONFIG_SYS_SPL_MALLOC_START)
 507         mem_malloc_init(CONFIG_SYS_SPL_MALLOC_START,
 508                         CONFIG_SYS_SPL_MALLOC_SIZE);
 509         gd->flags |= GD_FLG_FULL_MALLOC_INIT;
 510 #endif
 511         if (!(gd->flags & GD_FLG_SPL_INIT)) {
 512                 if (spl_init())
 513                         hang();
 514         }
 515 #if !defined(CONFIG_PPC) && !defined(CONFIG_ARCH_MX6)
 516         /*
 517          * timer_init() does not exist on PPC systems. The timer is initialized
 518          * and enabled (decrementer) in interrupt_init() here.
 519          */
 520         timer_init();
 521 #endif
 522
 523 #if CONFIG_IS_ENABLED(BOARD_INIT)
 524         spl_board_init();
 525 #endif
 526
 527         bootcount_inc();
 528
 529         memset(&spl_image, '\0', sizeof(spl_image));
 530 #ifdef CONFIG_SYS_SPL_ARGS_ADDR
 531         spl_image.arg = (void *)CONFIG_SYS_SPL_ARGS_ADDR;
 532 #endif
 533         spl_image.boot_device = BOOT_DEVICE_NONE;
 534         board_boot_order(spl_boot_list);
 535
 536         if (boot_from_devices(&spl_image, spl_boot_list,
 537                               ARRAY_SIZE(spl_boot_list))) {
 538                 puts(SPL_TPL_PROMPT "failed to boot from all boot devices\n");
 539                 hang();
 540         }
 541
 542         spl_perform_fixups(&spl_image);
 543         if (CONFIG_IS_ENABLED(BLOBLIST)) {
 544                 ret = bloblist_finish();
 545                 if (ret)
 546                         printf("Warning: Failed to finish bloblist (ret=%d)\n",
 547                                ret);
 548         }
 549
 550 #ifdef CONFIG_CPU_V7M
 551         spl_image.entry_point |= 0x1;
 552 #endif
 553         switch (spl_image.os) {
 554         case IH_OS_U_BOOT:
 555                 debug("Jumping to U-Boot\n");
 556                 break;
 557 #if CONFIG_IS_ENABLED(ATF)
 558         case IH_OS_ARM_TRUSTED_FIRMWARE:
 559                 debug("Jumping to U-Boot via ARM Trusted Firmware\n");
 560                 spl_invoke_atf(&spl_image);
 561                 break;
 562 #endif
 563 #if CONFIG_IS_ENABLED(OPTEE)
 564         case IH_OS_TEE:
 565                 debug("Jumping to U-Boot via OP-TEE\n");
 566                 spl_optee_entry(NULL, NULL, spl_image.fdt_addr,
 567                                 (void *)spl_image.entry_point);
 568                 break;
 569 #endif
 570 #ifdef CONFIG_SPL_OS_BOOT
 571         case IH_OS_LINUX:
 572                 debug("Jumping to Linux\n");
 573                 spl_fixup_fdt();
 574                 spl_board_prepare_for_linux();
 575                 jump_to_image_linux(&spl_image);
 576 #endif
 577         default:
 578                 debug("Unsupported OS image.. Jumping nevertheless..\n");
 579         }
 580 #if CONFIG_VAL(SYS_MALLOC_F_LEN) && !defined(CONFIG_SYS_SPL_MALLOC_SIZE)
 581         debug("SPL malloc() used 0x%lx bytes (%ld KB)\n", gd->malloc_ptr,
 582               gd->malloc_ptr / 1024);
 583 #endif
 584 #ifdef CONFIG_BOOTSTAGE_STASH
 585         bootstage_mark_name(BOOTSTAGE_ID_END_SPL, "end_spl");
 586         ret = bootstage_stash((void *)CONFIG_BOOTSTAGE_STASH_ADDR,
 587                               CONFIG_BOOTSTAGE_STASH_SIZE);
 588         if (ret)
 589                 debug("Failed to stash bootstage: err=%d\n", ret);
 590 #endif
 591
 592         debug("loaded - jumping to U-Boot...\n");
 593         spl_board_prepare_for_boot();
 594         jump_to_image_no_args(&spl_image);
 595 }
 596
 597 #ifdef CONFIG_SPL_SERIAL_SUPPORT
 598 /*
 599  * This requires UART clocks to be enabled.  In order for this to work the
 600  * caller must ensure that the gd pointer is valid.
 601  */
 602 void preloader_console_init(void)
 603 {
 604         gd->baudrate = CONFIG_BAUDRATE;
 605
 606         serial_init();          /* serial communications setup */
 607
 608         gd->have_console = 1;
 609
 610 #if CONFIG_IS_ENABLED(BANNER_PRINT)
 611         puts("\nU-Boot " SPL_TPL_NAME " " PLAIN_VERSION " (" U_BOOT_DATE " - "
 612              U_BOOT_TIME " " U_BOOT_TZ ")\n");
 613 #endif
 614 #ifdef CONFIG_SPL_DISPLAY_PRINT
 615         spl_display_print();
 616 #endif
 617 }
 618 #endif
 619
 620 /**
 621  * spl_relocate_stack_gd() - Relocate stack ready for board_init_r() execution
 622  *
 623  * Sometimes board_init_f() runs with a stack in SRAM but we want to use SDRAM
 624  * for the main board_init_r() execution. This is typically because we need
 625  * more stack space for things like the MMC sub-system.
 626  *
 627  * This function calculates the stack position, copies the global_data into
 628  * place, sets the new gd (except for ARM, for which setting GD within a C
 629  * function may not always work) and returns the new stack position. The
 630  * caller is responsible for setting up the sp register and, in the case
 631  * of ARM, setting up gd.
 632  *
 633  * All of this is done using the same layout and alignments as done in
 634  * board_init_f_init_reserve() / board_init_f_alloc_reserve().
 635  *
 636  * @return new stack location, or 0 to use the same stack
 637  */
 638 ulong spl_relocate_stack_gd(void)
 639 {
 640 #ifdef CONFIG_SPL_STACK_R
 641         gd_t *new_gd;
 642         ulong ptr = CONFIG_SPL_STACK_R_ADDR;
 643
 644 #if defined(CONFIG_SPL_SYS_MALLOC_SIMPLE) && CONFIG_VAL(SYS_MALLOC_F_LEN)
 645         if (CONFIG_SPL_STACK_R_MALLOC_SIMPLE_LEN) {
 646                 ptr -= CONFIG_SPL_STACK_R_MALLOC_SIMPLE_LEN;
 647                 gd->malloc_base = ptr;
 648                 gd->malloc_limit = CONFIG_SPL_STACK_R_MALLOC_SIMPLE_LEN;
 649                 gd->malloc_ptr = 0;
 650         }
 651 #endif
 652         /* Get stack position: use 8-byte alignment for ABI compliance */
 653         ptr = CONFIG_SPL_STACK_R_ADDR - roundup(sizeof(gd_t),16);
 654         new_gd = (gd_t *)ptr;
 655         memcpy(new_gd, (void *)gd, sizeof(gd_t));
 656 #if CONFIG_IS_ENABLED(DM)
 657         dm_fixup_for_gd_move(new_gd);
 658 #endif
 659 #if !defined(CONFIG_ARM)
 660         gd = new_gd;
 661 #endif
 662         return ptr;
 663 #else
 664         return 0;
 665 #endif
 666 }