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