Convert CONFIG_SYS_MONITOR_LEN to Kconfig
[J-u-boot.git] / common / spl / spl.c
CommitLineData
83d290c5 1// SPDX-License-Identifier: GPL-2.0+
bcae7211
A
2/*
3 * (C) Copyright 2010
4 * Texas Instruments, <www.ti.com>
5 *
6 * Aneesh V <aneesh@ti.com>
bcae7211 7 */
f1c6e192 8
bcae7211 9#include <common.h>
e945a726 10#include <bloblist.h>
8bee2d25 11#include <binman_sym.h>
52f24238 12#include <bootstage.h>
11516518 13#include <dm.h>
b0edea3c 14#include <handoff.h>
db41d65a 15#include <hang.h>
691d719d 16#include <init.h>
c30b7adb 17#include <irq_func.h>
f7ae49fc 18#include <log.h>
891d9e84 19#include <mapmem.h>
b03e0510 20#include <serial.h>
47f7bcae 21#include <spl.h>
10f6e4dc 22#include <system-constants.h>
401d1c4f 23#include <asm/global_data.h>
1d99e673 24#include <asm-generic/gpio.h>
bcae7211 25#include <asm/u-boot.h>
bb085b87 26#include <nand.h>
8cf686e1 27#include <fat.h>
3db71108 28#include <u-boot/crc.h>
121a165c
T
29#if CONFIG_IS_ENABLED(BANNER_PRINT)
30#include <timestamp.h>
31#endif
efb2172e 32#include <version.h>
8cf686e1 33#include <image.h>
2d01dd95 34#include <malloc.h>
31f9f0ea 35#include <mapmem.h>
11516518 36#include <dm/root.h>
4f6500aa 37#include <dm/util.h>
761ca31e 38#include <linux/compiler.h>
6e7585bb 39#include <fdt_support.h>
a8be2494 40#include <bootcount.h>
06985289 41#include <wdt.h>
bcae7211
A
42
43DECLARE_GLOBAL_DATA_PTR;
367ecbf2 44DECLARE_BINMAN_MAGIC_SYM;
bcae7211 45
3c6f8a0d 46#ifndef CONFIG_SYS_UBOOT_START
98463903 47#define CONFIG_SYS_UBOOT_START CONFIG_TEXT_BASE
3c6f8a0d 48#endif
ae83d882 49
47f7bcae 50u32 *boot_params_ptr = NULL;
9ea5c6ef 51
d8830cf8 52#if CONFIG_IS_ENABLED(BINMAN_UBOOT_SYMBOLS)
8bee2d25 53/* See spl.h for information about this */
dbf6be9f 54binman_sym_declare(ulong, u_boot_any, image_pos);
e82c624d
SG
55binman_sym_declare(ulong, u_boot_any, size);
56
57#ifdef CONFIG_TPL
2b8d2ccd
SG
58binman_sym_declare(ulong, u_boot_spl_any, image_pos);
59binman_sym_declare(ulong, u_boot_spl_any, size);
e82c624d 60#endif
8bee2d25 61
f86ca5ad 62#ifdef CONFIG_VPL
2b8d2ccd
SG
63binman_sym_declare(ulong, u_boot_vpl_any, image_pos);
64binman_sym_declare(ulong, u_boot_vpl_any, size);
f86ca5ad
SG
65#endif
66
d8830cf8
ANY
67#endif /* BINMAN_UBOOT_SYMBOLS */
68
58b504e5
AG
69/* Define board data structure */
70static struct bd_info bdata __attribute__ ((section(".data")));
71
b55881dd 72#if CONFIG_IS_ENABLED(SHOW_BOOT_PROGRESS)
496c5483
HS
73/*
74 * Board-specific Platform code can reimplement show_boot_progress () if needed
75 */
76__weak void show_boot_progress(int val) {}
cb80ff20 77#endif
496c5483 78
a343b4fe
HS
79#if defined(CONFIG_SPL_OS_BOOT) || CONFIG_IS_ENABLED(HANDOFF) || \
80 defined(CONFIG_SPL_ATF)
b0edea3c
SG
81/* weak, default platform-specific function to initialize dram banks */
82__weak int dram_init_banksize(void)
83{
84 return 0;
85}
86#endif
87
379c19ab
SS
88/*
89 * Default function to determine if u-boot or the OS should
90 * be started. This implementation always returns 1.
91 *
92 * Please implement your own board specific funcion to do this.
93 *
94 * RETURN
95 * 0 to not start u-boot
96 * positive if u-boot should start
97 */
7115007c 98#if CONFIG_IS_ENABLED(OS_BOOT)
379c19ab
SS
99__weak int spl_start_uboot(void)
100{
d6330064
SG
101 puts(SPL_TPL_PROMPT
102 "Please implement spl_start_uboot() for your board\n");
103 puts(SPL_TPL_PROMPT "Direct Linux boot not active!\n");
379c19ab
SS
104 return 1;
105}
431889d6
LM
106
107/*
108 * Weak default function for arch specific zImage check. Return zero
109 * and fill start and end address if image is recognized.
110 */
111int __weak bootz_setup(ulong image, ulong *start, ulong *end)
112{
113 return 1;
114}
7a0d8807
NBM
115
116int __weak booti_setup(ulong image, ulong *relocated_addr, ulong *size, bool force_reloc)
117{
118 return 1;
119}
379c19ab
SS
120#endif
121
de5dd4c4
PT
122/* Weak default function for arch/board-specific fixups to the spl_image_info */
123void __weak spl_perform_fixups(struct spl_image_info *spl_image)
124{
125}
126
a343b4fe 127void spl_fixup_fdt(void *fdt_blob)
6e7585bb 128{
a343b4fe 129#if defined(CONFIG_SPL_OF_LIBFDT)
6e7585bb
R
130 int err;
131
a343b4fe
HS
132 if (!fdt_blob)
133 return;
134
6e7585bb
R
135 err = fdt_check_header(fdt_blob);
136 if (err < 0) {
137 printf("fdt_root: %s\n", fdt_strerror(err));
138 return;
139 }
140
141 /* fixup the memory dt node */
142 err = fdt_shrink_to_minimum(fdt_blob, 0);
143 if (err == 0) {
d6330064 144 printf(SPL_TPL_PROMPT "fdt_shrink_to_minimum err - %d\n", err);
6e7585bb
R
145 return;
146 }
147
148 err = arch_fixup_fdt(fdt_blob);
149 if (err) {
d6330064 150 printf(SPL_TPL_PROMPT "arch_fixup_fdt err - %d\n", err);
6e7585bb
R
151 return;
152 }
153#endif
154}
155
e82c624d
SG
156ulong spl_get_image_pos(void)
157{
d8830cf8 158 if (!CONFIG_IS_ENABLED(BINMAN_UBOOT_SYMBOLS))
d7f07172
ANY
159 return BINMAN_SYM_MISSING;
160
f86ca5ad
SG
161#ifdef CONFIG_VPL
162 if (spl_next_phase() == PHASE_VPL)
2b8d2ccd 163 return binman_sym(ulong, u_boot_vpl_any, image_pos);
f86ca5ad
SG
164#endif
165 return spl_next_phase() == PHASE_SPL ?
2b8d2ccd 166 binman_sym(ulong, u_boot_spl_any, image_pos) :
e82c624d
SG
167 binman_sym(ulong, u_boot_any, image_pos);
168}
169
170ulong spl_get_image_size(void)
171{
d8830cf8 172 if (!CONFIG_IS_ENABLED(BINMAN_UBOOT_SYMBOLS))
d7f07172
ANY
173 return BINMAN_SYM_MISSING;
174
f86ca5ad
SG
175#ifdef CONFIG_VPL
176 if (spl_next_phase() == PHASE_VPL)
2b8d2ccd 177 return binman_sym(ulong, u_boot_vpl_any, size);
f86ca5ad
SG
178#endif
179 return spl_next_phase() == PHASE_SPL ?
2b8d2ccd 180 binman_sym(ulong, u_boot_spl_any, size) :
e82c624d
SG
181 binman_sym(ulong, u_boot_any, size);
182}
183
86c372af
SG
184ulong spl_get_image_text_base(void)
185{
f86ca5ad
SG
186#ifdef CONFIG_VPL
187 if (spl_next_phase() == PHASE_VPL)
188 return CONFIG_VPL_TEXT_BASE;
189#endif
190 return spl_next_phase() == PHASE_SPL ? CONFIG_SPL_TEXT_BASE :
98463903 191 CONFIG_TEXT_BASE;
86c372af
SG
192}
193
ea8256f0
SR
194/*
195 * Weak default function for board specific cleanup/preparation before
196 * Linux boot. Some boards/platforms might not need it, so just provide
197 * an empty stub here.
198 */
199__weak void spl_board_prepare_for_linux(void)
200{
201 /* Nothing to do! */
202}
203
a25d6b65
AG
204__weak void spl_board_prepare_for_optee(void *fdt)
205{
206}
207
c5922923
HT
208__weak const char *spl_board_loader_name(u32 boot_device)
209{
210 return NULL;
211}
212
949eb228
RS
213#if CONFIG_IS_ENABLED(OPTEE_IMAGE)
214__weak void __noreturn jump_to_image_optee(struct spl_image_info *spl_image)
215{
216 spl_optee_entry(NULL, NULL, spl_image->fdt_addr,
217 (void *)spl_image->entry_point);
218}
219#endif
220
3a3b9147
MS
221__weak void spl_board_prepare_for_boot(void)
222{
223 /* Nothing to do! */
224}
225
f3543e69 226__weak struct legacy_img_hdr *spl_get_load_buffer(ssize_t offset, size_t size)
04ce5427 227{
98463903 228 return map_sysmem(CONFIG_TEXT_BASE + offset, 0);
04ce5427
MV
229}
230
08574ed3 231#ifdef CONFIG_SPL_RAW_IMAGE_SUPPORT
d95ceb97 232void spl_set_header_raw_uboot(struct spl_image_info *spl_image)
0c3117b1 233{
d7f07172 234 ulong u_boot_pos = spl_get_image_pos();
8bee2d25 235
08574ed3 236#if CONFIG_SYS_MONITOR_LEN != 0
d95ceb97 237 spl_image->size = CONFIG_SYS_MONITOR_LEN;
08574ed3
TR
238#else
239 /* Unknown U-Boot size, let's assume it will not be more than 200 KB */
240 spl_image->size = 200 * 1024;
241#endif
55fe0e2b
MR
242
243 /*
244 * Binman error cases: address of the end of the previous region or the
245 * start of the image's entry area (usually 0) if there is no previous
246 * region.
247 */
248 if (u_boot_pos && u_boot_pos != BINMAN_SYM_MISSING) {
249 /* Binman does not support separated entry addresses */
8bee2d25
SG
250 spl_image->entry_point = u_boot_pos;
251 spl_image->load_addr = u_boot_pos;
252 } else {
253 spl_image->entry_point = CONFIG_SYS_UBOOT_START;
98463903 254 spl_image->load_addr = CONFIG_TEXT_BASE;
8bee2d25 255 }
d95ceb97
SG
256 spl_image->os = IH_OS_U_BOOT;
257 spl_image->name = "U-Boot";
0c3117b1 258}
08574ed3 259#endif
0c3117b1 260
674afa6b 261#if CONFIG_IS_ENABLED(LOAD_FIT_FULL)
8a9dc16e
MV
262/* Parse and load full fitImage in SPL */
263static int spl_load_fit_image(struct spl_image_info *spl_image,
f3543e69 264 const struct legacy_img_hdr *header)
8a9dc16e 265{
d9d7c20b 266 struct bootm_headers images;
8a9dc16e 267 const char *fit_uname_config = NULL;
60138aa8 268 uintptr_t fdt_hack;
8a9dc16e
MV
269 const char *uname;
270 ulong fw_data = 0, dt_data = 0, img_data = 0;
271 ulong fw_len = 0, dt_len = 0, img_len = 0;
272 int idx, conf_noffset;
273 int ret;
274
275#ifdef CONFIG_SPL_FIT_SIGNATURE
276 images.verify = 1;
277#endif
278 ret = fit_image_load(&images, (ulong)header,
279 NULL, &fit_uname_config,
280 IH_ARCH_DEFAULT, IH_TYPE_STANDALONE, -1,
51d3a8b5
AG
281 FIT_LOAD_OPTIONAL, &fw_data, &fw_len);
282 if (ret >= 0) {
283 printf("DEPRECATED: 'standalone = ' property.");
284 printf("Please use either 'firmware =' or 'kernel ='\n");
285 } else {
286 ret = fit_image_load(&images, (ulong)header, NULL,
287 &fit_uname_config, IH_ARCH_DEFAULT,
288 IH_TYPE_FIRMWARE, -1, FIT_LOAD_OPTIONAL,
289 &fw_data, &fw_len);
290 }
291
292 if (ret < 0) {
293 ret = fit_image_load(&images, (ulong)header, NULL,
294 &fit_uname_config, IH_ARCH_DEFAULT,
295 IH_TYPE_KERNEL, -1, FIT_LOAD_OPTIONAL,
296 &fw_data, &fw_len);
297 }
298
8a9dc16e
MV
299 if (ret < 0)
300 return ret;
301
302 spl_image->size = fw_len;
303 spl_image->entry_point = fw_data;
304 spl_image->load_addr = fw_data;
2eaae17b
AG
305 if (fit_image_get_os(header, ret, &spl_image->os))
306 spl_image->os = IH_OS_INVALID;
307 spl_image->name = genimg_get_os_name(spl_image->os);
8a9dc16e 308
d6330064 309 debug(SPL_TPL_PROMPT "payload image: %32s load addr: 0x%lx size: %d\n",
30c0740e 310 spl_image->name, spl_image->load_addr, spl_image->size);
8a9dc16e
MV
311
312#ifdef CONFIG_SPL_FIT_SIGNATURE
313 images.verify = 1;
314#endif
18fd663c 315 ret = fit_image_load(&images, (ulong)header, NULL, &fit_uname_config,
8a9dc16e
MV
316 IH_ARCH_DEFAULT, IH_TYPE_FLATDT, -1,
317 FIT_LOAD_OPTIONAL, &dt_data, &dt_len);
60138aa8 318 if (ret >= 0) {
a9a8271e 319 spl_image->fdt_addr = (void *)dt_data;
8a9dc16e 320
60138aa8
AG
321 if (spl_image->os == IH_OS_U_BOOT) {
322 /* HACK: U-boot expects FDT at a specific address */
323 fdt_hack = spl_image->load_addr + spl_image->size;
324 fdt_hack = (fdt_hack + 3) & ~3;
325 debug("Relocating FDT to %p\n", spl_image->fdt_addr);
326 memcpy((void *)fdt_hack, spl_image->fdt_addr, dt_len);
327 }
328 }
329
8a9dc16e
MV
330 conf_noffset = fit_conf_get_node((const void *)header,
331 fit_uname_config);
332 if (conf_noffset <= 0)
333 return 0;
334
335 for (idx = 0;
336 uname = fdt_stringlist_get((const void *)header, conf_noffset,
337 FIT_LOADABLE_PROP, idx,
338 NULL), uname;
339 idx++)
340 {
341#ifdef CONFIG_SPL_FIT_SIGNATURE
342 images.verify = 1;
343#endif
344 ret = fit_image_load(&images, (ulong)header,
345 &uname, &fit_uname_config,
346 IH_ARCH_DEFAULT, IH_TYPE_LOADABLE, -1,
347 FIT_LOAD_OPTIONAL_NON_ZERO,
348 &img_data, &img_len);
349 if (ret < 0)
350 return ret;
351 }
352
353 return 0;
354}
355#endif
356
9baab60b 357__weak int spl_parse_board_header(struct spl_image_info *spl_image,
2e0429bc 358 const struct spl_boot_device *bootdev,
9baab60b
T
359 const void *image_header, size_t size)
360{
361 return -EINVAL;
362}
363
c1108172 364__weak int spl_parse_legacy_header(struct spl_image_info *spl_image,
f3543e69 365 const struct legacy_img_hdr *header)
c1108172
SR
366{
367 /* LEGACY image not supported */
368 debug("Legacy boot image support not enabled, proceeding to other boot methods\n");
369 return -EINVAL;
370}
371
71316c1d 372int spl_parse_image_header(struct spl_image_info *spl_image,
2e0429bc 373 const struct spl_boot_device *bootdev,
f3543e69 374 const struct legacy_img_hdr *header)
8cf686e1 375{
674afa6b 376#if CONFIG_IS_ENABLED(LOAD_FIT_FULL)
8a9dc16e
MV
377 int ret = spl_load_fit_image(spl_image, header);
378
379 if (!ret)
380 return ret;
381#endif
77552b06 382 if (image_get_magic(header) == IH_MAGIC) {
c1108172 383 int ret;
dae5c2dc 384
c1108172
SR
385 ret = spl_parse_legacy_header(spl_image, header);
386 if (ret)
387 return ret;
8cf686e1 388 } else {
8c80eb3b
AA
389#ifdef CONFIG_SPL_PANIC_ON_RAW_IMAGE
390 /*
391 * CONFIG_SPL_PANIC_ON_RAW_IMAGE is defined when the
392 * code which loads images in SPL cannot guarantee that
393 * absolutely all read errors will be reported.
394 * An example is the LPC32XX MLC NAND driver, which
395 * will consider that a completely unreadable NAND block
396 * is bad, and thus should be skipped silently.
397 */
398 panic("** no mkimage signature but raw image not supported");
85a37729
PK
399#endif
400
7115007c 401#if CONFIG_IS_ENABLED(OS_BOOT)
7a0d8807
NBM
402#if defined(CMD_BOOTI)
403 ulong start, size;
404
405 if (!booti_setup((ulong)header, &start, &size, 0)) {
406 spl_image->name = "Linux";
407 spl_image->os = IH_OS_LINUX;
408 spl_image->load_addr = start;
409 spl_image->entry_point = start;
410 spl_image->size = size;
411 debug(SPL_TPL_PROMPT
412 "payload Image, load addr: 0x%lx size: %d\n",
413 spl_image->load_addr, spl_image->size);
414 return 0;
415 }
416#elif defined(CMD_BOOTZ)
431889d6
LM
417 ulong start, end;
418
419 if (!bootz_setup((ulong)header, &start, &end)) {
71316c1d
SG
420 spl_image->name = "Linux";
421 spl_image->os = IH_OS_LINUX;
422 spl_image->load_addr = CONFIG_SYS_LOAD_ADDR;
423 spl_image->entry_point = CONFIG_SYS_LOAD_ADDR;
424 spl_image->size = end - start;
d6330064
SG
425 debug(SPL_TPL_PROMPT
426 "payload zImage, load addr: 0x%lx size: %d\n",
71316c1d 427 spl_image->load_addr, spl_image->size);
431889d6
LM
428 return 0;
429 }
7a0d8807 430#endif
431889d6 431#endif
85a37729 432
2e0429bc 433 if (!spl_parse_board_header(spl_image, bootdev, (const void *)header, sizeof(*header)))
9baab60b
T
434 return 0;
435
24eb39b5 436#ifdef CONFIG_SPL_RAW_IMAGE_SUPPORT
8cf686e1 437 /* Signature not found - assume u-boot.bin */
026b2fe3 438 debug("mkimage signature not found - ih_magic = %x\n",
8cf686e1 439 header->ih_magic);
71316c1d 440 spl_set_header_raw_uboot(spl_image);
24eb39b5
AD
441#else
442 /* RAW image not supported, proceed to other boot methods. */
2d2531be 443 debug("Raw boot image support not enabled, proceeding to other boot methods\n");
24eb39b5 444 return -EINVAL;
8c80eb3b 445#endif
8cf686e1 446 }
24eb39b5 447
7e0f2267 448 return 0;
8cf686e1
A
449}
450
a759f1e0 451__weak void __noreturn jump_to_image_no_args(struct spl_image_info *spl_image)
8cf686e1 452{
4a0eb757
S
453 typedef void __noreturn (*image_entry_noargs_t)(void);
454
8cf686e1 455 image_entry_noargs_t image_entry =
11e1479b 456 (image_entry_noargs_t)spl_image->entry_point;
8cf686e1 457
30c0740e 458 debug("image entry point: 0x%lx\n", spl_image->entry_point);
4a0eb757 459 image_entry();
8cf686e1
A
460}
461
b0edea3c
SG
462#if CONFIG_IS_ENABLED(HANDOFF)
463/**
464 * Set up the SPL hand-off information
465 *
466 * This is initially empty (zero) but can be written by
467 */
468static int setup_spl_handoff(void)
469{
470 struct spl_handoff *ho;
471
7f3b79af 472 ho = bloblist_ensure(BLOBLISTT_U_BOOT_SPL_HANDOFF, sizeof(struct spl_handoff));
b0edea3c
SG
473 if (!ho)
474 return -ENOENT;
475
476 return 0;
477}
478
366291af
SG
479__weak int handoff_arch_save(struct spl_handoff *ho)
480{
481 return 0;
482}
483
b0edea3c
SG
484static int write_spl_handoff(void)
485{
486 struct spl_handoff *ho;
366291af 487 int ret;
b0edea3c 488
7f3b79af 489 ho = bloblist_find(BLOBLISTT_U_BOOT_SPL_HANDOFF, sizeof(struct spl_handoff));
b0edea3c
SG
490 if (!ho)
491 return -ENOENT;
492 handoff_save_dram(ho);
366291af
SG
493 ret = handoff_arch_save(ho);
494 if (ret)
495 return ret;
b0edea3c
SG
496 debug(SPL_TPL_PROMPT "Wrote SPL handoff\n");
497
498 return 0;
499}
500#else
501static inline int setup_spl_handoff(void) { return 0; }
502static inline int write_spl_handoff(void) { return 0; }
503
504#endif /* HANDOFF */
505
05e3a0d6
SG
506/**
507 * get_bootstage_id() - Get the bootstage ID to emit
508 *
509 * @start: true if this is for starting SPL, false for ending it
185f812c 510 * Return: bootstage ID to use
05e3a0d6
SG
511 */
512static enum bootstage_id get_bootstage_id(bool start)
513{
514 enum u_boot_phase phase = spl_phase();
515
516 if (IS_ENABLED(CONFIG_TPL_BUILD) && phase == PHASE_TPL)
517 return start ? BOOTSTAGE_ID_START_TPL : BOOTSTAGE_ID_END_TPL;
f86ca5ad
SG
518 else if (IS_ENABLED(CONFIG_VPL_BUILD) && phase == PHASE_VPL)
519 return start ? BOOTSTAGE_ID_START_VPL : BOOTSTAGE_ID_END_VPL;
05e3a0d6
SG
520 else
521 return start ? BOOTSTAGE_ID_START_SPL : BOOTSTAGE_ID_END_SPL;
522}
523
340f418a 524static int spl_common_init(bool setup_malloc)
bcae7211 525{
f3d46bd6
SG
526 int ret;
527
f1896c45 528#if CONFIG_VAL(SYS_MALLOC_F_LEN)
340f418a 529 if (setup_malloc) {
94b9e22e 530#ifdef CONFIG_MALLOC_F_ADDR
340f418a 531 gd->malloc_base = CONFIG_MALLOC_F_ADDR;
94b9e22e 532#endif
f1896c45 533 gd->malloc_limit = CONFIG_VAL(SYS_MALLOC_F_LEN);
340f418a
EC
534 gd->malloc_ptr = 0;
535 }
24dafad5 536#endif
31f9f0ea 537 ret = bootstage_init(u_boot_first_phase());
824bb1b4
SG
538 if (ret) {
539 debug("%s: Failed to set up bootstage: ret=%d\n", __func__,
540 ret);
541 return ret;
542 }
31f9f0ea
SG
543#ifdef CONFIG_BOOTSTAGE_STASH
544 if (!u_boot_first_phase()) {
545 const void *stash = map_sysmem(CONFIG_BOOTSTAGE_STASH_ADDR,
546 CONFIG_BOOTSTAGE_STASH_SIZE);
547
548 ret = bootstage_unstash(stash, CONFIG_BOOTSTAGE_STASH_SIZE);
549 if (ret)
550 debug("%s: Failed to unstash bootstage: ret=%d\n",
551 __func__, ret);
552 }
553#endif /* CONFIG_BOOTSTAGE_STASH */
05e3a0d6
SG
554 bootstage_mark_name(get_bootstage_id(true),
555 spl_phase_name(spl_phase()));
4d8d3056
SG
556#if CONFIG_IS_ENABLED(LOG)
557 ret = log_init();
558 if (ret) {
559 debug("%s: Failed to set up logging\n", __func__);
560 return ret;
561 }
562#endif
414cc151 563 if (CONFIG_IS_ENABLED(OF_REAL)) {
f3d46bd6
SG
564 ret = fdtdec_setup();
565 if (ret) {
566 debug("fdtdec_setup() returned error %d\n", ret);
070d00b8 567 return ret;
f3d46bd6
SG
568 }
569 }
f1c6e192 570 if (CONFIG_IS_ENABLED(DM)) {
b67eefdb 571 bootstage_start(BOOTSTAGE_ID_ACCUM_DM_SPL,
5256beec 572 spl_phase() == PHASE_TPL ? "dm tpl" : "dm_spl");
7f73ca48 573 /* With CONFIG_SPL_OF_PLATDATA, bring in all devices */
7d23b9cf 574 ret = dm_init_and_scan(!CONFIG_IS_ENABLED(OF_PLATDATA));
b67eefdb 575 bootstage_accum(BOOTSTAGE_ID_ACCUM_DM_SPL);
f3d46bd6
SG
576 if (ret) {
577 debug("dm_init_and_scan() returned error %d\n", ret);
070d00b8 578 return ret;
f3d46bd6
SG
579 }
580 }
340f418a
EC
581
582 return 0;
583}
584
58b504e5 585void spl_set_bd(void)
d1fc0a31 586{
c21f407b
SG
587 /*
588 * NOTE: On some platforms (e.g. x86) bdata may be in flash and not
589 * writeable.
590 */
58b504e5
AG
591 if (!gd->bd)
592 gd->bd = &bdata;
d1fc0a31
YS
593}
594
340f418a
EC
595int spl_early_init(void)
596{
597 int ret;
598
94cb986e
SG
599 debug("%s\n", __func__);
600
340f418a
EC
601 ret = spl_common_init(true);
602 if (ret)
603 return ret;
604 gd->flags |= GD_FLG_SPL_EARLY_INIT;
605
606 return 0;
607}
608
609int spl_init(void)
610{
611 int ret;
cf334edf
TR
612 bool setup_malloc = !(IS_ENABLED(CONFIG_SPL_STACK_R) &&
613 IS_ENABLED(CONFIG_SPL_SYS_MALLOC_SIMPLE));
340f418a 614
94cb986e
SG
615 debug("%s\n", __func__);
616
340f418a 617 if (!(gd->flags & GD_FLG_SPL_EARLY_INIT)) {
cf334edf 618 ret = spl_common_init(setup_malloc);
340f418a
EC
619 if (ret)
620 return ret;
621 }
070d00b8 622 gd->flags |= GD_FLG_SPL_INIT;
2d01dd95 623
070d00b8
SG
624 return 0;
625}
626
f101e4bd
NK
627#ifndef BOOT_DEVICE_NONE
628#define BOOT_DEVICE_NONE 0xdeadbeef
629#endif
630
f101e4bd
NK
631__weak void board_boot_order(u32 *spl_boot_list)
632{
633 spl_boot_list[0] = spl_boot_device();
634}
635
c10939d8
T
636__weak int spl_check_board_image(struct spl_image_info *spl_image,
637 const struct spl_boot_device *bootdev)
638{
639 return 0;
640}
641
29d357d7
SG
642static int spl_load_image(struct spl_image_info *spl_image,
643 struct spl_image_loader *loader)
070d00b8 644{
dae5c2dc 645 int ret;
ecdfd69a
SG
646 struct spl_boot_device bootdev;
647
29d357d7 648 bootdev.boot_device = loader->boot_device;
ecdfd69a
SG
649 bootdev.boot_device_name = NULL;
650
dae5c2dc
SG
651 ret = loader->load_image(spl_image, &bootdev);
652#ifdef CONFIG_SPL_LEGACY_IMAGE_CRC_CHECK
653 if (!ret && spl_image->dcrc_length) {
654 /* check data crc */
655 ulong dcrc = crc32_wd(0, (unsigned char *)spl_image->dcrc_data,
656 spl_image->dcrc_length, CHUNKSZ_CRC32);
657 if (dcrc != spl_image->dcrc) {
658 puts("SPL: Image data CRC check failed!\n");
659 ret = -EINVAL;
660 }
661 }
662#endif
c10939d8
T
663 if (!ret)
664 ret = spl_check_board_image(spl_image, &bootdev);
665
dae5c2dc 666 return ret;
540bfe7d
SG
667}
668
669/**
fd4ee98d 670 * boot_from_devices() - Try loading a booting U-Boot from a list of devices
540bfe7d
SG
671 *
672 * @spl_image: Place to put the image details if successful
673 * @spl_boot_list: List of boot devices to try
674 * @count: Number of elements in spl_boot_list
185f812c 675 * Return: 0 if OK, -ENODEV if there were no boot devices
7d84fbb5
SG
676 * if CONFIG_SHOW_ERRORS is enabled, returns -ENXIO if there were
677 * devices but none worked
540bfe7d
SG
678 */
679static int boot_from_devices(struct spl_image_info *spl_image,
680 u32 spl_boot_list[], int count)
681{
5a61bf17
SG
682 struct spl_image_loader *drv =
683 ll_entry_start(struct spl_image_loader, spl_image_loader);
684 const int n_ents =
685 ll_entry_count(struct spl_image_loader, spl_image_loader);
7d84fbb5 686 int ret = -ENODEV;
540bfe7d
SG
687 int i;
688
689 for (i = 0; i < count && spl_boot_list[i] != BOOT_DEVICE_NONE; i++) {
690 struct spl_image_loader *loader;
7d84fbb5
SG
691 int bootdev = spl_boot_list[i];
692
693 if (CONFIG_IS_ENABLED(SHOW_ERRORS))
694 ret = -ENXIO;
5a61bf17
SG
695 for (loader = drv; loader != drv + n_ents; loader++) {
696 if (bootdev != loader->boot_device)
697 continue;
698 if (!CONFIG_IS_ENABLED(SILENT_CONSOLE)) {
699 if (loader)
700 printf("Trying to boot from %s\n",
701 spl_loader_name(loader));
702 else if (CONFIG_IS_ENABLED(SHOW_ERRORS)) {
703 printf(SPL_TPL_PROMPT
704 "Unsupported Boot Device %d\n",
705 bootdev);
706 } else {
707 puts(SPL_TPL_PROMPT
708 "Unsupported Boot Device!\n");
709 }
710 }
711 if (loader &&
712 !spl_load_image(spl_image, loader)) {
713 spl_image->boot_device = bootdev;
714 return 0;
715 }
de5dd4c4 716 }
540bfe7d
SG
717 }
718
7d84fbb5 719 return ret;
5211b87e
NK
720}
721
a9a3aada
PR
722#if defined(CONFIG_SPL_FRAMEWORK_BOARD_INIT_F)
723void board_init_f(ulong dummy)
724{
725 if (CONFIG_IS_ENABLED(OF_CONTROL)) {
726 int ret;
727
728 ret = spl_early_init();
729 if (ret) {
730 debug("spl_early_init() failed: %d\n", ret);
731 hang();
732 }
733 }
734
3988be5f 735 preloader_console_init();
a9a3aada
PR
736}
737#endif
738
5211b87e
NK
739void board_init_r(gd_t *dummy1, ulong dummy2)
740{
d32b2d1c
SG
741 u32 spl_boot_list[] = {
742 BOOT_DEVICE_NONE,
743 BOOT_DEVICE_NONE,
744 BOOT_DEVICE_NONE,
745 BOOT_DEVICE_NONE,
746 BOOT_DEVICE_NONE,
747 };
748 struct spl_image_info spl_image;
e945a726 749 int ret;
5211b87e 750
d6330064 751 debug(">>" SPL_TPL_PROMPT "board_init_r()\n");
d1fc0a31 752
58b504e5
AG
753 spl_set_bd();
754
10f6e4dc
TR
755#if defined(CONFIG_SYS_SPL_MALLOC)
756 mem_malloc_init(SYS_SPL_MALLOC_START, CONFIG_SYS_SPL_MALLOC_SIZE);
5211b87e
NK
757 gd->flags |= GD_FLG_FULL_MALLOC_INIT;
758#endif
759 if (!(gd->flags & GD_FLG_SPL_INIT)) {
760 if (spl_init())
761 hang();
762 }
f9d42d82 763#if !defined(CONFIG_PPC) && !defined(CONFIG_ARCH_MX6)
5211b87e
NK
764 /*
765 * timer_init() does not exist on PPC systems. The timer is initialized
766 * and enabled (decrementer) in interrupt_init() here.
767 */
768 timer_init();
769#endif
3cd71981
SG
770 if (CONFIG_IS_ENABLED(BLOBLIST)) {
771 ret = bloblist_init();
772 if (ret) {
773 debug("%s: Failed to set up bloblist: ret=%d\n",
774 __func__, ret);
775 puts(SPL_TPL_PROMPT "Cannot set up bloblist\n");
776 hang();
777 }
778 }
779 if (CONFIG_IS_ENABLED(HANDOFF)) {
780 int ret;
781
782 ret = setup_spl_handoff();
783 if (ret) {
784 puts(SPL_TPL_PROMPT "Cannot set up SPL handoff\n");
785 hang();
786 }
787 }
5211b87e 788
1d99e673
EJ
789 if (CONFIG_IS_ENABLED(GPIO_HOG))
790 gpio_hog_probe_all();
791
af2f4426 792#if CONFIG_IS_ENABLED(BOARD_INIT)
5211b87e
NK
793 spl_board_init();
794#endif
795
078111b9 796#if defined(CONFIG_SPL_WATCHDOG) && CONFIG_IS_ENABLED(WDT)
06985289
SR
797 initr_watchdog();
798#endif
799
a343b4fe
HS
800 if (IS_ENABLED(CONFIG_SPL_OS_BOOT) || CONFIG_IS_ENABLED(HANDOFF) ||
801 IS_ENABLED(CONFIG_SPL_ATF))
b0edea3c
SG
802 dram_init_banksize();
803
a8be2494
LM
804 bootcount_inc();
805
4f6500aa
SG
806 /* Dump driver model states to aid analysis */
807 if (CONFIG_IS_ENABLED(DM_STATS)) {
808 struct dm_stats mem;
809
810 dm_get_mem(&mem);
811 dm_dump_mem(&mem);
812 }
813
d32b2d1c 814 memset(&spl_image, '\0', sizeof(spl_image));
5bf5250e
VM
815#ifdef CONFIG_SYS_SPL_ARGS_ADDR
816 spl_image.arg = (void *)CONFIG_SYS_SPL_ARGS_ADDR;
817#endif
de5dd4c4 818 spl_image.boot_device = BOOT_DEVICE_NONE;
f101e4bd 819 board_boot_order(spl_boot_list);
f101e4bd 820
7d84fbb5
SG
821 ret = boot_from_devices(&spl_image, spl_boot_list,
822 ARRAY_SIZE(spl_boot_list));
823 if (ret) {
824 if (CONFIG_IS_ENABLED(SHOW_ERRORS) &&
825 CONFIG_IS_ENABLED(LIBCOMMON_SUPPORT))
826 printf(SPL_TPL_PROMPT "failed to boot from all boot devices (err=%d)\n",
827 ret);
828 else
829 puts(SPL_TPL_PROMPT "failed to boot from all boot devices\n");
5211b87e 830 hang();
f101e4bd 831 }
5211b87e 832
de5dd4c4 833 spl_perform_fixups(&spl_image);
b0edea3c
SG
834 if (CONFIG_IS_ENABLED(HANDOFF)) {
835 ret = write_spl_handoff();
836 if (ret)
837 printf(SPL_TPL_PROMPT
838 "SPL hand-off write failed (err=%d)\n", ret);
839 }
e945a726
SG
840 if (CONFIG_IS_ENABLED(BLOBLIST)) {
841 ret = bloblist_finish();
842 if (ret)
843 printf("Warning: Failed to finish bloblist (ret=%d)\n",
844 ret);
845 }
de5dd4c4 846
9ea5c6ef 847 switch (spl_image.os) {
8cf686e1 848 case IH_OS_U_BOOT:
1a9e75bd 849 debug("Jumping to %s...\n", spl_phase_name(spl_next_phase()));
8cf686e1 850 break;
1d379090
PT
851#if CONFIG_IS_ENABLED(ATF)
852 case IH_OS_ARM_TRUSTED_FIRMWARE:
853 debug("Jumping to U-Boot via ARM Trusted Firmware\n");
a343b4fe 854 spl_fixup_fdt(spl_image.fdt_addr);
1d379090
PT
855 spl_invoke_atf(&spl_image);
856 break;
857#endif
51827f9a 858#if CONFIG_IS_ENABLED(OPTEE_IMAGE)
70fe2876
KY
859 case IH_OS_TEE:
860 debug("Jumping to U-Boot via OP-TEE\n");
a25d6b65 861 spl_board_prepare_for_optee(spl_image.fdt_addr);
949eb228 862 jump_to_image_optee(&spl_image);
70fe2876
KY
863 break;
864#endif
5e30e45c
LA
865#if CONFIG_IS_ENABLED(OPENSBI)
866 case IH_OS_OPENSBI:
867 debug("Jumping to U-Boot via RISC-V OpenSBI\n");
868 spl_invoke_opensbi(&spl_image);
869 break;
870#endif
7115007c 871#if CONFIG_IS_ENABLED(OS_BOOT)
379c19ab
SS
872 case IH_OS_LINUX:
873 debug("Jumping to Linux\n");
a343b4fe
HS
874#if defined(CONFIG_SYS_SPL_ARGS_ADDR)
875 spl_fixup_fdt((void *)CONFIG_SYS_SPL_ARGS_ADDR);
876#endif
379c19ab 877 spl_board_prepare_for_linux();
5bf5250e 878 jump_to_image_linux(&spl_image);
379c19ab 879#endif
8cf686e1 880 default:
42120981 881 debug("Unsupported OS image.. Jumping nevertheless..\n");
8cf686e1 882 }
f1896c45 883#if CONFIG_VAL(SYS_MALLOC_F_LEN) && !defined(CONFIG_SYS_SPL_MALLOC_SIZE)
30c0740e 884 debug("SPL malloc() used 0x%lx bytes (%ld KB)\n", gd->malloc_ptr,
fb4f5e7c
SG
885 gd->malloc_ptr / 1024);
886#endif
05e3a0d6 887 bootstage_mark_name(get_bootstage_id(false), "end phase");
824bb1b4 888#ifdef CONFIG_BOOTSTAGE_STASH
824bb1b4
SG
889 ret = bootstage_stash((void *)CONFIG_BOOTSTAGE_STASH_ADDR,
890 CONFIG_BOOTSTAGE_STASH_SIZE);
891 if (ret)
892 debug("Failed to stash bootstage: err=%d\n", ret);
893#endif
a8c5112a 894
3a3b9147 895 spl_board_prepare_for_boot();
a759f1e0 896 jump_to_image_no_args(&spl_image);
bcae7211
A
897}
898
6507f133
TR
899/*
900 * This requires UART clocks to be enabled. In order for this to work the
901 * caller must ensure that the gd pointer is valid.
902 */
bcae7211
A
903void preloader_console_init(void)
904{
2a736066 905#ifdef CONFIG_SPL_SERIAL
bcae7211
A
906 gd->baudrate = CONFIG_BAUDRATE;
907
bcae7211
A
908 serial_init(); /* serial communications setup */
909
b88befa5
IY
910 gd->have_console = 1;
911
aedc08b2 912#if CONFIG_IS_ENABLED(BANNER_PRINT)
d6330064
SG
913 puts("\nU-Boot " SPL_TPL_NAME " " PLAIN_VERSION " (" U_BOOT_DATE " - "
914 U_BOOT_TIME " " U_BOOT_TZ ")\n");
0292bc0d 915#endif
861a86f4
TR
916#ifdef CONFIG_SPL_DISPLAY_PRINT
917 spl_display_print();
918#endif
117a0e02 919#endif
3988be5f 920}
db910353 921
d8c03320
SG
922/**
923 * This function is called before the stack is changed from initial stack to
924 * relocated stack. It tries to dump the stack size used
925 */
926__weak void spl_relocate_stack_check(void)
927{
928#if CONFIG_IS_ENABLED(SYS_REPORT_STACK_F_USAGE)
929 ulong init_sp = gd->start_addr_sp;
930 ulong stack_bottom = init_sp - CONFIG_VAL(SIZE_LIMIT_PROVIDE_STACK);
931 u8 *ptr = (u8 *)stack_bottom;
932 ulong i;
933
934 for (i = 0; i < CONFIG_VAL(SIZE_LIMIT_PROVIDE_STACK); i++) {
935 if (*ptr != CONFIG_VAL(SYS_STACK_F_CHECK_BYTE))
936 break;
937 ptr++;
938 }
939 printf("SPL initial stack usage: %lu bytes\n",
940 CONFIG_VAL(SIZE_LIMIT_PROVIDE_STACK) - i);
941#endif
942}
943
db910353
SG
944/**
945 * spl_relocate_stack_gd() - Relocate stack ready for board_init_r() execution
946 *
947 * Sometimes board_init_f() runs with a stack in SRAM but we want to use SDRAM
948 * for the main board_init_r() execution. This is typically because we need
949 * more stack space for things like the MMC sub-system.
950 *
951 * This function calculates the stack position, copies the global_data into
adc421e4
AA
952 * place, sets the new gd (except for ARM, for which setting GD within a C
953 * function may not always work) and returns the new stack position. The
954 * caller is responsible for setting up the sp register and, in the case
955 * of ARM, setting up gd.
956 *
957 * All of this is done using the same layout and alignments as done in
958 * board_init_f_init_reserve() / board_init_f_alloc_reserve().
db910353 959 *
185f812c 960 * Return: new stack location, or 0 to use the same stack
db910353
SG
961 */
962ulong spl_relocate_stack_gd(void)
963{
964#ifdef CONFIG_SPL_STACK_R
965 gd_t *new_gd;
adc421e4 966 ulong ptr = CONFIG_SPL_STACK_R_ADDR;
db910353 967
d8c03320
SG
968 if (CONFIG_IS_ENABLED(SYS_REPORT_STACK_F_USAGE))
969 spl_relocate_stack_check();
970
ae2cee2e 971#if defined(CONFIG_SPL_SYS_MALLOC_SIMPLE) && CONFIG_VAL(SYS_MALLOC_F_LEN)
dcfcb8d4 972 if (CONFIG_SPL_STACK_R_MALLOC_SIMPLE_LEN) {
438dcabb
SG
973 debug("SPL malloc() before relocation used 0x%lx bytes (%ld KB)\n",
974 gd->malloc_ptr, gd->malloc_ptr / 1024);
dcfcb8d4
HG
975 ptr -= CONFIG_SPL_STACK_R_MALLOC_SIMPLE_LEN;
976 gd->malloc_base = ptr;
977 gd->malloc_limit = CONFIG_SPL_STACK_R_MALLOC_SIMPLE_LEN;
978 gd->malloc_ptr = 0;
979 }
980#endif
adc421e4
AA
981 /* Get stack position: use 8-byte alignment for ABI compliance */
982 ptr = CONFIG_SPL_STACK_R_ADDR - roundup(sizeof(gd_t),16);
983 new_gd = (gd_t *)ptr;
984 memcpy(new_gd, (void *)gd, sizeof(gd_t));
2f11cd91
SG
985#if CONFIG_IS_ENABLED(DM)
986 dm_fixup_for_gd_move(new_gd);
987#endif
c7e1effb 988#if !defined(CONFIG_ARM) && !defined(CONFIG_RISCV)
adc421e4
AA
989 gd = new_gd;
990#endif
db910353
SG
991 return ptr;
992#else
993 return 0;
994#endif
995}
c6604441 996
4d145f26
PR
997#if defined(CONFIG_BOOTCOUNT_LIMIT) && \
998 ((!defined(CONFIG_TPL_BUILD) && !defined(CONFIG_SPL_BOOTCOUNT_LIMIT)) || \
999 (defined(CONFIG_TPL_BUILD) && !defined(CONFIG_TPL_BOOTCOUNT_LIMIT)))
c6604441
SG
1000void bootcount_store(ulong a)
1001{
1002}
1003
1004ulong bootcount_load(void)
1005{
1006 return 0;
1007}
1008#endif
This page took 0.621206 seconds and 4 git commands to generate.