blob: f6375b06a19913f970eceeac792faf8b170e617a [file] [log] [blame]
Tom Rini83d290c2018-05-06 17:58:06 -04001// SPDX-License-Identifier: GPL-2.0+
Aneesh Vbcae7212011-07-21 09:10:21 -04002/*
3 * (C) Copyright 2010
4 * Texas Instruments, <www.ti.com>
5 *
6 * Aneesh V <aneesh@ti.com>
Aneesh Vbcae7212011-07-21 09:10:21 -04007 */
Philipp Tomsichf1c6e192017-06-30 19:02:53 +02008
Aneesh Vbcae7212011-07-21 09:10:21 -04009#include <common.h>
Simon Glasse945a722018-11-15 18:43:51 -070010#include <bloblist.h>
Simon Glass8bee2d22017-11-13 18:55:03 -070011#include <binman_sym.h>
Simon Glass52f24232020-05-10 11:40:00 -060012#include <bootstage.h>
Simon Glass11516512014-11-10 17:16:46 -070013#include <dm.h>
Simon Glassb0edea32018-11-15 18:44:09 -070014#include <handoff.h>
Simon Glassdb41d652019-12-28 10:45:07 -070015#include <hang.h>
Simon Glass691d7192020-05-10 11:40:02 -060016#include <init.h>
Simon Glassc30b7ad2019-11-14 12:57:41 -070017#include <irq_func.h>
Simon Glassf7ae49f2020-05-10 11:40:05 -060018#include <log.h>
Simon Glass891d9e82021-03-07 17:35:14 -070019#include <mapmem.h>
Simon Glassb03e0512019-11-14 12:57:24 -070020#include <serial.h>
Tom Rini47f7bca2012-08-13 12:03:19 -070021#include <spl.h>
Simon Glass401d1c42020-10-30 21:38:53 -060022#include <asm/global_data.h>
Aneesh Vbcae7212011-07-21 09:10:21 -040023#include <asm/u-boot.h>
Simon Schwarzbb085b82011-09-14 15:29:26 -040024#include <nand.h>
Aneesh V8cf686e2011-07-21 09:10:27 -040025#include <fat.h>
Simon Glass3db71102019-11-14 12:57:16 -070026#include <u-boot/crc.h>
Simon Glassefb21722011-10-10 08:55:19 +000027#include <version.h>
Aneesh V8cf686e2011-07-21 09:10:27 -040028#include <image.h>
Aneesh V2d01dd92011-10-21 12:29:34 -040029#include <malloc.h>
Simon Glass31f9f0e2019-10-21 17:26:52 -060030#include <mapmem.h>
Simon Glass11516512014-11-10 17:16:46 -070031#include <dm/root.h>
Andreas Müller761ca312012-01-04 15:26:24 +000032#include <linux/compiler.h>
B, Ravi6e7585b2017-04-18 17:27:27 +053033#include <fdt_support.h>
Lukasz Majewskia8be2492018-05-02 16:10:54 +020034#include <bootcount.h>
Stefan Roese06985282019-04-11 15:58:44 +020035#include <wdt.h>
Aneesh Vbcae7212011-07-21 09:10:21 -040036
37DECLARE_GLOBAL_DATA_PTR;
38
Stefan Roese3c6f8a02012-08-28 10:50:59 +020039#ifndef CONFIG_SYS_UBOOT_START
40#define CONFIG_SYS_UBOOT_START CONFIG_SYS_TEXT_BASE
41#endif
Stefano Babicae83d882012-08-23 12:46:16 +020042#ifndef CONFIG_SYS_MONITOR_LEN
Andreas Bießmanne76caa62014-10-25 02:54:55 +020043/* Unknown U-Boot size, let's assume it will not be more than 200 KB */
Stefano Babicae83d882012-08-23 12:46:16 +020044#define CONFIG_SYS_MONITOR_LEN (200 * 1024)
45#endif
46
Tom Rini47f7bca2012-08-13 12:03:19 -070047u32 *boot_params_ptr = NULL;
Simon Schwarz9ea5c6e2011-09-14 15:33:34 -040048
Simon Glass8bee2d22017-11-13 18:55:03 -070049/* See spl.h for information about this */
Simon Glassdbf6be92018-08-01 15:22:42 -060050binman_sym_declare(ulong, u_boot_any, image_pos);
Simon Glasse82c6242019-12-08 17:40:12 -070051binman_sym_declare(ulong, u_boot_any, size);
52
53#ifdef CONFIG_TPL
54binman_sym_declare(ulong, spl, image_pos);
55binman_sym_declare(ulong, spl, size);
56#endif
Simon Glass8bee2d22017-11-13 18:55:03 -070057
Alexandru Gagniuc58b504e2021-04-08 11:56:11 -050058/* Define board data structure */
59static struct bd_info bdata __attribute__ ((section(".data")));
60
Tom Rinicb80ff22021-05-03 16:48:58 -040061#if CONFIG_IS_ENABLED(BOOTSTAGE)
Simon Schwarz379c19a2012-03-15 04:01:38 +000062/*
Heiko Schocher496c5482016-06-07 08:31:20 +020063 * Board-specific Platform code can reimplement show_boot_progress () if needed
64 */
65__weak void show_boot_progress(int val) {}
Tom Rinicb80ff22021-05-03 16:48:58 -040066#endif
Heiko Schocher496c5482016-06-07 08:31:20 +020067
Heiko Stuebnera343b4f2020-05-25 19:57:25 +020068#if defined(CONFIG_SPL_OS_BOOT) || CONFIG_IS_ENABLED(HANDOFF) || \
69 defined(CONFIG_SPL_ATF)
Simon Glassb0edea32018-11-15 18:44:09 -070070/* weak, default platform-specific function to initialize dram banks */
71__weak int dram_init_banksize(void)
72{
73 return 0;
74}
75#endif
76
Heiko Schocher496c5482016-06-07 08:31:20 +020077/*
Simon Schwarz379c19a2012-03-15 04:01:38 +000078 * Default function to determine if u-boot or the OS should
79 * be started. This implementation always returns 1.
80 *
81 * Please implement your own board specific funcion to do this.
82 *
83 * RETURN
84 * 0 to not start u-boot
85 * positive if u-boot should start
86 */
87#ifdef CONFIG_SPL_OS_BOOT
88__weak int spl_start_uboot(void)
89{
Simon Glassd6330062018-11-15 18:43:56 -070090 puts(SPL_TPL_PROMPT
91 "Please implement spl_start_uboot() for your board\n");
92 puts(SPL_TPL_PROMPT "Direct Linux boot not active!\n");
Simon Schwarz379c19a2012-03-15 04:01:38 +000093 return 1;
94}
Ladislav Michl431889d2016-07-12 20:28:14 +020095
96/*
97 * Weak default function for arch specific zImage check. Return zero
98 * and fill start and end address if image is recognized.
99 */
100int __weak bootz_setup(ulong image, ulong *start, ulong *end)
101{
102 return 1;
103}
Simon Schwarz379c19a2012-03-15 04:01:38 +0000104#endif
105
Philipp Tomsichde5dd4c2018-05-24 17:15:50 +0200106/* Weak default function for arch/board-specific fixups to the spl_image_info */
107void __weak spl_perform_fixups(struct spl_image_info *spl_image)
108{
109}
110
Heiko Stuebnera343b4f2020-05-25 19:57:25 +0200111void spl_fixup_fdt(void *fdt_blob)
B, Ravi6e7585b2017-04-18 17:27:27 +0530112{
Heiko Stuebnera343b4f2020-05-25 19:57:25 +0200113#if defined(CONFIG_SPL_OF_LIBFDT)
B, Ravi6e7585b2017-04-18 17:27:27 +0530114 int err;
115
Heiko Stuebnera343b4f2020-05-25 19:57:25 +0200116 if (!fdt_blob)
117 return;
118
B, Ravi6e7585b2017-04-18 17:27:27 +0530119 err = fdt_check_header(fdt_blob);
120 if (err < 0) {
121 printf("fdt_root: %s\n", fdt_strerror(err));
122 return;
123 }
124
125 /* fixup the memory dt node */
126 err = fdt_shrink_to_minimum(fdt_blob, 0);
127 if (err == 0) {
Simon Glassd6330062018-11-15 18:43:56 -0700128 printf(SPL_TPL_PROMPT "fdt_shrink_to_minimum err - %d\n", err);
B, Ravi6e7585b2017-04-18 17:27:27 +0530129 return;
130 }
131
132 err = arch_fixup_fdt(fdt_blob);
133 if (err) {
Simon Glassd6330062018-11-15 18:43:56 -0700134 printf(SPL_TPL_PROMPT "arch_fixup_fdt err - %d\n", err);
B, Ravi6e7585b2017-04-18 17:27:27 +0530135 return;
136 }
137#endif
138}
139
Simon Glasse82c6242019-12-08 17:40:12 -0700140ulong spl_get_image_pos(void)
141{
142 return spl_phase() == PHASE_TPL ?
143 binman_sym(ulong, spl, image_pos) :
144 binman_sym(ulong, u_boot_any, image_pos);
145}
146
147ulong spl_get_image_size(void)
148{
149 return spl_phase() == PHASE_TPL ?
150 binman_sym(ulong, spl, size) :
151 binman_sym(ulong, u_boot_any, size);
152}
153
Simon Glass86c372a2021-01-24 10:06:03 -0700154ulong spl_get_image_text_base(void)
155{
156 return spl_phase() == PHASE_TPL ? CONFIG_SPL_TEXT_BASE :
157 CONFIG_SYS_TEXT_BASE;
158}
159
Stefan Roeseea8256f2012-08-23 08:34:21 +0200160/*
161 * Weak default function for board specific cleanup/preparation before
162 * Linux boot. Some boards/platforms might not need it, so just provide
163 * an empty stub here.
164 */
165__weak void spl_board_prepare_for_linux(void)
166{
167 /* Nothing to do! */
168}
169
Alexandru Gagniuca25d6b62021-07-15 14:19:24 -0500170__weak void spl_board_prepare_for_optee(void *fdt)
171{
172}
173
Michal Simek3a3b9142016-05-10 07:54:20 +0200174__weak void spl_board_prepare_for_boot(void)
175{
176 /* Nothing to do! */
177}
178
Marek Vasut04ce5422018-08-14 11:27:02 +0200179__weak struct image_header *spl_get_load_buffer(ssize_t offset, size_t size)
180{
Simon Glass891d9e82021-03-07 17:35:14 -0700181 return map_sysmem(CONFIG_SYS_TEXT_BASE + offset, 0);
Marek Vasut04ce5422018-08-14 11:27:02 +0200182}
183
Simon Glassd95ceb92016-09-24 18:19:52 -0600184void spl_set_header_raw_uboot(struct spl_image_info *spl_image)
Heiko Schocher0c3117b2014-10-31 08:31:00 +0100185{
Simon Glassdbf6be92018-08-01 15:22:42 -0600186 ulong u_boot_pos = binman_sym(ulong, u_boot_any, image_pos);
Simon Glass8bee2d22017-11-13 18:55:03 -0700187
Simon Glassd95ceb92016-09-24 18:19:52 -0600188 spl_image->size = CONFIG_SYS_MONITOR_LEN;
Miquel Raynal55fe0e22018-02-28 20:51:43 +0100189
190 /*
191 * Binman error cases: address of the end of the previous region or the
192 * start of the image's entry area (usually 0) if there is no previous
193 * region.
194 */
195 if (u_boot_pos && u_boot_pos != BINMAN_SYM_MISSING) {
196 /* Binman does not support separated entry addresses */
Simon Glass8bee2d22017-11-13 18:55:03 -0700197 spl_image->entry_point = u_boot_pos;
198 spl_image->load_addr = u_boot_pos;
199 } else {
200 spl_image->entry_point = CONFIG_SYS_UBOOT_START;
201 spl_image->load_addr = CONFIG_SYS_TEXT_BASE;
202 }
Simon Glassd95ceb92016-09-24 18:19:52 -0600203 spl_image->os = IH_OS_U_BOOT;
204 spl_image->name = "U-Boot";
Heiko Schocher0c3117b2014-10-31 08:31:00 +0100205}
206
John Keeping674afa62021-05-19 15:05:53 +0100207#if CONFIG_IS_ENABLED(LOAD_FIT_FULL)
Marek Vasut8a9dc162018-05-13 00:23:17 +0200208/* Parse and load full fitImage in SPL */
209static int spl_load_fit_image(struct spl_image_info *spl_image,
210 const struct image_header *header)
211{
212 bootm_headers_t images;
213 const char *fit_uname_config = NULL;
Alexandru Gagniuc60138aa2021-04-01 13:25:28 -0500214 uintptr_t fdt_hack;
Marek Vasut8a9dc162018-05-13 00:23:17 +0200215 const char *uname;
216 ulong fw_data = 0, dt_data = 0, img_data = 0;
217 ulong fw_len = 0, dt_len = 0, img_len = 0;
218 int idx, conf_noffset;
219 int ret;
220
221#ifdef CONFIG_SPL_FIT_SIGNATURE
222 images.verify = 1;
223#endif
224 ret = fit_image_load(&images, (ulong)header,
225 NULL, &fit_uname_config,
226 IH_ARCH_DEFAULT, IH_TYPE_STANDALONE, -1,
Alexandru Gagniuc51d3a8b2021-04-01 13:25:29 -0500227 FIT_LOAD_OPTIONAL, &fw_data, &fw_len);
228 if (ret >= 0) {
229 printf("DEPRECATED: 'standalone = ' property.");
230 printf("Please use either 'firmware =' or 'kernel ='\n");
231 } else {
232 ret = fit_image_load(&images, (ulong)header, NULL,
233 &fit_uname_config, IH_ARCH_DEFAULT,
234 IH_TYPE_FIRMWARE, -1, FIT_LOAD_OPTIONAL,
235 &fw_data, &fw_len);
236 }
237
238 if (ret < 0) {
239 ret = fit_image_load(&images, (ulong)header, NULL,
240 &fit_uname_config, IH_ARCH_DEFAULT,
241 IH_TYPE_KERNEL, -1, FIT_LOAD_OPTIONAL,
242 &fw_data, &fw_len);
243 }
244
Marek Vasut8a9dc162018-05-13 00:23:17 +0200245 if (ret < 0)
246 return ret;
247
248 spl_image->size = fw_len;
249 spl_image->entry_point = fw_data;
250 spl_image->load_addr = fw_data;
Alexandru Gagniuc2eaae172021-04-01 13:25:27 -0500251 if (fit_image_get_os(header, ret, &spl_image->os))
252 spl_image->os = IH_OS_INVALID;
253 spl_image->name = genimg_get_os_name(spl_image->os);
Marek Vasut8a9dc162018-05-13 00:23:17 +0200254
Simon Glassd6330062018-11-15 18:43:56 -0700255 debug(SPL_TPL_PROMPT "payload image: %32s load addr: 0x%lx size: %d\n",
Simon Goldschmidt30c07402018-11-02 21:49:52 +0100256 spl_image->name, spl_image->load_addr, spl_image->size);
Marek Vasut8a9dc162018-05-13 00:23:17 +0200257
258#ifdef CONFIG_SPL_FIT_SIGNATURE
259 images.verify = 1;
260#endif
Alexandru Gagniuc18fd6632021-04-01 13:25:26 -0500261 ret = fit_image_load(&images, (ulong)header, NULL, &fit_uname_config,
Marek Vasut8a9dc162018-05-13 00:23:17 +0200262 IH_ARCH_DEFAULT, IH_TYPE_FLATDT, -1,
263 FIT_LOAD_OPTIONAL, &dt_data, &dt_len);
Alexandru Gagniuc60138aa2021-04-01 13:25:28 -0500264 if (ret >= 0) {
Marek Vasuta9a82712019-05-07 21:17:02 +0200265 spl_image->fdt_addr = (void *)dt_data;
Marek Vasut8a9dc162018-05-13 00:23:17 +0200266
Alexandru Gagniuc60138aa2021-04-01 13:25:28 -0500267 if (spl_image->os == IH_OS_U_BOOT) {
268 /* HACK: U-boot expects FDT at a specific address */
269 fdt_hack = spl_image->load_addr + spl_image->size;
270 fdt_hack = (fdt_hack + 3) & ~3;
271 debug("Relocating FDT to %p\n", spl_image->fdt_addr);
272 memcpy((void *)fdt_hack, spl_image->fdt_addr, dt_len);
273 }
274 }
275
Marek Vasut8a9dc162018-05-13 00:23:17 +0200276 conf_noffset = fit_conf_get_node((const void *)header,
277 fit_uname_config);
278 if (conf_noffset <= 0)
279 return 0;
280
281 for (idx = 0;
282 uname = fdt_stringlist_get((const void *)header, conf_noffset,
283 FIT_LOADABLE_PROP, idx,
284 NULL), uname;
285 idx++)
286 {
287#ifdef CONFIG_SPL_FIT_SIGNATURE
288 images.verify = 1;
289#endif
290 ret = fit_image_load(&images, (ulong)header,
291 &uname, &fit_uname_config,
292 IH_ARCH_DEFAULT, IH_TYPE_LOADABLE, -1,
293 FIT_LOAD_OPTIONAL_NON_ZERO,
294 &img_data, &img_len);
295 if (ret < 0)
296 return ret;
297 }
298
299 return 0;
300}
301#endif
302
Stefan Roesec1108172020-04-21 09:28:41 +0200303__weak int spl_parse_legacy_header(struct spl_image_info *spl_image,
304 const struct image_header *header)
305{
306 /* LEGACY image not supported */
307 debug("Legacy boot image support not enabled, proceeding to other boot methods\n");
308 return -EINVAL;
309}
310
Simon Glass71316c12016-09-24 18:19:53 -0600311int spl_parse_image_header(struct spl_image_info *spl_image,
312 const struct image_header *header)
Aneesh V8cf686e2011-07-21 09:10:27 -0400313{
John Keeping674afa62021-05-19 15:05:53 +0100314#if CONFIG_IS_ENABLED(LOAD_FIT_FULL)
Marek Vasut8a9dc162018-05-13 00:23:17 +0200315 int ret = spl_load_fit_image(spl_image, header);
316
317 if (!ret)
318 return ret;
319#endif
Stefan Roese77552b02012-08-27 12:50:57 +0200320 if (image_get_magic(header) == IH_MAGIC) {
Stefan Roesec1108172020-04-21 09:28:41 +0200321 int ret;
Andrew F. Davis722a6b12017-02-16 11:18:39 -0600322
Stefan Roesec1108172020-04-21 09:28:41 +0200323 ret = spl_parse_legacy_header(spl_image, header);
324 if (ret)
325 return ret;
Aneesh V8cf686e2011-07-21 09:10:27 -0400326 } else {
Albert ARIBAUD \(3ADEV\)8c80eb32015-03-31 11:40:50 +0200327#ifdef CONFIG_SPL_PANIC_ON_RAW_IMAGE
328 /*
329 * CONFIG_SPL_PANIC_ON_RAW_IMAGE is defined when the
330 * code which loads images in SPL cannot guarantee that
331 * absolutely all read errors will be reported.
332 * An example is the LPC32XX MLC NAND driver, which
333 * will consider that a completely unreadable NAND block
334 * is bad, and thus should be skipped silently.
335 */
336 panic("** no mkimage signature but raw image not supported");
Paul Kocialkowski85a37722016-08-24 20:04:42 +0200337#endif
338
Ladislav Michl431889d2016-07-12 20:28:14 +0200339#ifdef CONFIG_SPL_OS_BOOT
340 ulong start, end;
341
342 if (!bootz_setup((ulong)header, &start, &end)) {
Simon Glass71316c12016-09-24 18:19:53 -0600343 spl_image->name = "Linux";
344 spl_image->os = IH_OS_LINUX;
345 spl_image->load_addr = CONFIG_SYS_LOAD_ADDR;
346 spl_image->entry_point = CONFIG_SYS_LOAD_ADDR;
347 spl_image->size = end - start;
Simon Glassd6330062018-11-15 18:43:56 -0700348 debug(SPL_TPL_PROMPT
349 "payload zImage, load addr: 0x%lx size: %d\n",
Simon Glass71316c12016-09-24 18:19:53 -0600350 spl_image->load_addr, spl_image->size);
Ladislav Michl431889d2016-07-12 20:28:14 +0200351 return 0;
352 }
353#endif
Paul Kocialkowski85a37722016-08-24 20:04:42 +0200354
Andrew F. Davis24eb39b2017-02-16 11:18:38 -0600355#ifdef CONFIG_SPL_RAW_IMAGE_SUPPORT
Aneesh V8cf686e2011-07-21 09:10:27 -0400356 /* Signature not found - assume u-boot.bin */
Tom Rini026b2fe2012-08-14 12:06:43 -0700357 debug("mkimage signature not found - ih_magic = %x\n",
Aneesh V8cf686e2011-07-21 09:10:27 -0400358 header->ih_magic);
Simon Glass71316c12016-09-24 18:19:53 -0600359 spl_set_header_raw_uboot(spl_image);
Andrew F. Davis24eb39b2017-02-16 11:18:38 -0600360#else
361 /* RAW image not supported, proceed to other boot methods. */
Anatolij Gustschin2d2531b2017-08-01 16:17:12 +0200362 debug("Raw boot image support not enabled, proceeding to other boot methods\n");
Andrew F. Davis24eb39b2017-02-16 11:18:38 -0600363 return -EINVAL;
Albert ARIBAUD \(3ADEV\)8c80eb32015-03-31 11:40:50 +0200364#endif
Aneesh V8cf686e2011-07-21 09:10:27 -0400365 }
Andrew F. Davis24eb39b2017-02-16 11:18:38 -0600366
Marek Vasut7e0f2262016-04-29 00:44:54 +0200367 return 0;
Aneesh V8cf686e2011-07-21 09:10:27 -0400368}
369
Allen Martina759f1e2012-10-19 21:08:22 +0000370__weak void __noreturn jump_to_image_no_args(struct spl_image_info *spl_image)
Aneesh V8cf686e2011-07-21 09:10:27 -0400371{
SRICHARAN R4a0eb752013-04-24 00:41:24 +0000372 typedef void __noreturn (*image_entry_noargs_t)(void);
373
Aneesh V8cf686e2011-07-21 09:10:27 -0400374 image_entry_noargs_t image_entry =
Andre Przywara11e14792017-01-02 11:48:31 +0000375 (image_entry_noargs_t)spl_image->entry_point;
Aneesh V8cf686e2011-07-21 09:10:27 -0400376
Simon Goldschmidt30c07402018-11-02 21:49:52 +0100377 debug("image entry point: 0x%lx\n", spl_image->entry_point);
SRICHARAN R4a0eb752013-04-24 00:41:24 +0000378 image_entry();
Aneesh V8cf686e2011-07-21 09:10:27 -0400379}
380
Simon Glassb0edea32018-11-15 18:44:09 -0700381#if CONFIG_IS_ENABLED(HANDOFF)
382/**
383 * Set up the SPL hand-off information
384 *
385 * This is initially empty (zero) but can be written by
386 */
387static int setup_spl_handoff(void)
388{
389 struct spl_handoff *ho;
390
391 ho = bloblist_ensure(BLOBLISTT_SPL_HANDOFF, sizeof(struct spl_handoff));
392 if (!ho)
393 return -ENOENT;
394
395 return 0;
396}
397
Simon Glass366291a2019-09-25 08:11:18 -0600398__weak int handoff_arch_save(struct spl_handoff *ho)
399{
400 return 0;
401}
402
Simon Glassb0edea32018-11-15 18:44:09 -0700403static int write_spl_handoff(void)
404{
405 struct spl_handoff *ho;
Simon Glass366291a2019-09-25 08:11:18 -0600406 int ret;
Simon Glassb0edea32018-11-15 18:44:09 -0700407
408 ho = bloblist_find(BLOBLISTT_SPL_HANDOFF, sizeof(struct spl_handoff));
409 if (!ho)
410 return -ENOENT;
411 handoff_save_dram(ho);
Simon Glass366291a2019-09-25 08:11:18 -0600412 ret = handoff_arch_save(ho);
413 if (ret)
414 return ret;
Simon Glassb0edea32018-11-15 18:44:09 -0700415 debug(SPL_TPL_PROMPT "Wrote SPL handoff\n");
416
417 return 0;
418}
419#else
420static inline int setup_spl_handoff(void) { return 0; }
421static inline int write_spl_handoff(void) { return 0; }
422
423#endif /* HANDOFF */
424
Simon Glass05e3a0d2021-03-15 18:11:15 +1300425/**
426 * get_bootstage_id() - Get the bootstage ID to emit
427 *
428 * @start: true if this is for starting SPL, false for ending it
429 * @return bootstage ID to use
430 */
431static enum bootstage_id get_bootstage_id(bool start)
432{
433 enum u_boot_phase phase = spl_phase();
434
435 if (IS_ENABLED(CONFIG_TPL_BUILD) && phase == PHASE_TPL)
436 return start ? BOOTSTAGE_ID_START_TPL : BOOTSTAGE_ID_END_TPL;
437 else
438 return start ? BOOTSTAGE_ID_START_SPL : BOOTSTAGE_ID_END_SPL;
439}
440
Eddie Cai340f4182017-03-15 08:43:28 -0600441static int spl_common_init(bool setup_malloc)
Aneesh Vbcae7212011-07-21 09:10:21 -0400442{
Simon Glassf3d46bd2015-02-27 22:06:42 -0700443 int ret;
444
Andy Yanf1896c42017-07-24 17:43:34 +0800445#if CONFIG_VAL(SYS_MALLOC_F_LEN)
Eddie Cai340f4182017-03-15 08:43:28 -0600446 if (setup_malloc) {
Marek Vasut94b9e222016-05-25 02:14:56 +0200447#ifdef CONFIG_MALLOC_F_ADDR
Eddie Cai340f4182017-03-15 08:43:28 -0600448 gd->malloc_base = CONFIG_MALLOC_F_ADDR;
Marek Vasut94b9e222016-05-25 02:14:56 +0200449#endif
Andy Yanf1896c42017-07-24 17:43:34 +0800450 gd->malloc_limit = CONFIG_VAL(SYS_MALLOC_F_LEN);
Eddie Cai340f4182017-03-15 08:43:28 -0600451 gd->malloc_ptr = 0;
452 }
Tom Rini24dafad2012-08-13 14:13:07 -0700453#endif
Simon Glass31f9f0e2019-10-21 17:26:52 -0600454 ret = bootstage_init(u_boot_first_phase());
Simon Glass824bb1b2017-05-22 05:05:35 -0600455 if (ret) {
456 debug("%s: Failed to set up bootstage: ret=%d\n", __func__,
457 ret);
458 return ret;
459 }
Simon Glass31f9f0e2019-10-21 17:26:52 -0600460#ifdef CONFIG_BOOTSTAGE_STASH
461 if (!u_boot_first_phase()) {
462 const void *stash = map_sysmem(CONFIG_BOOTSTAGE_STASH_ADDR,
463 CONFIG_BOOTSTAGE_STASH_SIZE);
464
465 ret = bootstage_unstash(stash, CONFIG_BOOTSTAGE_STASH_SIZE);
466 if (ret)
467 debug("%s: Failed to unstash bootstage: ret=%d\n",
468 __func__, ret);
469 }
470#endif /* CONFIG_BOOTSTAGE_STASH */
Simon Glass05e3a0d2021-03-15 18:11:15 +1300471 bootstage_mark_name(get_bootstage_id(true),
472 spl_phase_name(spl_phase()));
Simon Glass4d8d3052018-11-15 18:43:49 -0700473#if CONFIG_IS_ENABLED(LOG)
474 ret = log_init();
475 if (ret) {
476 debug("%s: Failed to set up logging\n", __func__);
477 return ret;
478 }
479#endif
Simon Glassd223e0a2016-07-04 11:57:56 -0600480 if (CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)) {
Simon Glassf3d46bd2015-02-27 22:06:42 -0700481 ret = fdtdec_setup();
482 if (ret) {
483 debug("fdtdec_setup() returned error %d\n", ret);
Simon Glass070d00b2015-06-23 15:39:10 -0600484 return ret;
Simon Glassf3d46bd2015-02-27 22:06:42 -0700485 }
486 }
Philipp Tomsichf1c6e192017-06-30 19:02:53 +0200487 if (CONFIG_IS_ENABLED(DM)) {
Simon Glassb67eefd2020-05-10 11:39:59 -0600488 bootstage_start(BOOTSTAGE_ID_ACCUM_DM_SPL,
Simon Glass5256bee2019-10-21 17:26:51 -0600489 spl_phase() == PHASE_TPL ? "dm tpl" : "dm_spl");
Tom Rini7f73ca42017-01-14 12:20:23 -0500490 /* With CONFIG_SPL_OF_PLATDATA, bring in all devices */
Simon Glass7d23b9c2016-07-04 11:58:14 -0600491 ret = dm_init_and_scan(!CONFIG_IS_ENABLED(OF_PLATDATA));
Simon Glassb67eefd2020-05-10 11:39:59 -0600492 bootstage_accum(BOOTSTAGE_ID_ACCUM_DM_SPL);
Simon Glassf3d46bd2015-02-27 22:06:42 -0700493 if (ret) {
494 debug("dm_init_and_scan() returned error %d\n", ret);
Simon Glass070d00b2015-06-23 15:39:10 -0600495 return ret;
Simon Glassf3d46bd2015-02-27 22:06:42 -0700496 }
497 }
Eddie Cai340f4182017-03-15 08:43:28 -0600498
499 return 0;
500}
501
Alexandru Gagniuc58b504e2021-04-08 11:56:11 -0500502void spl_set_bd(void)
York Sund1fc0a32017-09-28 08:42:10 -0700503{
Simon Glassc21f4072018-11-15 18:43:58 -0700504 /*
505 * NOTE: On some platforms (e.g. x86) bdata may be in flash and not
506 * writeable.
507 */
Alexandru Gagniuc58b504e2021-04-08 11:56:11 -0500508 if (!gd->bd)
509 gd->bd = &bdata;
York Sund1fc0a32017-09-28 08:42:10 -0700510}
511
Eddie Cai340f4182017-03-15 08:43:28 -0600512int spl_early_init(void)
513{
514 int ret;
515
Simon Goldschmidt94cb9862018-08-13 11:24:05 +0200516 debug("%s\n", __func__);
517
Eddie Cai340f4182017-03-15 08:43:28 -0600518 ret = spl_common_init(true);
519 if (ret)
520 return ret;
521 gd->flags |= GD_FLG_SPL_EARLY_INIT;
522
523 return 0;
524}
525
526int spl_init(void)
527{
528 int ret;
Tom Rinicf334ed2017-03-20 14:19:27 -0400529 bool setup_malloc = !(IS_ENABLED(CONFIG_SPL_STACK_R) &&
530 IS_ENABLED(CONFIG_SPL_SYS_MALLOC_SIMPLE));
Eddie Cai340f4182017-03-15 08:43:28 -0600531
Simon Goldschmidt94cb9862018-08-13 11:24:05 +0200532 debug("%s\n", __func__);
533
Eddie Cai340f4182017-03-15 08:43:28 -0600534 if (!(gd->flags & GD_FLG_SPL_EARLY_INIT)) {
Tom Rinicf334ed2017-03-20 14:19:27 -0400535 ret = spl_common_init(setup_malloc);
Eddie Cai340f4182017-03-15 08:43:28 -0600536 if (ret)
537 return ret;
538 }
Simon Glass070d00b2015-06-23 15:39:10 -0600539 gd->flags |= GD_FLG_SPL_INIT;
Aneesh V2d01dd92011-10-21 12:29:34 -0400540
Simon Glass070d00b2015-06-23 15:39:10 -0600541 return 0;
542}
543
Nikita Kiryanovf101e4b2015-11-08 17:11:51 +0200544#ifndef BOOT_DEVICE_NONE
545#define BOOT_DEVICE_NONE 0xdeadbeef
546#endif
547
Nikita Kiryanovf101e4b2015-11-08 17:11:51 +0200548__weak void board_boot_order(u32 *spl_boot_list)
549{
550 spl_boot_list[0] = spl_boot_device();
551}
552
Simon Glassa0a80292016-09-24 18:19:58 -0600553static struct spl_image_loader *spl_ll_find_loader(uint boot_device)
554{
555 struct spl_image_loader *drv =
556 ll_entry_start(struct spl_image_loader, spl_image_loader);
557 const int n_ents =
558 ll_entry_count(struct spl_image_loader, spl_image_loader);
559 struct spl_image_loader *entry;
560
561 for (entry = drv; entry != drv + n_ents; entry++) {
562 if (boot_device == entry->boot_device)
563 return entry;
564 }
565
566 /* Not found */
567 return NULL;
568}
569
Simon Glass29d357d2016-11-30 15:30:52 -0700570static int spl_load_image(struct spl_image_info *spl_image,
571 struct spl_image_loader *loader)
Nikita Kiryanov5211b872015-11-08 17:11:50 +0200572{
Simon Goldschmidtdae5c2d2019-02-10 21:34:37 +0100573 int ret;
Simon Glassecdfd692016-09-24 18:19:57 -0600574 struct spl_boot_device bootdev;
575
Simon Glass29d357d2016-11-30 15:30:52 -0700576 bootdev.boot_device = loader->boot_device;
Simon Glassecdfd692016-09-24 18:19:57 -0600577 bootdev.boot_device_name = NULL;
578
Simon Goldschmidtdae5c2d2019-02-10 21:34:37 +0100579 ret = loader->load_image(spl_image, &bootdev);
580#ifdef CONFIG_SPL_LEGACY_IMAGE_CRC_CHECK
581 if (!ret && spl_image->dcrc_length) {
582 /* check data crc */
583 ulong dcrc = crc32_wd(0, (unsigned char *)spl_image->dcrc_data,
584 spl_image->dcrc_length, CHUNKSZ_CRC32);
585 if (dcrc != spl_image->dcrc) {
586 puts("SPL: Image data CRC check failed!\n");
587 ret = -EINVAL;
588 }
589 }
590#endif
591 return ret;
Simon Glass540bfe72016-11-30 15:30:51 -0700592}
593
594/**
Miquel Raynalfd4ee982019-05-07 14:18:43 +0200595 * boot_from_devices() - Try loading a booting U-Boot from a list of devices
Simon Glass540bfe72016-11-30 15:30:51 -0700596 *
597 * @spl_image: Place to put the image details if successful
598 * @spl_boot_list: List of boot devices to try
599 * @count: Number of elements in spl_boot_list
Simon Glass7d84fbb2021-07-05 16:32:57 -0600600 * @return 0 if OK, -ENODEV if there were no boot devices
601 * if CONFIG_SHOW_ERRORS is enabled, returns -ENXIO if there were
602 * devices but none worked
Simon Glass540bfe72016-11-30 15:30:51 -0700603 */
604static int boot_from_devices(struct spl_image_info *spl_image,
605 u32 spl_boot_list[], int count)
606{
Simon Glass7d84fbb2021-07-05 16:32:57 -0600607 int ret = -ENODEV;
Simon Glass540bfe72016-11-30 15:30:51 -0700608 int i;
609
610 for (i = 0; i < count && spl_boot_list[i] != BOOT_DEVICE_NONE; i++) {
611 struct spl_image_loader *loader;
Simon Glass7d84fbb2021-07-05 16:32:57 -0600612 int bootdev = spl_boot_list[i];
Simon Glass540bfe72016-11-30 15:30:51 -0700613
Simon Glass7d84fbb2021-07-05 16:32:57 -0600614 if (CONFIG_IS_ENABLED(SHOW_ERRORS))
615 ret = -ENXIO;
616 loader = spl_ll_find_loader(bootdev);
617 if (CONFIG_IS_ENABLED(SERIAL_SUPPORT) &&
618 CONFIG_IS_ENABLED(LIBCOMMON_SUPPORT) &&
619 !IS_ENABLED(CONFIG_SILENT_CONSOLE)) {
620 if (loader)
621 printf("Trying to boot from %s\n",
622 spl_loader_name(loader));
623 else if (CONFIG_IS_ENABLED(SHOW_ERRORS))
624 printf(SPL_TPL_PROMPT
625 "Unsupported Boot Device %d\n", bootdev);
626 else
627 puts(SPL_TPL_PROMPT "Unsupported Boot Device!\n");
628 }
Philipp Tomsichde5dd4c2018-05-24 17:15:50 +0200629 if (loader && !spl_load_image(spl_image, loader)) {
Simon Glass7d84fbb2021-07-05 16:32:57 -0600630 spl_image->boot_device = bootdev;
Simon Glass540bfe72016-11-30 15:30:51 -0700631 return 0;
Philipp Tomsichde5dd4c2018-05-24 17:15:50 +0200632 }
Simon Glass540bfe72016-11-30 15:30:51 -0700633 }
634
Simon Glass7d84fbb2021-07-05 16:32:57 -0600635 return ret;
Nikita Kiryanov5211b872015-11-08 17:11:50 +0200636}
637
Philippe Reynesa9a3aad2019-09-19 16:18:39 +0200638#if defined(CONFIG_SPL_FRAMEWORK_BOARD_INIT_F)
639void board_init_f(ulong dummy)
640{
641 if (CONFIG_IS_ENABLED(OF_CONTROL)) {
642 int ret;
643
644 ret = spl_early_init();
645 if (ret) {
646 debug("spl_early_init() failed: %d\n", ret);
647 hang();
648 }
649 }
650
Samuel Holland3988be52020-05-07 18:08:10 -0500651 preloader_console_init();
Philippe Reynesa9a3aad2019-09-19 16:18:39 +0200652}
653#endif
654
Simon Glass070d00b2015-06-23 15:39:10 -0600655void board_init_r(gd_t *dummy1, ulong dummy2)
656{
Simon Glassd32b2d12016-09-24 18:20:17 -0600657 u32 spl_boot_list[] = {
658 BOOT_DEVICE_NONE,
659 BOOT_DEVICE_NONE,
660 BOOT_DEVICE_NONE,
661 BOOT_DEVICE_NONE,
662 BOOT_DEVICE_NONE,
663 };
664 struct spl_image_info spl_image;
Simon Glasse945a722018-11-15 18:43:51 -0700665 int ret;
Simon Glass070d00b2015-06-23 15:39:10 -0600666
Simon Glassd6330062018-11-15 18:43:56 -0700667 debug(">>" SPL_TPL_PROMPT "board_init_r()\n");
York Sund1fc0a32017-09-28 08:42:10 -0700668
Alexandru Gagniuc58b504e2021-04-08 11:56:11 -0500669 spl_set_bd();
670
Simon Glass070d00b2015-06-23 15:39:10 -0600671#if defined(CONFIG_SYS_SPL_MALLOC_START)
672 mem_malloc_init(CONFIG_SYS_SPL_MALLOC_START,
673 CONFIG_SYS_SPL_MALLOC_SIZE);
674 gd->flags |= GD_FLG_FULL_MALLOC_INIT;
675#endif
676 if (!(gd->flags & GD_FLG_SPL_INIT)) {
677 if (spl_init())
678 hang();
679 }
Anatolij Gustschinf9d42d82017-08-28 17:46:33 +0200680#if !defined(CONFIG_PPC) && !defined(CONFIG_ARCH_MX6)
Stefan Roeseea8256f2012-08-23 08:34:21 +0200681 /*
682 * timer_init() does not exist on PPC systems. The timer is initialized
683 * and enabled (decrementer) in interrupt_init() here.
684 */
Ilya Yanok4063c772012-09-17 10:26:26 +0000685 timer_init();
Stefan Roeseea8256f2012-08-23 08:34:21 +0200686#endif
Simon Glass3cd71982019-09-25 08:11:19 -0600687 if (CONFIG_IS_ENABLED(BLOBLIST)) {
688 ret = bloblist_init();
689 if (ret) {
690 debug("%s: Failed to set up bloblist: ret=%d\n",
691 __func__, ret);
692 puts(SPL_TPL_PROMPT "Cannot set up bloblist\n");
693 hang();
694 }
695 }
696 if (CONFIG_IS_ENABLED(HANDOFF)) {
697 int ret;
698
699 ret = setup_spl_handoff();
700 if (ret) {
701 puts(SPL_TPL_PROMPT "Cannot set up SPL handoff\n");
702 hang();
703 }
704 }
Ilya Yanok4063c772012-09-17 10:26:26 +0000705
Kever Yangaf2f4422018-01-20 18:00:26 +0800706#if CONFIG_IS_ENABLED(BOARD_INIT)
Tom Riniee08a822011-11-23 05:13:06 +0000707 spl_board_init();
708#endif
709
Simon Glass078111b2021-07-10 21:14:28 -0600710#if defined(CONFIG_SPL_WATCHDOG) && CONFIG_IS_ENABLED(WDT)
Stefan Roese06985282019-04-11 15:58:44 +0200711 initr_watchdog();
712#endif
713
Heiko Stuebnera343b4f2020-05-25 19:57:25 +0200714 if (IS_ENABLED(CONFIG_SPL_OS_BOOT) || CONFIG_IS_ENABLED(HANDOFF) ||
715 IS_ENABLED(CONFIG_SPL_ATF))
Simon Glassb0edea32018-11-15 18:44:09 -0700716 dram_init_banksize();
717
Lukasz Majewskia8be2492018-05-02 16:10:54 +0200718 bootcount_inc();
719
Simon Glassd32b2d12016-09-24 18:20:17 -0600720 memset(&spl_image, '\0', sizeof(spl_image));
Vikas Manocha5bf52502017-04-07 15:38:13 -0700721#ifdef CONFIG_SYS_SPL_ARGS_ADDR
722 spl_image.arg = (void *)CONFIG_SYS_SPL_ARGS_ADDR;
723#endif
Philipp Tomsichde5dd4c2018-05-24 17:15:50 +0200724 spl_image.boot_device = BOOT_DEVICE_NONE;
Nikita Kiryanovf101e4b2015-11-08 17:11:51 +0200725 board_boot_order(spl_boot_list);
Nikita Kiryanovf101e4b2015-11-08 17:11:51 +0200726
Simon Glass7d84fbb2021-07-05 16:32:57 -0600727 ret = boot_from_devices(&spl_image, spl_boot_list,
728 ARRAY_SIZE(spl_boot_list));
729 if (ret) {
730 if (CONFIG_IS_ENABLED(SHOW_ERRORS) &&
731 CONFIG_IS_ENABLED(LIBCOMMON_SUPPORT))
732 printf(SPL_TPL_PROMPT "failed to boot from all boot devices (err=%d)\n",
733 ret);
734 else
735 puts(SPL_TPL_PROMPT "failed to boot from all boot devices\n");
Aneesh V8cf686e2011-07-21 09:10:27 -0400736 hang();
Nikita Kiryanovf101e4b2015-11-08 17:11:51 +0200737 }
Aneesh V8cf686e2011-07-21 09:10:27 -0400738
Philipp Tomsichde5dd4c2018-05-24 17:15:50 +0200739 spl_perform_fixups(&spl_image);
Simon Glassb0edea32018-11-15 18:44:09 -0700740 if (CONFIG_IS_ENABLED(HANDOFF)) {
741 ret = write_spl_handoff();
742 if (ret)
743 printf(SPL_TPL_PROMPT
744 "SPL hand-off write failed (err=%d)\n", ret);
745 }
Simon Glasse945a722018-11-15 18:43:51 -0700746 if (CONFIG_IS_ENABLED(BLOBLIST)) {
747 ret = bloblist_finish();
748 if (ret)
749 printf("Warning: Failed to finish bloblist (ret=%d)\n",
750 ret);
751 }
Philipp Tomsichde5dd4c2018-05-24 17:15:50 +0200752
Vikas Manocha6bcdd662017-05-28 12:55:08 -0700753#ifdef CONFIG_CPU_V7M
754 spl_image.entry_point |= 0x1;
755#endif
Simon Schwarz9ea5c6e2011-09-14 15:33:34 -0400756 switch (spl_image.os) {
Aneesh V8cf686e2011-07-21 09:10:27 -0400757 case IH_OS_U_BOOT:
Simon Glass1a9e75b2021-02-06 09:57:27 -0700758 debug("Jumping to %s...\n", spl_phase_name(spl_next_phase()));
Aneesh V8cf686e2011-07-21 09:10:27 -0400759 break;
Philipp Tomsich1d379092017-09-13 21:29:35 +0200760#if CONFIG_IS_ENABLED(ATF)
761 case IH_OS_ARM_TRUSTED_FIRMWARE:
762 debug("Jumping to U-Boot via ARM Trusted Firmware\n");
Heiko Stuebnera343b4f2020-05-25 19:57:25 +0200763 spl_fixup_fdt(spl_image.fdt_addr);
Philipp Tomsich1d379092017-09-13 21:29:35 +0200764 spl_invoke_atf(&spl_image);
765 break;
766#endif
Kever Yang70fe2872018-08-23 17:17:59 +0800767#if CONFIG_IS_ENABLED(OPTEE)
768 case IH_OS_TEE:
769 debug("Jumping to U-Boot via OP-TEE\n");
Alexandru Gagniuca25d6b62021-07-15 14:19:24 -0500770 spl_board_prepare_for_optee(spl_image.fdt_addr);
Kever Yang70fe2872018-08-23 17:17:59 +0800771 spl_optee_entry(NULL, NULL, spl_image.fdt_addr,
772 (void *)spl_image.entry_point);
773 break;
774#endif
Lukas Auer5e30e452019-08-21 21:14:44 +0200775#if CONFIG_IS_ENABLED(OPENSBI)
776 case IH_OS_OPENSBI:
777 debug("Jumping to U-Boot via RISC-V OpenSBI\n");
778 spl_invoke_opensbi(&spl_image);
779 break;
780#endif
Simon Schwarz379c19a2012-03-15 04:01:38 +0000781#ifdef CONFIG_SPL_OS_BOOT
782 case IH_OS_LINUX:
783 debug("Jumping to Linux\n");
Heiko Stuebnera343b4f2020-05-25 19:57:25 +0200784#if defined(CONFIG_SYS_SPL_ARGS_ADDR)
785 spl_fixup_fdt((void *)CONFIG_SYS_SPL_ARGS_ADDR);
786#endif
Simon Schwarz379c19a2012-03-15 04:01:38 +0000787 spl_board_prepare_for_linux();
Vikas Manocha5bf52502017-04-07 15:38:13 -0700788 jump_to_image_linux(&spl_image);
Simon Schwarz379c19a2012-03-15 04:01:38 +0000789#endif
Aneesh V8cf686e2011-07-21 09:10:27 -0400790 default:
Tom Rini42120982012-08-27 14:58:28 -0700791 debug("Unsupported OS image.. Jumping nevertheless..\n");
Aneesh V8cf686e2011-07-21 09:10:27 -0400792 }
Andy Yanf1896c42017-07-24 17:43:34 +0800793#if CONFIG_VAL(SYS_MALLOC_F_LEN) && !defined(CONFIG_SYS_SPL_MALLOC_SIZE)
Simon Goldschmidt30c07402018-11-02 21:49:52 +0100794 debug("SPL malloc() used 0x%lx bytes (%ld KB)\n", gd->malloc_ptr,
Simon Glassfb4f5e72014-11-10 17:16:45 -0700795 gd->malloc_ptr / 1024);
796#endif
Simon Glass05e3a0d2021-03-15 18:11:15 +1300797 bootstage_mark_name(get_bootstage_id(false), "end phase");
Simon Glass824bb1b2017-05-22 05:05:35 -0600798#ifdef CONFIG_BOOTSTAGE_STASH
Simon Glass824bb1b2017-05-22 05:05:35 -0600799 ret = bootstage_stash((void *)CONFIG_BOOTSTAGE_STASH_ADDR,
800 CONFIG_BOOTSTAGE_STASH_SIZE);
801 if (ret)
802 debug("Failed to stash bootstage: err=%d\n", ret);
803#endif
Kever Yanga8c51122017-09-13 18:24:24 +0800804
Michal Simek3a3b9142016-05-10 07:54:20 +0200805 spl_board_prepare_for_boot();
Allen Martina759f1e2012-10-19 21:08:22 +0000806 jump_to_image_no_args(&spl_image);
Aneesh Vbcae7212011-07-21 09:10:21 -0400807}
808
Tom Rini6507f132012-08-22 15:31:05 -0700809/*
810 * This requires UART clocks to be enabled. In order for this to work the
811 * caller must ensure that the gd pointer is valid.
812 */
Aneesh Vbcae7212011-07-21 09:10:21 -0400813void preloader_console_init(void)
814{
Samuel Holland3988be52020-05-07 18:08:10 -0500815#ifdef CONFIG_SPL_SERIAL_SUPPORT
Aneesh Vbcae7212011-07-21 09:10:21 -0400816 gd->baudrate = CONFIG_BAUDRATE;
817
Aneesh Vbcae7212011-07-21 09:10:21 -0400818 serial_init(); /* serial communications setup */
819
Ilya Yanokb88befa2011-11-01 13:16:03 +0000820 gd->have_console = 1;
821
Simon Glassaedc08b2018-11-15 18:43:57 -0700822#if CONFIG_IS_ENABLED(BANNER_PRINT)
Simon Glassd6330062018-11-15 18:43:56 -0700823 puts("\nU-Boot " SPL_TPL_NAME " " PLAIN_VERSION " (" U_BOOT_DATE " - "
824 U_BOOT_TIME " " U_BOOT_TZ ")\n");
Anatolij Gustschin0292bc02018-01-25 18:45:22 +0100825#endif
Tom Rini861a86f2012-08-13 11:37:56 -0700826#ifdef CONFIG_SPL_DISPLAY_PRINT
827 spl_display_print();
828#endif
Alex Kiernan117a0e02018-04-19 04:32:51 +0000829#endif
Samuel Holland3988be52020-05-07 18:08:10 -0500830}
Simon Glassdb910352015-03-03 08:03:00 -0700831
832/**
Simon Goldschmidtd8c03322019-07-16 22:30:36 +0200833 * This function is called before the stack is changed from initial stack to
834 * relocated stack. It tries to dump the stack size used
835 */
836__weak void spl_relocate_stack_check(void)
837{
838#if CONFIG_IS_ENABLED(SYS_REPORT_STACK_F_USAGE)
839 ulong init_sp = gd->start_addr_sp;
840 ulong stack_bottom = init_sp - CONFIG_VAL(SIZE_LIMIT_PROVIDE_STACK);
841 u8 *ptr = (u8 *)stack_bottom;
842 ulong i;
843
844 for (i = 0; i < CONFIG_VAL(SIZE_LIMIT_PROVIDE_STACK); i++) {
845 if (*ptr != CONFIG_VAL(SYS_STACK_F_CHECK_BYTE))
846 break;
847 ptr++;
848 }
849 printf("SPL initial stack usage: %lu bytes\n",
850 CONFIG_VAL(SIZE_LIMIT_PROVIDE_STACK) - i);
851#endif
852}
853
854/**
Simon Glassdb910352015-03-03 08:03:00 -0700855 * spl_relocate_stack_gd() - Relocate stack ready for board_init_r() execution
856 *
857 * Sometimes board_init_f() runs with a stack in SRAM but we want to use SDRAM
858 * for the main board_init_r() execution. This is typically because we need
859 * more stack space for things like the MMC sub-system.
860 *
861 * This function calculates the stack position, copies the global_data into
Albert ARIBAUDadc421e2015-11-25 17:56:33 +0100862 * place, sets the new gd (except for ARM, for which setting GD within a C
863 * function may not always work) and returns the new stack position. The
864 * caller is responsible for setting up the sp register and, in the case
865 * of ARM, setting up gd.
866 *
867 * All of this is done using the same layout and alignments as done in
868 * board_init_f_init_reserve() / board_init_f_alloc_reserve().
Simon Glassdb910352015-03-03 08:03:00 -0700869 *
870 * @return new stack location, or 0 to use the same stack
871 */
872ulong spl_relocate_stack_gd(void)
873{
874#ifdef CONFIG_SPL_STACK_R
875 gd_t *new_gd;
Albert ARIBAUDadc421e2015-11-25 17:56:33 +0100876 ulong ptr = CONFIG_SPL_STACK_R_ADDR;
Simon Glassdb910352015-03-03 08:03:00 -0700877
Simon Goldschmidtd8c03322019-07-16 22:30:36 +0200878 if (CONFIG_IS_ENABLED(SYS_REPORT_STACK_F_USAGE))
879 spl_relocate_stack_check();
880
Philipp Tomsichae2cee22017-07-28 11:06:03 +0200881#if defined(CONFIG_SPL_SYS_MALLOC_SIMPLE) && CONFIG_VAL(SYS_MALLOC_F_LEN)
Hans de Goededcfcb8d2015-09-13 15:04:17 +0200882 if (CONFIG_SPL_STACK_R_MALLOC_SIMPLE_LEN) {
Simon Goldschmidt438dcab2019-02-26 22:27:52 +0100883 debug("SPL malloc() before relocation used 0x%lx bytes (%ld KB)\n",
884 gd->malloc_ptr, gd->malloc_ptr / 1024);
Hans de Goededcfcb8d2015-09-13 15:04:17 +0200885 ptr -= CONFIG_SPL_STACK_R_MALLOC_SIMPLE_LEN;
886 gd->malloc_base = ptr;
887 gd->malloc_limit = CONFIG_SPL_STACK_R_MALLOC_SIMPLE_LEN;
888 gd->malloc_ptr = 0;
889 }
890#endif
Albert ARIBAUDadc421e2015-11-25 17:56:33 +0100891 /* Get stack position: use 8-byte alignment for ABI compliance */
892 ptr = CONFIG_SPL_STACK_R_ADDR - roundup(sizeof(gd_t),16);
893 new_gd = (gd_t *)ptr;
894 memcpy(new_gd, (void *)gd, sizeof(gd_t));
Simon Glass2f11cd92016-11-13 14:21:58 -0700895#if CONFIG_IS_ENABLED(DM)
896 dm_fixup_for_gd_move(new_gd);
897#endif
Lukas Auerc7e1eff2019-08-21 21:14:46 +0200898#if !defined(CONFIG_ARM) && !defined(CONFIG_RISCV)
Albert ARIBAUDadc421e2015-11-25 17:56:33 +0100899 gd = new_gd;
900#endif
Simon Glassdb910352015-03-03 08:03:00 -0700901 return ptr;
902#else
903 return 0;
904#endif
905}
Simon Glassc6604442019-11-14 12:57:17 -0700906
Philippe Reynes4d145f22020-12-11 19:56:47 +0100907#if defined(CONFIG_BOOTCOUNT_LIMIT) && \
908 ((!defined(CONFIG_TPL_BUILD) && !defined(CONFIG_SPL_BOOTCOUNT_LIMIT)) || \
909 (defined(CONFIG_TPL_BUILD) && !defined(CONFIG_TPL_BOOTCOUNT_LIMIT)))
Simon Glassc6604442019-11-14 12:57:17 -0700910void bootcount_store(ulong a)
911{
912}
913
914ulong bootcount_load(void)
915{
916 return 0;
917}
918#endif