blob: b65c439e7aa9b5818a28a30a4c308141fbce946a [file] [log] [blame]
Tom Rini10e47792018-05-06 17:58:06 -04001// SPDX-License-Identifier: GPL-2.0+
Aneesh Vb8e60b92011-07-21 09:10:21 -04002/*
3 * (C) Copyright 2010
4 * Texas Instruments, <www.ti.com>
5 *
6 * Aneesh V <aneesh@ti.com>
Aneesh Vb8e60b92011-07-21 09:10:21 -04007 */
Philipp Tomsich60e15782017-06-30 19:02:53 +02008
Aneesh Vb8e60b92011-07-21 09:10:21 -04009#include <common.h>
Simon Glass4e0a52d2018-11-15 18:43:51 -070010#include <bloblist.h>
Simon Glass867a3982017-11-13 18:55:03 -070011#include <binman_sym.h>
Simon Glass1ea97892020-05-10 11:40:00 -060012#include <bootstage.h>
Simon Glass1801a3e2014-11-10 17:16:46 -070013#include <dm.h>
Simon Glasse14f1a22018-11-15 18:44:09 -070014#include <handoff.h>
Simon Glassf11478f2019-12-28 10:45:07 -070015#include <hang.h>
Simon Glass97589732020-05-10 11:40:02 -060016#include <init.h>
Simon Glass9b61c7c2019-11-14 12:57:41 -070017#include <irq_func.h>
Simon Glass0f2af882020-05-10 11:40:05 -060018#include <log.h>
Simon Glass2192e982021-03-07 17:35:14 -070019#include <mapmem.h>
Simon Glass36736182019-11-14 12:57:24 -070020#include <serial.h>
Tom Rini28591df2012-08-13 12:03:19 -070021#include <spl.h>
Sean Anderson3a4a2b72023-11-08 11:48:47 -050022#include <spl_load.h>
Tom Rini166e3222022-05-27 12:48:32 -040023#include <system-constants.h>
Simon Glass3ba929a2020-10-30 21:38:53 -060024#include <asm/global_data.h>
Eddie James652b8692022-02-07 17:09:01 -060025#include <asm-generic/gpio.h>
Aneesh Vb8e60b92011-07-21 09:10:21 -040026#include <asm/u-boot.h>
Simon Schwarz992dcf72011-09-14 15:29:26 -040027#include <nand.h>
Aneesh V13a74c12011-07-21 09:10:27 -040028#include <fat.h>
Simon Glass48b6c6b2019-11-14 12:57:16 -070029#include <u-boot/crc.h>
Pali Rohár6e1f0852021-08-02 15:18:38 +020030#if CONFIG_IS_ENABLED(BANNER_PRINT)
31#include <timestamp.h>
32#endif
Simon Glass50402412011-10-10 08:55:19 +000033#include <version.h>
Aneesh V13a74c12011-07-21 09:10:27 -040034#include <image.h>
Aneesh V0560be22011-10-21 12:29:34 -040035#include <malloc.h>
Simon Glass0e864562019-10-21 17:26:52 -060036#include <mapmem.h>
Simon Glass1801a3e2014-11-10 17:16:46 -070037#include <dm/root.h>
Simon Glass099dc1f2022-05-08 04:39:27 -060038#include <dm/util.h>
Nikhil M Jaineda07d62023-04-10 14:19:13 +053039#include <dm/device-internal.h>
40#include <dm/uclass-internal.h>
Andreas Müller0cda7a42012-01-04 15:26:24 +000041#include <linux/compiler.h>
B, Ravi4cf02b12017-04-18 17:27:27 +053042#include <fdt_support.h>
Lukasz Majewskia4858602018-05-02 16:10:54 +020043#include <bootcount.h>
Stefan Roese502acb02019-04-11 15:58:44 +020044#include <wdt.h>
Devarsh Thakkar84e08342023-12-05 21:25:16 +053045#include <video.h>
Aneesh Vb8e60b92011-07-21 09:10:21 -040046
47DECLARE_GLOBAL_DATA_PTR;
Alper Nebi Yasak9634dc92022-06-18 15:13:11 +030048DECLARE_BINMAN_MAGIC_SYM;
Aneesh Vb8e60b92011-07-21 09:10:21 -040049
Tom Rini28591df2012-08-13 12:03:19 -070050u32 *boot_params_ptr = NULL;
Simon Schwarze21d2d82011-09-14 15:33:34 -040051
Alper Nebi Yasakd6d2c9b2022-06-18 15:13:09 +030052#if CONFIG_IS_ENABLED(BINMAN_UBOOT_SYMBOLS)
Simon Glass867a3982017-11-13 18:55:03 -070053/* See spl.h for information about this */
Simon Glass9dcc8612018-08-01 15:22:42 -060054binman_sym_declare(ulong, u_boot_any, image_pos);
Simon Glass596f31c2019-12-08 17:40:12 -070055binman_sym_declare(ulong, u_boot_any, size);
56
57#ifdef CONFIG_TPL
Simon Glass5a332c12022-10-20 18:22:41 -060058binman_sym_declare(ulong, u_boot_spl_any, image_pos);
59binman_sym_declare(ulong, u_boot_spl_any, size);
Simon Glass596f31c2019-12-08 17:40:12 -070060#endif
Simon Glass867a3982017-11-13 18:55:03 -070061
Simon Glass7eec8842022-04-30 00:56:52 -060062#ifdef CONFIG_VPL
Simon Glass5a332c12022-10-20 18:22:41 -060063binman_sym_declare(ulong, u_boot_vpl_any, image_pos);
64binman_sym_declare(ulong, u_boot_vpl_any, size);
Simon Glass7eec8842022-04-30 00:56:52 -060065#endif
66
Alper Nebi Yasakd6d2c9b2022-06-18 15:13:09 +030067#endif /* BINMAN_UBOOT_SYMBOLS */
68
Alexandru Gagniuc7861f8b2021-04-08 11:56:11 -050069/* Define board data structure */
70static struct bd_info bdata __attribute__ ((section(".data")));
71
Marek Vasut98154342021-10-23 03:06:03 +020072#if CONFIG_IS_ENABLED(SHOW_BOOT_PROGRESS)
Simon Schwarz305bc4c2012-03-15 04:01:38 +000073/*
Heiko Schocher747ceee2016-06-07 08:31:20 +020074 * Board-specific Platform code can reimplement show_boot_progress () if needed
75 */
76__weak void show_boot_progress(int val) {}
Tom Rinia9765d02021-05-03 16:48:58 -040077#endif
Heiko Schocher747ceee2016-06-07 08:31:20 +020078
Heiko Stuebner593b82e2020-05-25 19:57:25 +020079#if defined(CONFIG_SPL_OS_BOOT) || CONFIG_IS_ENABLED(HANDOFF) || \
80 defined(CONFIG_SPL_ATF)
Simon Glasse14f1a22018-11-15 18:44:09 -070081/* weak, default platform-specific function to initialize dram banks */
82__weak int dram_init_banksize(void)
83{
84 return 0;
85}
86#endif
87
Heiko Schocher747ceee2016-06-07 08:31:20 +020088/*
Simon Schwarz305bc4c2012-03-15 04:01:38 +000089 * 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 */
Tom Rinic2e78882021-10-30 23:03:48 -040098#if CONFIG_IS_ENABLED(OS_BOOT)
Simon Schwarz305bc4c2012-03-15 04:01:38 +000099__weak int spl_start_uboot(void)
100{
Simon Glassdbd3f112018-11-15 18:43:56 -0700101 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");
Simon Schwarz305bc4c2012-03-15 04:01:38 +0000104 return 1;
105}
Ladislav Michl9c743722016-07-12 20:28:14 +0200106
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}
Nathan Barrett-Morrisonc20400a2022-02-02 15:05:18 -0500115
116int __weak booti_setup(ulong image, ulong *relocated_addr, ulong *size, bool force_reloc)
117{
118 return 1;
119}
Simon Schwarz305bc4c2012-03-15 04:01:38 +0000120#endif
121
Philipp Tomsich58beb6e2018-05-24 17:15:50 +0200122/* 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
Heiko Stuebner593b82e2020-05-25 19:57:25 +0200127void spl_fixup_fdt(void *fdt_blob)
B, Ravi4cf02b12017-04-18 17:27:27 +0530128{
Heiko Stuebner593b82e2020-05-25 19:57:25 +0200129#if defined(CONFIG_SPL_OF_LIBFDT)
B, Ravi4cf02b12017-04-18 17:27:27 +0530130 int err;
131
Heiko Stuebner593b82e2020-05-25 19:57:25 +0200132 if (!fdt_blob)
133 return;
134
B, Ravi4cf02b12017-04-18 17:27:27 +0530135 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) {
Simon Glassdbd3f112018-11-15 18:43:56 -0700144 printf(SPL_TPL_PROMPT "fdt_shrink_to_minimum err - %d\n", err);
B, Ravi4cf02b12017-04-18 17:27:27 +0530145 return;
146 }
147
148 err = arch_fixup_fdt(fdt_blob);
149 if (err) {
Simon Glassdbd3f112018-11-15 18:43:56 -0700150 printf(SPL_TPL_PROMPT "arch_fixup_fdt err - %d\n", err);
B, Ravi4cf02b12017-04-18 17:27:27 +0530151 return;
152 }
153#endif
154}
155
Devarsh Thakkar84e08342023-12-05 21:25:16 +0530156int spl_reserve_video_from_ram_top(void)
157{
158 if (CONFIG_IS_ENABLED(VIDEO)) {
159 ulong addr;
160 int ret;
161
162 addr = gd->ram_top;
163 ret = video_reserve(&addr);
164 if (ret)
165 return ret;
166 debug("Reserving %luk for video at: %08lx\n",
167 ((unsigned long)gd->relocaddr - addr) >> 10, addr);
168 gd->relocaddr = addr;
169 }
170
171 return 0;
172}
173
Simon Glass596f31c2019-12-08 17:40:12 -0700174ulong spl_get_image_pos(void)
175{
Alper Nebi Yasakd6d2c9b2022-06-18 15:13:09 +0300176 if (!CONFIG_IS_ENABLED(BINMAN_UBOOT_SYMBOLS))
Alper Nebi Yasak173321c2022-06-18 15:13:06 +0300177 return BINMAN_SYM_MISSING;
178
Simon Glass7eec8842022-04-30 00:56:52 -0600179#ifdef CONFIG_VPL
180 if (spl_next_phase() == PHASE_VPL)
Simon Glass5a332c12022-10-20 18:22:41 -0600181 return binman_sym(ulong, u_boot_vpl_any, image_pos);
Simon Glass7eec8842022-04-30 00:56:52 -0600182#endif
183 return spl_next_phase() == PHASE_SPL ?
Simon Glass5a332c12022-10-20 18:22:41 -0600184 binman_sym(ulong, u_boot_spl_any, image_pos) :
Simon Glass596f31c2019-12-08 17:40:12 -0700185 binman_sym(ulong, u_boot_any, image_pos);
186}
187
188ulong spl_get_image_size(void)
189{
Alper Nebi Yasakd6d2c9b2022-06-18 15:13:09 +0300190 if (!CONFIG_IS_ENABLED(BINMAN_UBOOT_SYMBOLS))
Alper Nebi Yasak173321c2022-06-18 15:13:06 +0300191 return BINMAN_SYM_MISSING;
192
Simon Glass7eec8842022-04-30 00:56:52 -0600193#ifdef CONFIG_VPL
194 if (spl_next_phase() == PHASE_VPL)
Simon Glass5a332c12022-10-20 18:22:41 -0600195 return binman_sym(ulong, u_boot_vpl_any, size);
Simon Glass7eec8842022-04-30 00:56:52 -0600196#endif
197 return spl_next_phase() == PHASE_SPL ?
Simon Glass5a332c12022-10-20 18:22:41 -0600198 binman_sym(ulong, u_boot_spl_any, size) :
Simon Glass596f31c2019-12-08 17:40:12 -0700199 binman_sym(ulong, u_boot_any, size);
200}
201
Simon Glass53857ee2021-01-24 10:06:03 -0700202ulong spl_get_image_text_base(void)
203{
Simon Glass7eec8842022-04-30 00:56:52 -0600204#ifdef CONFIG_VPL
205 if (spl_next_phase() == PHASE_VPL)
206 return CONFIG_VPL_TEXT_BASE;
207#endif
208 return spl_next_phase() == PHASE_SPL ? CONFIG_SPL_TEXT_BASE :
Simon Glass72cc5382022-10-20 18:22:39 -0600209 CONFIG_TEXT_BASE;
Simon Glass53857ee2021-01-24 10:06:03 -0700210}
211
Stefan Roeseec90d342012-08-23 08:34:21 +0200212/*
213 * Weak default function for board specific cleanup/preparation before
214 * Linux boot. Some boards/platforms might not need it, so just provide
215 * an empty stub here.
216 */
217__weak void spl_board_prepare_for_linux(void)
218{
219 /* Nothing to do! */
220}
221
Alexandru Gagniucf2b410a2021-07-15 14:19:24 -0500222__weak void spl_board_prepare_for_optee(void *fdt)
223{
224}
225
Heiko Thiery3db30332022-01-17 16:25:41 +0100226__weak const char *spl_board_loader_name(u32 boot_device)
227{
228 return NULL;
229}
230
Ricardo Salvetiec0352a2021-10-20 15:12:06 +0300231#if CONFIG_IS_ENABLED(OPTEE_IMAGE)
232__weak void __noreturn jump_to_image_optee(struct spl_image_info *spl_image)
233{
234 spl_optee_entry(NULL, NULL, spl_image->fdt_addr,
235 (void *)spl_image->entry_point);
236}
237#endif
238
Michal Simek7a8465b2016-05-10 07:54:20 +0200239__weak void spl_board_prepare_for_boot(void)
240{
241 /* Nothing to do! */
242}
243
Simon Glassbb7d3bb2022-09-06 20:26:52 -0600244__weak struct legacy_img_hdr *spl_get_load_buffer(ssize_t offset, size_t size)
Marek Vasut1dda46f2018-08-14 11:27:02 +0200245{
Simon Glass72cc5382022-10-20 18:22:39 -0600246 return map_sysmem(CONFIG_TEXT_BASE + offset, 0);
Marek Vasut1dda46f2018-08-14 11:27:02 +0200247}
248
Tom Rini7f184322022-10-28 20:27:07 -0400249#ifdef CONFIG_SPL_RAW_IMAGE_SUPPORT
Simon Glass11a1a272016-09-24 18:19:52 -0600250void spl_set_header_raw_uboot(struct spl_image_info *spl_image)
Heiko Schochercf000272014-10-31 08:31:00 +0100251{
Alper Nebi Yasak173321c2022-06-18 15:13:06 +0300252 ulong u_boot_pos = spl_get_image_pos();
Simon Glass867a3982017-11-13 18:55:03 -0700253
Tom Rini7f184322022-10-28 20:27:07 -0400254#if CONFIG_SYS_MONITOR_LEN != 0
Simon Glass11a1a272016-09-24 18:19:52 -0600255 spl_image->size = CONFIG_SYS_MONITOR_LEN;
Tom Rini7f184322022-10-28 20:27:07 -0400256#else
257 /* Unknown U-Boot size, let's assume it will not be more than 200 KB */
258 spl_image->size = 200 * 1024;
259#endif
Miquel Raynal31824ff2018-02-28 20:51:43 +0100260
261 /*
262 * Binman error cases: address of the end of the previous region or the
263 * start of the image's entry area (usually 0) if there is no previous
264 * region.
265 */
266 if (u_boot_pos && u_boot_pos != BINMAN_SYM_MISSING) {
267 /* Binman does not support separated entry addresses */
Simon Glass867a3982017-11-13 18:55:03 -0700268 spl_image->entry_point = u_boot_pos;
269 spl_image->load_addr = u_boot_pos;
270 } else {
Jesse Taube93ee5c82023-08-24 21:59:48 -0400271 spl_image->entry_point = CONFIG_SYS_UBOOT_START;
Simon Glass72cc5382022-10-20 18:22:39 -0600272 spl_image->load_addr = CONFIG_TEXT_BASE;
Simon Glass867a3982017-11-13 18:55:03 -0700273 }
Simon Glass11a1a272016-09-24 18:19:52 -0600274 spl_image->os = IH_OS_U_BOOT;
275 spl_image->name = "U-Boot";
Heiko Schochercf000272014-10-31 08:31:00 +0100276}
Tom Rini7f184322022-10-28 20:27:07 -0400277#endif
Heiko Schochercf000272014-10-31 08:31:00 +0100278
Pali Rohárbde23cb2021-07-23 11:14:28 +0200279__weak int spl_parse_board_header(struct spl_image_info *spl_image,
Pali Rohárdda8f882022-01-14 14:31:38 +0100280 const struct spl_boot_device *bootdev,
Pali Rohárbde23cb2021-07-23 11:14:28 +0200281 const void *image_header, size_t size)
282{
283 return -EINVAL;
284}
285
Stefan Roese21a1df12020-04-21 09:28:41 +0200286__weak int spl_parse_legacy_header(struct spl_image_info *spl_image,
Simon Glassbb7d3bb2022-09-06 20:26:52 -0600287 const struct legacy_img_hdr *header)
Stefan Roese21a1df12020-04-21 09:28:41 +0200288{
289 /* LEGACY image not supported */
290 debug("Legacy boot image support not enabled, proceeding to other boot methods\n");
291 return -EINVAL;
292}
293
Simon Glass6b2e4db2016-09-24 18:19:53 -0600294int spl_parse_image_header(struct spl_image_info *spl_image,
Pali Rohárdda8f882022-01-14 14:31:38 +0100295 const struct spl_boot_device *bootdev,
Simon Glassbb7d3bb2022-09-06 20:26:52 -0600296 const struct legacy_img_hdr *header)
Aneesh V13a74c12011-07-21 09:10:27 -0400297{
Simon Glassc0bd55e2023-09-26 08:14:34 -0600298 int ret;
Marek Vasut06623372018-05-13 00:23:17 +0200299
Simon Glassc0bd55e2023-09-26 08:14:34 -0600300 if (CONFIG_IS_ENABLED(LOAD_FIT_FULL)) {
301 ret = spl_load_fit_image(spl_image, header);
302
303 if (!ret)
304 return ret;
305 }
Stefan Roese292db772012-08-27 12:50:57 +0200306 if (image_get_magic(header) == IH_MAGIC) {
Stefan Roese21a1df12020-04-21 09:28:41 +0200307 int ret;
Andrew F. Davis74630342017-02-16 11:18:39 -0600308
Stefan Roese21a1df12020-04-21 09:28:41 +0200309 ret = spl_parse_legacy_header(spl_image, header);
310 if (ret)
311 return ret;
Aneesh V13a74c12011-07-21 09:10:27 -0400312 } else {
Albert ARIBAUD \(3ADEV\)287b0942015-03-31 11:40:50 +0200313#ifdef CONFIG_SPL_PANIC_ON_RAW_IMAGE
314 /*
315 * CONFIG_SPL_PANIC_ON_RAW_IMAGE is defined when the
316 * code which loads images in SPL cannot guarantee that
317 * absolutely all read errors will be reported.
318 * An example is the LPC32XX MLC NAND driver, which
319 * will consider that a completely unreadable NAND block
320 * is bad, and thus should be skipped silently.
321 */
322 panic("** no mkimage signature but raw image not supported");
Paul Kocialkowskie48b7752016-08-24 20:04:42 +0200323#endif
324
Tom Rinic2e78882021-10-30 23:03:48 -0400325#if CONFIG_IS_ENABLED(OS_BOOT)
Nathan Barrett-Morrisonc20400a2022-02-02 15:05:18 -0500326#if defined(CMD_BOOTI)
327 ulong start, size;
328
329 if (!booti_setup((ulong)header, &start, &size, 0)) {
330 spl_image->name = "Linux";
331 spl_image->os = IH_OS_LINUX;
332 spl_image->load_addr = start;
333 spl_image->entry_point = start;
334 spl_image->size = size;
335 debug(SPL_TPL_PROMPT
336 "payload Image, load addr: 0x%lx size: %d\n",
337 spl_image->load_addr, spl_image->size);
338 return 0;
339 }
340#elif defined(CMD_BOOTZ)
Ladislav Michl9c743722016-07-12 20:28:14 +0200341 ulong start, end;
342
343 if (!bootz_setup((ulong)header, &start, &end)) {
Simon Glass6b2e4db2016-09-24 18:19:53 -0600344 spl_image->name = "Linux";
345 spl_image->os = IH_OS_LINUX;
346 spl_image->load_addr = CONFIG_SYS_LOAD_ADDR;
347 spl_image->entry_point = CONFIG_SYS_LOAD_ADDR;
348 spl_image->size = end - start;
Simon Glassdbd3f112018-11-15 18:43:56 -0700349 debug(SPL_TPL_PROMPT
350 "payload zImage, load addr: 0x%lx size: %d\n",
Simon Glass6b2e4db2016-09-24 18:19:53 -0600351 spl_image->load_addr, spl_image->size);
Ladislav Michl9c743722016-07-12 20:28:14 +0200352 return 0;
353 }
354#endif
Nathan Barrett-Morrisonc20400a2022-02-02 15:05:18 -0500355#endif
Paul Kocialkowskie48b7752016-08-24 20:04:42 +0200356
Pali Rohárdda8f882022-01-14 14:31:38 +0100357 if (!spl_parse_board_header(spl_image, bootdev, (const void *)header, sizeof(*header)))
Pali Rohárbde23cb2021-07-23 11:14:28 +0200358 return 0;
359
Andrew F. Davisb4be3c32017-02-16 11:18:38 -0600360#ifdef CONFIG_SPL_RAW_IMAGE_SUPPORT
Aneesh V13a74c12011-07-21 09:10:27 -0400361 /* Signature not found - assume u-boot.bin */
Tom Rini7b516862012-08-14 12:06:43 -0700362 debug("mkimage signature not found - ih_magic = %x\n",
Aneesh V13a74c12011-07-21 09:10:27 -0400363 header->ih_magic);
Simon Glass6b2e4db2016-09-24 18:19:53 -0600364 spl_set_header_raw_uboot(spl_image);
Andrew F. Davisb4be3c32017-02-16 11:18:38 -0600365#else
366 /* RAW image not supported, proceed to other boot methods. */
Anatolij Gustschindcb711f2017-08-01 16:17:12 +0200367 debug("Raw boot image support not enabled, proceeding to other boot methods\n");
Andrew F. Davisb4be3c32017-02-16 11:18:38 -0600368 return -EINVAL;
Albert ARIBAUD \(3ADEV\)287b0942015-03-31 11:40:50 +0200369#endif
Aneesh V13a74c12011-07-21 09:10:27 -0400370 }
Andrew F. Davisb4be3c32017-02-16 11:18:38 -0600371
Marek Vasut02266e22016-04-29 00:44:54 +0200372 return 0;
Aneesh V13a74c12011-07-21 09:10:27 -0400373}
374
Sean Anderson3a4a2b72023-11-08 11:48:47 -0500375#if SPL_LOAD_USERS > 1
376int spl_load(struct spl_image_info *spl_image,
377 const struct spl_boot_device *bootdev, struct spl_load_info *info,
378 size_t size, size_t offset)
379{
380 return _spl_load(spl_image, bootdev, info, size, offset);
381}
382#endif
383
Allen Martinc67e4852012-10-19 21:08:22 +0000384__weak void __noreturn jump_to_image_no_args(struct spl_image_info *spl_image)
Aneesh V13a74c12011-07-21 09:10:27 -0400385{
SRICHARAN R3f30b0a2013-04-24 00:41:24 +0000386 typedef void __noreturn (*image_entry_noargs_t)(void);
387
Aneesh V13a74c12011-07-21 09:10:27 -0400388 image_entry_noargs_t image_entry =
Andre Przywara6c526072017-01-02 11:48:31 +0000389 (image_entry_noargs_t)spl_image->entry_point;
Aneesh V13a74c12011-07-21 09:10:27 -0400390
Simon Goldschmidt1ddade62018-11-02 21:49:52 +0100391 debug("image entry point: 0x%lx\n", spl_image->entry_point);
SRICHARAN R3f30b0a2013-04-24 00:41:24 +0000392 image_entry();
Aneesh V13a74c12011-07-21 09:10:27 -0400393}
394
Simon Glasse14f1a22018-11-15 18:44:09 -0700395#if CONFIG_IS_ENABLED(HANDOFF)
396/**
397 * Set up the SPL hand-off information
398 *
399 * This is initially empty (zero) but can be written by
400 */
401static int setup_spl_handoff(void)
402{
403 struct spl_handoff *ho;
404
Simon Glass90c1a582022-01-12 19:26:17 -0700405 ho = bloblist_ensure(BLOBLISTT_U_BOOT_SPL_HANDOFF, sizeof(struct spl_handoff));
Simon Glasse14f1a22018-11-15 18:44:09 -0700406 if (!ho)
407 return -ENOENT;
408
409 return 0;
410}
411
Simon Glassc5d27202019-09-25 08:11:18 -0600412__weak int handoff_arch_save(struct spl_handoff *ho)
413{
414 return 0;
415}
416
Simon Glasse14f1a22018-11-15 18:44:09 -0700417static int write_spl_handoff(void)
418{
419 struct spl_handoff *ho;
Simon Glassc5d27202019-09-25 08:11:18 -0600420 int ret;
Simon Glasse14f1a22018-11-15 18:44:09 -0700421
Simon Glass90c1a582022-01-12 19:26:17 -0700422 ho = bloblist_find(BLOBLISTT_U_BOOT_SPL_HANDOFF, sizeof(struct spl_handoff));
Simon Glasse14f1a22018-11-15 18:44:09 -0700423 if (!ho)
424 return -ENOENT;
425 handoff_save_dram(ho);
Simon Glassc5d27202019-09-25 08:11:18 -0600426 ret = handoff_arch_save(ho);
427 if (ret)
428 return ret;
Simon Glasse14f1a22018-11-15 18:44:09 -0700429 debug(SPL_TPL_PROMPT "Wrote SPL handoff\n");
430
431 return 0;
432}
433#else
434static inline int setup_spl_handoff(void) { return 0; }
435static inline int write_spl_handoff(void) { return 0; }
436
437#endif /* HANDOFF */
438
Simon Glass97447ea2021-03-15 18:11:15 +1300439/**
440 * get_bootstage_id() - Get the bootstage ID to emit
441 *
442 * @start: true if this is for starting SPL, false for ending it
Heinrich Schuchardt47b4c022022-01-19 18:05:50 +0100443 * Return: bootstage ID to use
Simon Glass97447ea2021-03-15 18:11:15 +1300444 */
445static enum bootstage_id get_bootstage_id(bool start)
446{
447 enum u_boot_phase phase = spl_phase();
448
449 if (IS_ENABLED(CONFIG_TPL_BUILD) && phase == PHASE_TPL)
450 return start ? BOOTSTAGE_ID_START_TPL : BOOTSTAGE_ID_END_TPL;
Simon Glass7eec8842022-04-30 00:56:52 -0600451 else if (IS_ENABLED(CONFIG_VPL_BUILD) && phase == PHASE_VPL)
452 return start ? BOOTSTAGE_ID_START_VPL : BOOTSTAGE_ID_END_VPL;
Simon Glass97447ea2021-03-15 18:11:15 +1300453 else
454 return start ? BOOTSTAGE_ID_START_SPL : BOOTSTAGE_ID_END_SPL;
455}
456
Eddie Cai32258992017-03-15 08:43:28 -0600457static int spl_common_init(bool setup_malloc)
Aneesh Vb8e60b92011-07-21 09:10:21 -0400458{
Simon Glass9a49ec12015-02-27 22:06:42 -0700459 int ret;
460
Simon Glassadad2d02023-09-26 08:14:27 -0600461#if CONFIG_IS_ENABLED(SYS_MALLOC_F)
Eddie Cai32258992017-03-15 08:43:28 -0600462 if (setup_malloc) {
Tom Rinifb52b942022-12-04 10:04:49 -0500463#ifdef CFG_MALLOC_F_ADDR
464 gd->malloc_base = CFG_MALLOC_F_ADDR;
Marek Vasutd61ba112016-05-25 02:14:56 +0200465#endif
Andy Yan1fa20e4d2017-07-24 17:43:34 +0800466 gd->malloc_limit = CONFIG_VAL(SYS_MALLOC_F_LEN);
Eddie Cai32258992017-03-15 08:43:28 -0600467 gd->malloc_ptr = 0;
468 }
Tom Rini730bae72012-08-13 14:13:07 -0700469#endif
Simon Glass0e864562019-10-21 17:26:52 -0600470 ret = bootstage_init(u_boot_first_phase());
Simon Glass01154cb2017-05-22 05:05:35 -0600471 if (ret) {
472 debug("%s: Failed to set up bootstage: ret=%d\n", __func__,
473 ret);
474 return ret;
475 }
Simon Glass0e864562019-10-21 17:26:52 -0600476 if (!u_boot_first_phase()) {
Simon Glassb4c22cf2023-09-26 08:14:32 -0600477 ret = bootstage_unstash_default();
Simon Glass0e864562019-10-21 17:26:52 -0600478 if (ret)
Simon Glassb4c22cf2023-09-26 08:14:32 -0600479 log_debug("Failed to unstash bootstage: ret=%d\n", ret);
Simon Glass0e864562019-10-21 17:26:52 -0600480 }
Simon Glass97447ea2021-03-15 18:11:15 +1300481 bootstage_mark_name(get_bootstage_id(true),
482 spl_phase_name(spl_phase()));
Simon Glassb56cdc02018-11-15 18:43:49 -0700483#if CONFIG_IS_ENABLED(LOG)
484 ret = log_init();
485 if (ret) {
486 debug("%s: Failed to set up logging\n", __func__);
487 return ret;
488 }
489#endif
Simon Glass3580f6d2021-08-07 07:24:03 -0600490 if (CONFIG_IS_ENABLED(OF_REAL)) {
Simon Glass9a49ec12015-02-27 22:06:42 -0700491 ret = fdtdec_setup();
492 if (ret) {
493 debug("fdtdec_setup() returned error %d\n", ret);
Simon Glassfa2a4db2015-06-23 15:39:10 -0600494 return ret;
Simon Glass9a49ec12015-02-27 22:06:42 -0700495 }
496 }
Philipp Tomsich60e15782017-06-30 19:02:53 +0200497 if (CONFIG_IS_ENABLED(DM)) {
Simon Glassea6a6092020-05-10 11:39:59 -0600498 bootstage_start(BOOTSTAGE_ID_ACCUM_DM_SPL,
Simon Glassaa2abc42019-10-21 17:26:51 -0600499 spl_phase() == PHASE_TPL ? "dm tpl" : "dm_spl");
Tom Rini9732f792017-01-14 12:20:23 -0500500 /* With CONFIG_SPL_OF_PLATDATA, bring in all devices */
Simon Glasse9559fb2016-07-04 11:58:14 -0600501 ret = dm_init_and_scan(!CONFIG_IS_ENABLED(OF_PLATDATA));
Simon Glassea6a6092020-05-10 11:39:59 -0600502 bootstage_accum(BOOTSTAGE_ID_ACCUM_DM_SPL);
Simon Glass9a49ec12015-02-27 22:06:42 -0700503 if (ret) {
504 debug("dm_init_and_scan() returned error %d\n", ret);
Simon Glassfa2a4db2015-06-23 15:39:10 -0600505 return ret;
Simon Glass9a49ec12015-02-27 22:06:42 -0700506 }
507 }
Eddie Cai32258992017-03-15 08:43:28 -0600508
509 return 0;
510}
511
Alexandru Gagniuc7861f8b2021-04-08 11:56:11 -0500512void spl_set_bd(void)
York Suna34ca5f2017-09-28 08:42:10 -0700513{
Simon Glassef8d48a2018-11-15 18:43:58 -0700514 /*
515 * NOTE: On some platforms (e.g. x86) bdata may be in flash and not
516 * writeable.
517 */
Alexandru Gagniuc7861f8b2021-04-08 11:56:11 -0500518 if (!gd->bd)
519 gd->bd = &bdata;
York Suna34ca5f2017-09-28 08:42:10 -0700520}
521
Eddie Cai32258992017-03-15 08:43:28 -0600522int spl_early_init(void)
523{
524 int ret;
525
Simon Goldschmidt7dbffe42018-08-13 11:24:05 +0200526 debug("%s\n", __func__);
527
Eddie Cai32258992017-03-15 08:43:28 -0600528 ret = spl_common_init(true);
529 if (ret)
530 return ret;
531 gd->flags |= GD_FLG_SPL_EARLY_INIT;
532
533 return 0;
534}
535
536int spl_init(void)
537{
538 int ret;
Tom Rini89ea21e2017-03-20 14:19:27 -0400539 bool setup_malloc = !(IS_ENABLED(CONFIG_SPL_STACK_R) &&
540 IS_ENABLED(CONFIG_SPL_SYS_MALLOC_SIMPLE));
Eddie Cai32258992017-03-15 08:43:28 -0600541
Simon Goldschmidt7dbffe42018-08-13 11:24:05 +0200542 debug("%s\n", __func__);
543
Eddie Cai32258992017-03-15 08:43:28 -0600544 if (!(gd->flags & GD_FLG_SPL_EARLY_INIT)) {
Tom Rini89ea21e2017-03-20 14:19:27 -0400545 ret = spl_common_init(setup_malloc);
Eddie Cai32258992017-03-15 08:43:28 -0600546 if (ret)
547 return ret;
548 }
Simon Glassfa2a4db2015-06-23 15:39:10 -0600549 gd->flags |= GD_FLG_SPL_INIT;
550
551 return 0;
552}
553
Nikita Kiryanov3ed94782015-11-08 17:11:51 +0200554#ifndef BOOT_DEVICE_NONE
555#define BOOT_DEVICE_NONE 0xdeadbeef
556#endif
557
Nikita Kiryanov3ed94782015-11-08 17:11:51 +0200558__weak void board_boot_order(u32 *spl_boot_list)
559{
560 spl_boot_list[0] = spl_boot_device();
561}
562
Pali Rohárf47349a2022-01-14 14:31:40 +0100563__weak int spl_check_board_image(struct spl_image_info *spl_image,
564 const struct spl_boot_device *bootdev)
565{
566 return 0;
567}
568
Simon Glassf1e55752016-11-30 15:30:52 -0700569static int spl_load_image(struct spl_image_info *spl_image,
570 struct spl_image_loader *loader)
Simon Glassfa2a4db2015-06-23 15:39:10 -0600571{
Simon Goldschmidt17140472019-02-10 21:34:37 +0100572 int ret;
Simon Glassc0b6c9b2016-09-24 18:19:57 -0600573 struct spl_boot_device bootdev;
574
Simon Glassf1e55752016-11-30 15:30:52 -0700575 bootdev.boot_device = loader->boot_device;
Simon Glassc0b6c9b2016-09-24 18:19:57 -0600576 bootdev.boot_device_name = NULL;
577
Simon Goldschmidt17140472019-02-10 21:34:37 +0100578 ret = loader->load_image(spl_image, &bootdev);
579#ifdef CONFIG_SPL_LEGACY_IMAGE_CRC_CHECK
580 if (!ret && spl_image->dcrc_length) {
581 /* check data crc */
582 ulong dcrc = crc32_wd(0, (unsigned char *)spl_image->dcrc_data,
583 spl_image->dcrc_length, CHUNKSZ_CRC32);
584 if (dcrc != spl_image->dcrc) {
585 puts("SPL: Image data CRC check failed!\n");
586 ret = -EINVAL;
587 }
588 }
589#endif
Pali Rohárf47349a2022-01-14 14:31:40 +0100590 if (!ret)
591 ret = spl_check_board_image(spl_image, &bootdev);
592
Simon Goldschmidt17140472019-02-10 21:34:37 +0100593 return ret;
Simon Glassc9ef1852016-11-30 15:30:51 -0700594}
595
596/**
Miquel Raynal9f8d9942019-05-07 14:18:43 +0200597 * boot_from_devices() - Try loading a booting U-Boot from a list of devices
Simon Glassc9ef1852016-11-30 15:30:51 -0700598 *
599 * @spl_image: Place to put the image details if successful
600 * @spl_boot_list: List of boot devices to try
601 * @count: Number of elements in spl_boot_list
Heinrich Schuchardt47b4c022022-01-19 18:05:50 +0100602 * Return: 0 if OK, -ENODEV if there were no boot devices
Simon Glass58254e02021-07-05 16:32:57 -0600603 * if CONFIG_SHOW_ERRORS is enabled, returns -ENXIO if there were
604 * devices but none worked
Simon Glassc9ef1852016-11-30 15:30:51 -0700605 */
606static int boot_from_devices(struct spl_image_info *spl_image,
607 u32 spl_boot_list[], int count)
608{
Simon Glass6b8705d2022-10-20 18:23:07 -0600609 struct spl_image_loader *drv =
610 ll_entry_start(struct spl_image_loader, spl_image_loader);
611 const int n_ents =
612 ll_entry_count(struct spl_image_loader, spl_image_loader);
Simon Glass58254e02021-07-05 16:32:57 -0600613 int ret = -ENODEV;
Simon Glassc9ef1852016-11-30 15:30:51 -0700614 int i;
615
616 for (i = 0; i < count && spl_boot_list[i] != BOOT_DEVICE_NONE; i++) {
617 struct spl_image_loader *loader;
Simon Glass58254e02021-07-05 16:32:57 -0600618 int bootdev = spl_boot_list[i];
Simon Glassc9ef1852016-11-30 15:30:51 -0700619
Simon Glass58254e02021-07-05 16:32:57 -0600620 if (CONFIG_IS_ENABLED(SHOW_ERRORS))
621 ret = -ENXIO;
Simon Glass6b8705d2022-10-20 18:23:07 -0600622 for (loader = drv; loader != drv + n_ents; loader++) {
623 if (bootdev != loader->boot_device)
624 continue;
625 if (!CONFIG_IS_ENABLED(SILENT_CONSOLE)) {
626 if (loader)
627 printf("Trying to boot from %s\n",
628 spl_loader_name(loader));
629 else if (CONFIG_IS_ENABLED(SHOW_ERRORS)) {
630 printf(SPL_TPL_PROMPT
631 "Unsupported Boot Device %d\n",
632 bootdev);
633 } else {
634 puts(SPL_TPL_PROMPT
635 "Unsupported Boot Device!\n");
636 }
637 }
638 if (loader &&
639 !spl_load_image(spl_image, loader)) {
640 spl_image->boot_device = bootdev;
641 return 0;
642 }
Philipp Tomsich58beb6e2018-05-24 17:15:50 +0200643 }
Simon Glassc9ef1852016-11-30 15:30:51 -0700644 }
645
Simon Glass58254e02021-07-05 16:32:57 -0600646 return ret;
Nikita Kiryanov0a978812015-11-08 17:11:50 +0200647}
648
Philippe Reynesc4510f42019-09-19 16:18:39 +0200649#if defined(CONFIG_SPL_FRAMEWORK_BOARD_INIT_F)
650void board_init_f(ulong dummy)
651{
652 if (CONFIG_IS_ENABLED(OF_CONTROL)) {
653 int ret;
654
655 ret = spl_early_init();
656 if (ret) {
657 debug("spl_early_init() failed: %d\n", ret);
658 hang();
659 }
660 }
661
Samuel Hollandb03e6662020-05-07 18:08:10 -0500662 preloader_console_init();
Philippe Reynesc4510f42019-09-19 16:18:39 +0200663}
664#endif
665
Nikita Kiryanov0a978812015-11-08 17:11:50 +0200666void board_init_r(gd_t *dummy1, ulong dummy2)
667{
Simon Glassce8f5092016-09-24 18:20:17 -0600668 u32 spl_boot_list[] = {
669 BOOT_DEVICE_NONE,
670 BOOT_DEVICE_NONE,
671 BOOT_DEVICE_NONE,
672 BOOT_DEVICE_NONE,
673 BOOT_DEVICE_NONE,
674 };
Jonas Karlman7cd91f72023-09-27 21:44:13 +0000675 typedef void __noreturn (*jump_to_image_t)(struct spl_image_info *);
676 jump_to_image_t jump_to_image = &jump_to_image_no_args;
Simon Glassce8f5092016-09-24 18:20:17 -0600677 struct spl_image_info spl_image;
Simon Glass35c84e52023-09-26 08:14:22 -0600678 int ret, os;
Nikita Kiryanov0a978812015-11-08 17:11:50 +0200679
Simon Glassdbd3f112018-11-15 18:43:56 -0700680 debug(">>" SPL_TPL_PROMPT "board_init_r()\n");
York Suna34ca5f2017-09-28 08:42:10 -0700681
Alexandru Gagniuc7861f8b2021-04-08 11:56:11 -0500682 spl_set_bd();
683
Simon Glass0686b0c2023-09-26 08:14:18 -0600684 if (IS_ENABLED(CONFIG_SPL_SYS_MALLOC)) {
Sean Anderson5ff77722023-10-14 16:47:55 -0400685 mem_malloc_init((ulong)map_sysmem(SPL_SYS_MALLOC_START,
686 SPL_SYS_MALLOC_SIZE),
687 SPL_SYS_MALLOC_SIZE);
Simon Glass0686b0c2023-09-26 08:14:18 -0600688 gd->flags |= GD_FLG_FULL_MALLOC_INIT;
689 }
Nikita Kiryanov0a978812015-11-08 17:11:50 +0200690 if (!(gd->flags & GD_FLG_SPL_INIT)) {
691 if (spl_init())
692 hang();
693 }
Nikita Kiryanov0a978812015-11-08 17:11:50 +0200694 timer_init();
Simon Glassf1207752019-09-25 08:11:19 -0600695 if (CONFIG_IS_ENABLED(BLOBLIST)) {
696 ret = bloblist_init();
697 if (ret) {
698 debug("%s: Failed to set up bloblist: ret=%d\n",
699 __func__, ret);
700 puts(SPL_TPL_PROMPT "Cannot set up bloblist\n");
701 hang();
702 }
703 }
704 if (CONFIG_IS_ENABLED(HANDOFF)) {
705 int ret;
706
707 ret = setup_spl_handoff();
708 if (ret) {
709 puts(SPL_TPL_PROMPT "Cannot set up SPL handoff\n");
710 hang();
711 }
712 }
Nikita Kiryanov0a978812015-11-08 17:11:50 +0200713
Simon Glasse49743f2023-09-26 08:14:20 -0600714 if (CONFIG_IS_ENABLED(BOARD_INIT))
715 spl_board_init();
Nikita Kiryanov0a978812015-11-08 17:11:50 +0200716
Simon Glasse49743f2023-09-26 08:14:20 -0600717 if (IS_ENABLED(CONFIG_SPL_WATCHDOG) && CONFIG_IS_ENABLED(WDT))
718 initr_watchdog();
Stefan Roese502acb02019-04-11 15:58:44 +0200719
Heiko Stuebner593b82e2020-05-25 19:57:25 +0200720 if (IS_ENABLED(CONFIG_SPL_OS_BOOT) || CONFIG_IS_ENABLED(HANDOFF) ||
721 IS_ENABLED(CONFIG_SPL_ATF))
Simon Glasse14f1a22018-11-15 18:44:09 -0700722 dram_init_banksize();
723
Simon Glass31ef8342023-09-07 09:58:13 -0600724 if (CONFIG_IS_ENABLED(PCI) && !(gd->flags & GD_FLG_DM_DEAD)) {
Heinrich Schuchardt1d8f1372023-07-24 22:18:41 +0200725 ret = pci_init();
726 if (ret)
727 puts(SPL_TPL_PROMPT "Cannot initialize PCI\n");
728 /* Don't fail. We still can try other boot methods. */
729 }
730
Lukasz Majewskia4858602018-05-02 16:10:54 +0200731 bootcount_inc();
732
Simon Glass099dc1f2022-05-08 04:39:27 -0600733 /* Dump driver model states to aid analysis */
734 if (CONFIG_IS_ENABLED(DM_STATS)) {
735 struct dm_stats mem;
736
737 dm_get_mem(&mem);
738 dm_dump_mem(&mem);
739 }
740
Simon Glassce8f5092016-09-24 18:20:17 -0600741 memset(&spl_image, '\0', sizeof(spl_image));
Simon Glassad679722023-09-26 08:14:21 -0600742 if (IS_ENABLED(CONFIG_SPL_OS_BOOT))
743 spl_image.arg = (void *)SPL_PAYLOAD_ARGS_ADDR;
Philipp Tomsich58beb6e2018-05-24 17:15:50 +0200744 spl_image.boot_device = BOOT_DEVICE_NONE;
Nikita Kiryanov3ed94782015-11-08 17:11:51 +0200745 board_boot_order(spl_boot_list);
Nikita Kiryanov3ed94782015-11-08 17:11:51 +0200746
Simon Glass58254e02021-07-05 16:32:57 -0600747 ret = boot_from_devices(&spl_image, spl_boot_list,
748 ARRAY_SIZE(spl_boot_list));
749 if (ret) {
Sean Anderson4d9e0f62023-11-08 11:48:35 -0500750 if (CONFIG_IS_ENABLED(SHOW_ERRORS))
Simon Glass58254e02021-07-05 16:32:57 -0600751 printf(SPL_TPL_PROMPT "failed to boot from all boot devices (err=%d)\n",
752 ret);
753 else
754 puts(SPL_TPL_PROMPT "failed to boot from all boot devices\n");
Nikita Kiryanov0a978812015-11-08 17:11:50 +0200755 hang();
Nikita Kiryanov3ed94782015-11-08 17:11:51 +0200756 }
Nikita Kiryanov0a978812015-11-08 17:11:50 +0200757
Philipp Tomsich58beb6e2018-05-24 17:15:50 +0200758 spl_perform_fixups(&spl_image);
759
Simon Glass35c84e52023-09-26 08:14:22 -0600760 os = spl_image.os;
761 if (os == IH_OS_U_BOOT) {
Simon Glasse12d98a2021-02-06 09:57:27 -0700762 debug("Jumping to %s...\n", spl_phase_name(spl_next_phase()));
Simon Glass35c84e52023-09-26 08:14:22 -0600763 } else if (CONFIG_IS_ENABLED(ATF) && os == IH_OS_ARM_TRUSTED_FIRMWARE) {
Philipp Tomsich4ab63e02017-09-13 21:29:35 +0200764 debug("Jumping to U-Boot via ARM Trusted Firmware\n");
Simon Glass35c84e52023-09-26 08:14:22 -0600765 spl_fixup_fdt(spl_image_fdt_addr(&spl_image));
Jonas Karlman7cd91f72023-09-27 21:44:13 +0000766 jump_to_image = &spl_invoke_atf;
Simon Glass35c84e52023-09-26 08:14:22 -0600767 } else if (CONFIG_IS_ENABLED(OPTEE_IMAGE) && os == IH_OS_TEE) {
Kever Yanga28d42c2018-08-23 17:17:59 +0800768 debug("Jumping to U-Boot via OP-TEE\n");
Simon Glass35c84e52023-09-26 08:14:22 -0600769 spl_board_prepare_for_optee(spl_image_fdt_addr(&spl_image));
Jonas Karlman7cd91f72023-09-27 21:44:13 +0000770 jump_to_image = &jump_to_image_optee;
Simon Glass35c84e52023-09-26 08:14:22 -0600771 } else if (CONFIG_IS_ENABLED(OPENSBI) && os == IH_OS_OPENSBI) {
Lukas Auer515b9342019-08-21 21:14:44 +0200772 debug("Jumping to U-Boot via RISC-V OpenSBI\n");
Jonas Karlman7cd91f72023-09-27 21:44:13 +0000773 jump_to_image = &spl_invoke_opensbi;
Simon Glass35c84e52023-09-26 08:14:22 -0600774 } else if (CONFIG_IS_ENABLED(OS_BOOT) && os == IH_OS_LINUX) {
Simon Schwarz305bc4c2012-03-15 04:01:38 +0000775 debug("Jumping to Linux\n");
Simon Glassad679722023-09-26 08:14:21 -0600776 if (IS_ENABLED(CONFIG_SPL_OS_BOOT))
777 spl_fixup_fdt((void *)SPL_PAYLOAD_ARGS_ADDR);
Simon Schwarz305bc4c2012-03-15 04:01:38 +0000778 spl_board_prepare_for_linux();
Jonas Karlman7cd91f72023-09-27 21:44:13 +0000779 jump_to_image = &jump_to_image_linux;
Simon Glass35c84e52023-09-26 08:14:22 -0600780 } else {
Tom Rini79178462012-08-27 14:58:28 -0700781 debug("Unsupported OS image.. Jumping nevertheless..\n");
Aneesh V13a74c12011-07-21 09:10:27 -0400782 }
Simon Glasse8804d72023-09-26 08:14:31 -0600783 if (CONFIG_IS_ENABLED(SYS_MALLOC_F) &&
784 !IS_ENABLED(CONFIG_SPL_SYS_MALLOC_SIZE))
785 debug("SPL malloc() used 0x%lx bytes (%ld KB)\n",
786 gd_malloc_ptr(), gd_malloc_ptr() / 1024);
787
Simon Glass97447ea2021-03-15 18:11:15 +1300788 bootstage_mark_name(get_bootstage_id(false), "end phase");
Simon Glassb4c22cf2023-09-26 08:14:32 -0600789 ret = bootstage_stash_default();
Simon Glass01154cb2017-05-22 05:05:35 -0600790 if (ret)
791 debug("Failed to stash bootstage: err=%d\n", ret);
Kever Yangaca62db2017-09-13 18:24:24 +0800792
Nikhil M Jain1a606db2023-07-18 14:27:33 +0530793 if (IS_ENABLED(CONFIG_SPL_VIDEO_REMOVE)) {
794 struct udevice *dev;
795 int rc;
Nikhil M Jaineda07d62023-04-10 14:19:13 +0530796
Nikhil M Jain1a606db2023-07-18 14:27:33 +0530797 rc = uclass_find_device(UCLASS_VIDEO, 0, &dev);
798 if (!rc && dev) {
799 rc = device_remove(dev, DM_REMOVE_NORMAL);
800 if (rc)
801 printf("Cannot remove video device '%s' (err=%d)\n",
802 dev->name, rc);
803 }
Nikhil M Jaineda07d62023-04-10 14:19:13 +0530804 }
Simon Glassc4b14502023-09-26 08:14:36 -0600805 if (CONFIG_IS_ENABLED(HANDOFF)) {
806 ret = write_spl_handoff();
807 if (ret)
808 printf(SPL_TPL_PROMPT
809 "SPL hand-off write failed (err=%d)\n", ret);
810 }
811 if (CONFIG_IS_ENABLED(BLOBLIST)) {
812 ret = bloblist_finish();
813 if (ret)
814 printf("Warning: Failed to finish bloblist (ret=%d)\n",
815 ret);
816 }
Nikhil M Jaineda07d62023-04-10 14:19:13 +0530817
Michal Simek7a8465b2016-05-10 07:54:20 +0200818 spl_board_prepare_for_boot();
Jonas Karlman7cd91f72023-09-27 21:44:13 +0000819 jump_to_image(&spl_image);
Aneesh Vb8e60b92011-07-21 09:10:21 -0400820}
821
Tom Rini31dfba42012-08-22 15:31:05 -0700822/*
823 * This requires UART clocks to be enabled. In order for this to work the
824 * caller must ensure that the gd pointer is valid.
825 */
Aneesh Vb8e60b92011-07-21 09:10:21 -0400826void preloader_console_init(void)
827{
Simon Glassf4d60392021-08-08 12:20:12 -0600828#ifdef CONFIG_SPL_SERIAL
Aneesh Vb8e60b92011-07-21 09:10:21 -0400829 gd->baudrate = CONFIG_BAUDRATE;
830
Aneesh Vb8e60b92011-07-21 09:10:21 -0400831 serial_init(); /* serial communications setup */
832
Ilya Yanok74193c62011-11-01 13:16:03 +0000833 gd->have_console = 1;
834
Simon Glass6324cce2018-11-15 18:43:57 -0700835#if CONFIG_IS_ENABLED(BANNER_PRINT)
Simon Glassdbd3f112018-11-15 18:43:56 -0700836 puts("\nU-Boot " SPL_TPL_NAME " " PLAIN_VERSION " (" U_BOOT_DATE " - "
837 U_BOOT_TIME " " U_BOOT_TZ ")\n");
Anatolij Gustschin6fe74d22018-01-25 18:45:22 +0100838#endif
Tom Rinife3b0c72012-08-13 11:37:56 -0700839#ifdef CONFIG_SPL_DISPLAY_PRINT
840 spl_display_print();
841#endif
Alex Kiernanb09f8922018-04-19 04:32:51 +0000842#endif
Samuel Hollandb03e6662020-05-07 18:08:10 -0500843}
Simon Glassd8711af2015-03-03 08:03:00 -0700844
845/**
Simon Goldschmidt0b820852019-07-16 22:30:36 +0200846 * This function is called before the stack is changed from initial stack to
847 * relocated stack. It tries to dump the stack size used
848 */
849__weak void spl_relocate_stack_check(void)
850{
851#if CONFIG_IS_ENABLED(SYS_REPORT_STACK_F_USAGE)
852 ulong init_sp = gd->start_addr_sp;
853 ulong stack_bottom = init_sp - CONFIG_VAL(SIZE_LIMIT_PROVIDE_STACK);
854 u8 *ptr = (u8 *)stack_bottom;
855 ulong i;
856
857 for (i = 0; i < CONFIG_VAL(SIZE_LIMIT_PROVIDE_STACK); i++) {
858 if (*ptr != CONFIG_VAL(SYS_STACK_F_CHECK_BYTE))
859 break;
860 ptr++;
861 }
862 printf("SPL initial stack usage: %lu bytes\n",
863 CONFIG_VAL(SIZE_LIMIT_PROVIDE_STACK) - i);
864#endif
865}
866
867/**
Simon Glassd8711af2015-03-03 08:03:00 -0700868 * spl_relocate_stack_gd() - Relocate stack ready for board_init_r() execution
869 *
870 * Sometimes board_init_f() runs with a stack in SRAM but we want to use SDRAM
871 * for the main board_init_r() execution. This is typically because we need
872 * more stack space for things like the MMC sub-system.
873 *
874 * This function calculates the stack position, copies the global_data into
Albert ARIBAUD85260bb2015-11-25 17:56:33 +0100875 * place, sets the new gd (except for ARM, for which setting GD within a C
876 * function may not always work) and returns the new stack position. The
877 * caller is responsible for setting up the sp register and, in the case
878 * of ARM, setting up gd.
879 *
880 * All of this is done using the same layout and alignments as done in
881 * board_init_f_init_reserve() / board_init_f_alloc_reserve().
Simon Glassd8711af2015-03-03 08:03:00 -0700882 *
Heinrich Schuchardt47b4c022022-01-19 18:05:50 +0100883 * Return: new stack location, or 0 to use the same stack
Simon Glassd8711af2015-03-03 08:03:00 -0700884 */
885ulong spl_relocate_stack_gd(void)
886{
887#ifdef CONFIG_SPL_STACK_R
888 gd_t *new_gd;
Albert ARIBAUD85260bb2015-11-25 17:56:33 +0100889 ulong ptr = CONFIG_SPL_STACK_R_ADDR;
Simon Glassd8711af2015-03-03 08:03:00 -0700890
Simon Goldschmidt0b820852019-07-16 22:30:36 +0200891 if (CONFIG_IS_ENABLED(SYS_REPORT_STACK_F_USAGE))
892 spl_relocate_stack_check();
893
Simon Glassadad2d02023-09-26 08:14:27 -0600894#if defined(CONFIG_SPL_SYS_MALLOC_SIMPLE) && CONFIG_IS_ENABLED(SYS_MALLOC_F)
Hans de Goede8f280382015-09-13 15:04:17 +0200895 if (CONFIG_SPL_STACK_R_MALLOC_SIMPLE_LEN) {
Simon Goldschmidtb3672af2019-02-26 22:27:52 +0100896 debug("SPL malloc() before relocation used 0x%lx bytes (%ld KB)\n",
897 gd->malloc_ptr, gd->malloc_ptr / 1024);
Hans de Goede8f280382015-09-13 15:04:17 +0200898 ptr -= CONFIG_SPL_STACK_R_MALLOC_SIMPLE_LEN;
899 gd->malloc_base = ptr;
900 gd->malloc_limit = CONFIG_SPL_STACK_R_MALLOC_SIMPLE_LEN;
901 gd->malloc_ptr = 0;
902 }
903#endif
Albert ARIBAUD85260bb2015-11-25 17:56:33 +0100904 /* Get stack position: use 8-byte alignment for ABI compliance */
905 ptr = CONFIG_SPL_STACK_R_ADDR - roundup(sizeof(gd_t),16);
Nikhil M Jain799ceff2023-07-18 14:27:27 +0530906 gd->start_addr_sp = ptr;
Albert ARIBAUD85260bb2015-11-25 17:56:33 +0100907 new_gd = (gd_t *)ptr;
908 memcpy(new_gd, (void *)gd, sizeof(gd_t));
Simon Glass1b0deee2016-11-13 14:21:58 -0700909#if CONFIG_IS_ENABLED(DM)
910 dm_fixup_for_gd_move(new_gd);
911#endif
Lukas Auer2a2a9252019-08-21 21:14:46 +0200912#if !defined(CONFIG_ARM) && !defined(CONFIG_RISCV)
Albert ARIBAUD85260bb2015-11-25 17:56:33 +0100913 gd = new_gd;
914#endif
Simon Glassd8711af2015-03-03 08:03:00 -0700915 return ptr;
916#else
917 return 0;
918#endif
919}
Simon Glassc11c19f2019-11-14 12:57:17 -0700920
Philippe Reynes8d82a202020-12-11 19:56:47 +0100921#if defined(CONFIG_BOOTCOUNT_LIMIT) && \
922 ((!defined(CONFIG_TPL_BUILD) && !defined(CONFIG_SPL_BOOTCOUNT_LIMIT)) || \
923 (defined(CONFIG_TPL_BUILD) && !defined(CONFIG_TPL_BOOTCOUNT_LIMIT)))
Simon Glassc11c19f2019-11-14 12:57:17 -0700924void bootcount_store(ulong a)
925{
926}
927
928ulong bootcount_load(void)
929{
930 return 0;
931}
932#endif