blob: 5fdd6d0d032181cfd6e841ede1c2dd47fd6b9701 [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 Glass1801a3e2014-11-10 17:16:46 -070012#include <dm.h>
Simon Glasse14f1a22018-11-15 18:44:09 -070013#include <handoff.h>
Tom Rini28591df2012-08-13 12:03:19 -070014#include <spl.h>
Aneesh Vb8e60b92011-07-21 09:10:21 -040015#include <asm/u-boot.h>
Simon Schwarz992dcf72011-09-14 15:29:26 -040016#include <nand.h>
Aneesh V13a74c12011-07-21 09:10:27 -040017#include <fat.h>
Simon Glass50402412011-10-10 08:55:19 +000018#include <version.h>
Aneesh V13a74c12011-07-21 09:10:27 -040019#include <image.h>
Aneesh V0560be22011-10-21 12:29:34 -040020#include <malloc.h>
Simon Glass1801a3e2014-11-10 17:16:46 -070021#include <dm/root.h>
Andreas Müller0cda7a42012-01-04 15:26:24 +000022#include <linux/compiler.h>
B, Ravi4cf02b12017-04-18 17:27:27 +053023#include <fdt_support.h>
Lukasz Majewskia4858602018-05-02 16:10:54 +020024#include <bootcount.h>
Stefan Roese502acb02019-04-11 15:58:44 +020025#include <wdt.h>
Aneesh Vb8e60b92011-07-21 09:10:21 -040026
27DECLARE_GLOBAL_DATA_PTR;
28
Stefan Roese5f169922012-08-28 10:50:59 +020029#ifndef CONFIG_SYS_UBOOT_START
30#define CONFIG_SYS_UBOOT_START CONFIG_SYS_TEXT_BASE
31#endif
Stefano Babicfb5d62a2012-08-23 12:46:16 +020032#ifndef CONFIG_SYS_MONITOR_LEN
Andreas Bießmannad244122014-10-25 02:54:55 +020033/* Unknown U-Boot size, let's assume it will not be more than 200 KB */
Stefano Babicfb5d62a2012-08-23 12:46:16 +020034#define CONFIG_SYS_MONITOR_LEN (200 * 1024)
35#endif
36
Tom Rini28591df2012-08-13 12:03:19 -070037u32 *boot_params_ptr = NULL;
Simon Schwarze21d2d82011-09-14 15:33:34 -040038
Simon Glass867a3982017-11-13 18:55:03 -070039/* See spl.h for information about this */
Simon Glass9dcc8612018-08-01 15:22:42 -060040binman_sym_declare(ulong, u_boot_any, image_pos);
Simon Glass867a3982017-11-13 18:55:03 -070041
Tom Rini31dfba42012-08-22 15:31:05 -070042/* Define board data structure */
Aneesh Vb8e60b92011-07-21 09:10:21 -040043static bd_t bdata __attribute__ ((section(".data")));
44
Simon Schwarz305bc4c2012-03-15 04:01:38 +000045/*
Heiko Schocher747ceee2016-06-07 08:31:20 +020046 * Board-specific Platform code can reimplement show_boot_progress () if needed
47 */
48__weak void show_boot_progress(int val) {}
49
Simon Glasse14f1a22018-11-15 18:44:09 -070050#if defined(CONFIG_SPL_OS_BOOT) || CONFIG_IS_ENABLED(HANDOFF)
51/* weak, default platform-specific function to initialize dram banks */
52__weak int dram_init_banksize(void)
53{
54 return 0;
55}
56#endif
57
Heiko Schocher747ceee2016-06-07 08:31:20 +020058/*
Simon Schwarz305bc4c2012-03-15 04:01:38 +000059 * Default function to determine if u-boot or the OS should
60 * be started. This implementation always returns 1.
61 *
62 * Please implement your own board specific funcion to do this.
63 *
64 * RETURN
65 * 0 to not start u-boot
66 * positive if u-boot should start
67 */
68#ifdef CONFIG_SPL_OS_BOOT
69__weak int spl_start_uboot(void)
70{
Simon Glassdbd3f112018-11-15 18:43:56 -070071 puts(SPL_TPL_PROMPT
72 "Please implement spl_start_uboot() for your board\n");
73 puts(SPL_TPL_PROMPT "Direct Linux boot not active!\n");
Simon Schwarz305bc4c2012-03-15 04:01:38 +000074 return 1;
75}
Ladislav Michl9c743722016-07-12 20:28:14 +020076
77/*
78 * Weak default function for arch specific zImage check. Return zero
79 * and fill start and end address if image is recognized.
80 */
81int __weak bootz_setup(ulong image, ulong *start, ulong *end)
82{
83 return 1;
84}
Simon Schwarz305bc4c2012-03-15 04:01:38 +000085#endif
86
Philipp Tomsich58beb6e2018-05-24 17:15:50 +020087/* Weak default function for arch/board-specific fixups to the spl_image_info */
88void __weak spl_perform_fixups(struct spl_image_info *spl_image)
89{
90}
91
B, Ravi4cf02b12017-04-18 17:27:27 +053092void spl_fixup_fdt(void)
93{
94#if defined(CONFIG_SPL_OF_LIBFDT) && defined(CONFIG_SYS_SPL_ARGS_ADDR)
95 void *fdt_blob = (void *)CONFIG_SYS_SPL_ARGS_ADDR;
96 int err;
97
98 err = fdt_check_header(fdt_blob);
99 if (err < 0) {
100 printf("fdt_root: %s\n", fdt_strerror(err));
101 return;
102 }
103
104 /* fixup the memory dt node */
105 err = fdt_shrink_to_minimum(fdt_blob, 0);
106 if (err == 0) {
Simon Glassdbd3f112018-11-15 18:43:56 -0700107 printf(SPL_TPL_PROMPT "fdt_shrink_to_minimum err - %d\n", err);
B, Ravi4cf02b12017-04-18 17:27:27 +0530108 return;
109 }
110
111 err = arch_fixup_fdt(fdt_blob);
112 if (err) {
Simon Glassdbd3f112018-11-15 18:43:56 -0700113 printf(SPL_TPL_PROMPT "arch_fixup_fdt err - %d\n", err);
B, Ravi4cf02b12017-04-18 17:27:27 +0530114 return;
115 }
116#endif
117}
118
Stefan Roeseec90d342012-08-23 08:34:21 +0200119/*
120 * Weak default function for board specific cleanup/preparation before
121 * Linux boot. Some boards/platforms might not need it, so just provide
122 * an empty stub here.
123 */
124__weak void spl_board_prepare_for_linux(void)
125{
126 /* Nothing to do! */
127}
128
Michal Simek7a8465b2016-05-10 07:54:20 +0200129__weak void spl_board_prepare_for_boot(void)
130{
131 /* Nothing to do! */
132}
133
Marek Vasut1dda46f2018-08-14 11:27:02 +0200134__weak struct image_header *spl_get_load_buffer(ssize_t offset, size_t size)
135{
136 return (struct image_header *)(CONFIG_SYS_TEXT_BASE + offset);
137}
138
Simon Glass11a1a272016-09-24 18:19:52 -0600139void spl_set_header_raw_uboot(struct spl_image_info *spl_image)
Heiko Schochercf000272014-10-31 08:31:00 +0100140{
Simon Glass9dcc8612018-08-01 15:22:42 -0600141 ulong u_boot_pos = binman_sym(ulong, u_boot_any, image_pos);
Simon Glass867a3982017-11-13 18:55:03 -0700142
Simon Glass11a1a272016-09-24 18:19:52 -0600143 spl_image->size = CONFIG_SYS_MONITOR_LEN;
Miquel Raynal31824ff2018-02-28 20:51:43 +0100144
145 /*
146 * Binman error cases: address of the end of the previous region or the
147 * start of the image's entry area (usually 0) if there is no previous
148 * region.
149 */
150 if (u_boot_pos && u_boot_pos != BINMAN_SYM_MISSING) {
151 /* Binman does not support separated entry addresses */
Simon Glass867a3982017-11-13 18:55:03 -0700152 spl_image->entry_point = u_boot_pos;
153 spl_image->load_addr = u_boot_pos;
154 } else {
155 spl_image->entry_point = CONFIG_SYS_UBOOT_START;
156 spl_image->load_addr = CONFIG_SYS_TEXT_BASE;
157 }
Simon Glass11a1a272016-09-24 18:19:52 -0600158 spl_image->os = IH_OS_U_BOOT;
159 spl_image->name = "U-Boot";
Heiko Schochercf000272014-10-31 08:31:00 +0100160}
161
Marek Vasut06623372018-05-13 00:23:17 +0200162#ifdef CONFIG_SPL_LOAD_FIT_FULL
163/* Parse and load full fitImage in SPL */
164static int spl_load_fit_image(struct spl_image_info *spl_image,
165 const struct image_header *header)
166{
167 bootm_headers_t images;
168 const char *fit_uname_config = NULL;
169 const char *fit_uname_fdt = FIT_FDT_PROP;
170 const char *uname;
171 ulong fw_data = 0, dt_data = 0, img_data = 0;
172 ulong fw_len = 0, dt_len = 0, img_len = 0;
173 int idx, conf_noffset;
174 int ret;
175
176#ifdef CONFIG_SPL_FIT_SIGNATURE
177 images.verify = 1;
178#endif
179 ret = fit_image_load(&images, (ulong)header,
180 NULL, &fit_uname_config,
181 IH_ARCH_DEFAULT, IH_TYPE_STANDALONE, -1,
182 FIT_LOAD_REQUIRED, &fw_data, &fw_len);
183 if (ret < 0)
184 return ret;
185
186 spl_image->size = fw_len;
187 spl_image->entry_point = fw_data;
188 spl_image->load_addr = fw_data;
189 spl_image->os = IH_OS_U_BOOT;
190 spl_image->name = "U-Boot";
191
Simon Glassdbd3f112018-11-15 18:43:56 -0700192 debug(SPL_TPL_PROMPT "payload image: %32s load addr: 0x%lx size: %d\n",
Simon Goldschmidt1ddade62018-11-02 21:49:52 +0100193 spl_image->name, spl_image->load_addr, spl_image->size);
Marek Vasut06623372018-05-13 00:23:17 +0200194
195#ifdef CONFIG_SPL_FIT_SIGNATURE
196 images.verify = 1;
197#endif
Marek Vasut187b9e32019-05-07 21:17:02 +0200198 ret = fit_image_load(&images, (ulong)header,
Marek Vasut06623372018-05-13 00:23:17 +0200199 &fit_uname_fdt, &fit_uname_config,
200 IH_ARCH_DEFAULT, IH_TYPE_FLATDT, -1,
201 FIT_LOAD_OPTIONAL, &dt_data, &dt_len);
Marek Vasut187b9e32019-05-07 21:17:02 +0200202 if (ret >= 0)
203 spl_image->fdt_addr = (void *)dt_data;
Marek Vasut06623372018-05-13 00:23:17 +0200204
205 conf_noffset = fit_conf_get_node((const void *)header,
206 fit_uname_config);
207 if (conf_noffset <= 0)
208 return 0;
209
210 for (idx = 0;
211 uname = fdt_stringlist_get((const void *)header, conf_noffset,
212 FIT_LOADABLE_PROP, idx,
213 NULL), uname;
214 idx++)
215 {
216#ifdef CONFIG_SPL_FIT_SIGNATURE
217 images.verify = 1;
218#endif
219 ret = fit_image_load(&images, (ulong)header,
220 &uname, &fit_uname_config,
221 IH_ARCH_DEFAULT, IH_TYPE_LOADABLE, -1,
222 FIT_LOAD_OPTIONAL_NON_ZERO,
223 &img_data, &img_len);
224 if (ret < 0)
225 return ret;
226 }
227
228 return 0;
229}
230#endif
231
Simon Glass6b2e4db2016-09-24 18:19:53 -0600232int spl_parse_image_header(struct spl_image_info *spl_image,
233 const struct image_header *header)
Aneesh V13a74c12011-07-21 09:10:27 -0400234{
Marek Vasut06623372018-05-13 00:23:17 +0200235#ifdef CONFIG_SPL_LOAD_FIT_FULL
236 int ret = spl_load_fit_image(spl_image, header);
237
238 if (!ret)
239 return ret;
240#endif
Stefan Roese292db772012-08-27 12:50:57 +0200241 if (image_get_magic(header) == IH_MAGIC) {
Andrew F. Davis74630342017-02-16 11:18:39 -0600242#ifdef CONFIG_SPL_LEGACY_IMAGE_SUPPORT
243 u32 header_size = sizeof(struct image_header);
244
Simon Goldschmidt17140472019-02-10 21:34:37 +0100245#ifdef CONFIG_SPL_LEGACY_IMAGE_CRC_CHECK
246 /* check uImage header CRC */
247 if (!image_check_hcrc(header)) {
248 puts("SPL: Image header CRC check failed!\n");
249 return -EINVAL;
250 }
251#endif
252
Simon Glass6b2e4db2016-09-24 18:19:53 -0600253 if (spl_image->flags & SPL_COPY_PAYLOAD_ONLY) {
Stefan Roese00b57b32012-08-27 12:50:58 +0200254 /*
255 * On some system (e.g. powerpc), the load-address and
256 * entry-point is located at address 0. We can't load
257 * to 0-0x40. So skip header in this case.
258 */
Simon Glass6b2e4db2016-09-24 18:19:53 -0600259 spl_image->load_addr = image_get_load(header);
260 spl_image->entry_point = image_get_ep(header);
261 spl_image->size = image_get_data_size(header);
Stefan Roese00b57b32012-08-27 12:50:58 +0200262 } else {
Simon Glass6b2e4db2016-09-24 18:19:53 -0600263 spl_image->entry_point = image_get_load(header);
Stefan Roese00b57b32012-08-27 12:50:58 +0200264 /* Load including the header */
Simon Glass6b2e4db2016-09-24 18:19:53 -0600265 spl_image->load_addr = spl_image->entry_point -
Stefan Roese00b57b32012-08-27 12:50:58 +0200266 header_size;
Simon Glass6b2e4db2016-09-24 18:19:53 -0600267 spl_image->size = image_get_data_size(header) +
Stefan Roese00b57b32012-08-27 12:50:58 +0200268 header_size;
269 }
Simon Goldschmidt17140472019-02-10 21:34:37 +0100270#ifdef CONFIG_SPL_LEGACY_IMAGE_CRC_CHECK
271 /* store uImage data length and CRC to check later */
272 spl_image->dcrc_data = image_get_load(header);
273 spl_image->dcrc_length = image_get_data_size(header);
274 spl_image->dcrc = image_get_dcrc(header);
275#endif
276
Simon Glass6b2e4db2016-09-24 18:19:53 -0600277 spl_image->os = image_get_os(header);
278 spl_image->name = image_get_name(header);
Simon Glassdbd3f112018-11-15 18:43:56 -0700279 debug(SPL_TPL_PROMPT
280 "payload image: %32s load addr: 0x%lx size: %d\n",
Simon Goldschmidt1ddade62018-11-02 21:49:52 +0100281 spl_image->name, spl_image->load_addr, spl_image->size);
Andrew F. Davis74630342017-02-16 11:18:39 -0600282#else
283 /* LEGACY image not supported */
Anatolij Gustschindcb711f2017-08-01 16:17:12 +0200284 debug("Legacy boot image support not enabled, proceeding to other boot methods\n");
Andrew F. Davis74630342017-02-16 11:18:39 -0600285 return -EINVAL;
286#endif
Aneesh V13a74c12011-07-21 09:10:27 -0400287 } else {
Albert ARIBAUD \(3ADEV\)287b0942015-03-31 11:40:50 +0200288#ifdef CONFIG_SPL_PANIC_ON_RAW_IMAGE
289 /*
290 * CONFIG_SPL_PANIC_ON_RAW_IMAGE is defined when the
291 * code which loads images in SPL cannot guarantee that
292 * absolutely all read errors will be reported.
293 * An example is the LPC32XX MLC NAND driver, which
294 * will consider that a completely unreadable NAND block
295 * is bad, and thus should be skipped silently.
296 */
297 panic("** no mkimage signature but raw image not supported");
Paul Kocialkowskie48b7752016-08-24 20:04:42 +0200298#endif
299
Ladislav Michl9c743722016-07-12 20:28:14 +0200300#ifdef CONFIG_SPL_OS_BOOT
301 ulong start, end;
302
303 if (!bootz_setup((ulong)header, &start, &end)) {
Simon Glass6b2e4db2016-09-24 18:19:53 -0600304 spl_image->name = "Linux";
305 spl_image->os = IH_OS_LINUX;
306 spl_image->load_addr = CONFIG_SYS_LOAD_ADDR;
307 spl_image->entry_point = CONFIG_SYS_LOAD_ADDR;
308 spl_image->size = end - start;
Simon Glassdbd3f112018-11-15 18:43:56 -0700309 debug(SPL_TPL_PROMPT
310 "payload zImage, load addr: 0x%lx size: %d\n",
Simon Glass6b2e4db2016-09-24 18:19:53 -0600311 spl_image->load_addr, spl_image->size);
Ladislav Michl9c743722016-07-12 20:28:14 +0200312 return 0;
313 }
314#endif
Paul Kocialkowskie48b7752016-08-24 20:04:42 +0200315
Andrew F. Davisb4be3c32017-02-16 11:18:38 -0600316#ifdef CONFIG_SPL_RAW_IMAGE_SUPPORT
Aneesh V13a74c12011-07-21 09:10:27 -0400317 /* Signature not found - assume u-boot.bin */
Tom Rini7b516862012-08-14 12:06:43 -0700318 debug("mkimage signature not found - ih_magic = %x\n",
Aneesh V13a74c12011-07-21 09:10:27 -0400319 header->ih_magic);
Simon Glass6b2e4db2016-09-24 18:19:53 -0600320 spl_set_header_raw_uboot(spl_image);
Andrew F. Davisb4be3c32017-02-16 11:18:38 -0600321#else
322 /* RAW image not supported, proceed to other boot methods. */
Anatolij Gustschindcb711f2017-08-01 16:17:12 +0200323 debug("Raw boot image support not enabled, proceeding to other boot methods\n");
Andrew F. Davisb4be3c32017-02-16 11:18:38 -0600324 return -EINVAL;
Albert ARIBAUD \(3ADEV\)287b0942015-03-31 11:40:50 +0200325#endif
Aneesh V13a74c12011-07-21 09:10:27 -0400326 }
Andrew F. Davisb4be3c32017-02-16 11:18:38 -0600327
Marek Vasut02266e22016-04-29 00:44:54 +0200328 return 0;
Aneesh V13a74c12011-07-21 09:10:27 -0400329}
330
Allen Martinc67e4852012-10-19 21:08:22 +0000331__weak void __noreturn jump_to_image_no_args(struct spl_image_info *spl_image)
Aneesh V13a74c12011-07-21 09:10:27 -0400332{
SRICHARAN R3f30b0a2013-04-24 00:41:24 +0000333 typedef void __noreturn (*image_entry_noargs_t)(void);
334
Aneesh V13a74c12011-07-21 09:10:27 -0400335 image_entry_noargs_t image_entry =
Andre Przywara6c526072017-01-02 11:48:31 +0000336 (image_entry_noargs_t)spl_image->entry_point;
Aneesh V13a74c12011-07-21 09:10:27 -0400337
Simon Goldschmidt1ddade62018-11-02 21:49:52 +0100338 debug("image entry point: 0x%lx\n", spl_image->entry_point);
SRICHARAN R3f30b0a2013-04-24 00:41:24 +0000339 image_entry();
Aneesh V13a74c12011-07-21 09:10:27 -0400340}
341
Simon Glasse14f1a22018-11-15 18:44:09 -0700342#if CONFIG_IS_ENABLED(HANDOFF)
343/**
344 * Set up the SPL hand-off information
345 *
346 * This is initially empty (zero) but can be written by
347 */
348static int setup_spl_handoff(void)
349{
350 struct spl_handoff *ho;
351
352 ho = bloblist_ensure(BLOBLISTT_SPL_HANDOFF, sizeof(struct spl_handoff));
353 if (!ho)
354 return -ENOENT;
355
356 return 0;
357}
358
Simon Glassc5d27202019-09-25 08:11:18 -0600359__weak int handoff_arch_save(struct spl_handoff *ho)
360{
361 return 0;
362}
363
Simon Glasse14f1a22018-11-15 18:44:09 -0700364static int write_spl_handoff(void)
365{
366 struct spl_handoff *ho;
Simon Glassc5d27202019-09-25 08:11:18 -0600367 int ret;
Simon Glasse14f1a22018-11-15 18:44:09 -0700368
369 ho = bloblist_find(BLOBLISTT_SPL_HANDOFF, sizeof(struct spl_handoff));
370 if (!ho)
371 return -ENOENT;
372 handoff_save_dram(ho);
Simon Glassc5d27202019-09-25 08:11:18 -0600373 ret = handoff_arch_save(ho);
374 if (ret)
375 return ret;
Simon Glasse14f1a22018-11-15 18:44:09 -0700376 debug(SPL_TPL_PROMPT "Wrote SPL handoff\n");
377
378 return 0;
379}
380#else
381static inline int setup_spl_handoff(void) { return 0; }
382static inline int write_spl_handoff(void) { return 0; }
383
384#endif /* HANDOFF */
385
Eddie Cai32258992017-03-15 08:43:28 -0600386static int spl_common_init(bool setup_malloc)
Aneesh Vb8e60b92011-07-21 09:10:21 -0400387{
Simon Glass9a49ec12015-02-27 22:06:42 -0700388 int ret;
389
Andy Yan1fa20e4d2017-07-24 17:43:34 +0800390#if CONFIG_VAL(SYS_MALLOC_F_LEN)
Eddie Cai32258992017-03-15 08:43:28 -0600391 if (setup_malloc) {
Marek Vasutd61ba112016-05-25 02:14:56 +0200392#ifdef CONFIG_MALLOC_F_ADDR
Eddie Cai32258992017-03-15 08:43:28 -0600393 gd->malloc_base = CONFIG_MALLOC_F_ADDR;
Marek Vasutd61ba112016-05-25 02:14:56 +0200394#endif
Andy Yan1fa20e4d2017-07-24 17:43:34 +0800395 gd->malloc_limit = CONFIG_VAL(SYS_MALLOC_F_LEN);
Eddie Cai32258992017-03-15 08:43:28 -0600396 gd->malloc_ptr = 0;
397 }
Tom Rini730bae72012-08-13 14:13:07 -0700398#endif
Simon Glass01154cb2017-05-22 05:05:35 -0600399 ret = bootstage_init(true);
400 if (ret) {
401 debug("%s: Failed to set up bootstage: ret=%d\n", __func__,
402 ret);
403 return ret;
404 }
405 bootstage_mark_name(BOOTSTAGE_ID_START_SPL, "spl");
Simon Glassb56cdc02018-11-15 18:43:49 -0700406#if CONFIG_IS_ENABLED(LOG)
407 ret = log_init();
408 if (ret) {
409 debug("%s: Failed to set up logging\n", __func__);
410 return ret;
411 }
412#endif
Simon Glassbb948382016-07-04 11:57:56 -0600413 if (CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)) {
Simon Glass9a49ec12015-02-27 22:06:42 -0700414 ret = fdtdec_setup();
415 if (ret) {
416 debug("fdtdec_setup() returned error %d\n", ret);
Simon Glassfa2a4db2015-06-23 15:39:10 -0600417 return ret;
Simon Glass9a49ec12015-02-27 22:06:42 -0700418 }
419 }
Philipp Tomsich60e15782017-06-30 19:02:53 +0200420 if (CONFIG_IS_ENABLED(DM)) {
Simon Glass01154cb2017-05-22 05:05:35 -0600421 bootstage_start(BOOTSTATE_ID_ACCUM_DM_SPL, "dm_spl");
Tom Rini9732f792017-01-14 12:20:23 -0500422 /* With CONFIG_SPL_OF_PLATDATA, bring in all devices */
Simon Glasse9559fb2016-07-04 11:58:14 -0600423 ret = dm_init_and_scan(!CONFIG_IS_ENABLED(OF_PLATDATA));
Simon Glass01154cb2017-05-22 05:05:35 -0600424 bootstage_accum(BOOTSTATE_ID_ACCUM_DM_SPL);
Simon Glass9a49ec12015-02-27 22:06:42 -0700425 if (ret) {
426 debug("dm_init_and_scan() returned error %d\n", ret);
Simon Glassfa2a4db2015-06-23 15:39:10 -0600427 return ret;
Simon Glass9a49ec12015-02-27 22:06:42 -0700428 }
429 }
Eddie Cai32258992017-03-15 08:43:28 -0600430
431 return 0;
432}
433
York Suna34ca5f2017-09-28 08:42:10 -0700434void spl_set_bd(void)
435{
Simon Glassef8d48a2018-11-15 18:43:58 -0700436 /*
437 * NOTE: On some platforms (e.g. x86) bdata may be in flash and not
438 * writeable.
439 */
York Suna34ca5f2017-09-28 08:42:10 -0700440 if (!gd->bd)
441 gd->bd = &bdata;
442}
443
Eddie Cai32258992017-03-15 08:43:28 -0600444int spl_early_init(void)
445{
446 int ret;
447
Simon Goldschmidt7dbffe42018-08-13 11:24:05 +0200448 debug("%s\n", __func__);
449
Eddie Cai32258992017-03-15 08:43:28 -0600450 ret = spl_common_init(true);
451 if (ret)
452 return ret;
453 gd->flags |= GD_FLG_SPL_EARLY_INIT;
454
455 return 0;
456}
457
458int spl_init(void)
459{
460 int ret;
Tom Rini89ea21e2017-03-20 14:19:27 -0400461 bool setup_malloc = !(IS_ENABLED(CONFIG_SPL_STACK_R) &&
462 IS_ENABLED(CONFIG_SPL_SYS_MALLOC_SIMPLE));
Eddie Cai32258992017-03-15 08:43:28 -0600463
Simon Goldschmidt7dbffe42018-08-13 11:24:05 +0200464 debug("%s\n", __func__);
465
Eddie Cai32258992017-03-15 08:43:28 -0600466 if (!(gd->flags & GD_FLG_SPL_EARLY_INIT)) {
Tom Rini89ea21e2017-03-20 14:19:27 -0400467 ret = spl_common_init(setup_malloc);
Eddie Cai32258992017-03-15 08:43:28 -0600468 if (ret)
469 return ret;
470 }
Simon Glassfa2a4db2015-06-23 15:39:10 -0600471 gd->flags |= GD_FLG_SPL_INIT;
472
473 return 0;
474}
475
Nikita Kiryanov3ed94782015-11-08 17:11:51 +0200476#ifndef BOOT_DEVICE_NONE
477#define BOOT_DEVICE_NONE 0xdeadbeef
478#endif
479
Nikita Kiryanov3ed94782015-11-08 17:11:51 +0200480__weak void board_boot_order(u32 *spl_boot_list)
481{
482 spl_boot_list[0] = spl_boot_device();
483}
484
Simon Glassd1cf3732016-09-24 18:19:58 -0600485static struct spl_image_loader *spl_ll_find_loader(uint boot_device)
486{
487 struct spl_image_loader *drv =
488 ll_entry_start(struct spl_image_loader, spl_image_loader);
489 const int n_ents =
490 ll_entry_count(struct spl_image_loader, spl_image_loader);
491 struct spl_image_loader *entry;
492
493 for (entry = drv; entry != drv + n_ents; entry++) {
494 if (boot_device == entry->boot_device)
495 return entry;
496 }
497
498 /* Not found */
499 return NULL;
500}
501
Simon Glassf1e55752016-11-30 15:30:52 -0700502static int spl_load_image(struct spl_image_info *spl_image,
503 struct spl_image_loader *loader)
Simon Glassfa2a4db2015-06-23 15:39:10 -0600504{
Simon Goldschmidt17140472019-02-10 21:34:37 +0100505 int ret;
Simon Glassc0b6c9b2016-09-24 18:19:57 -0600506 struct spl_boot_device bootdev;
507
Simon Glassf1e55752016-11-30 15:30:52 -0700508 bootdev.boot_device = loader->boot_device;
Simon Glassc0b6c9b2016-09-24 18:19:57 -0600509 bootdev.boot_device_name = NULL;
510
Simon Goldschmidt17140472019-02-10 21:34:37 +0100511 ret = loader->load_image(spl_image, &bootdev);
512#ifdef CONFIG_SPL_LEGACY_IMAGE_CRC_CHECK
513 if (!ret && spl_image->dcrc_length) {
514 /* check data crc */
515 ulong dcrc = crc32_wd(0, (unsigned char *)spl_image->dcrc_data,
516 spl_image->dcrc_length, CHUNKSZ_CRC32);
517 if (dcrc != spl_image->dcrc) {
518 puts("SPL: Image data CRC check failed!\n");
519 ret = -EINVAL;
520 }
521 }
522#endif
523 return ret;
Simon Glassc9ef1852016-11-30 15:30:51 -0700524}
525
526/**
Miquel Raynal9f8d9942019-05-07 14:18:43 +0200527 * boot_from_devices() - Try loading a booting U-Boot from a list of devices
Simon Glassc9ef1852016-11-30 15:30:51 -0700528 *
529 * @spl_image: Place to put the image details if successful
530 * @spl_boot_list: List of boot devices to try
531 * @count: Number of elements in spl_boot_list
532 * @return 0 if OK, -ve on error
533 */
534static int boot_from_devices(struct spl_image_info *spl_image,
535 u32 spl_boot_list[], int count)
536{
537 int i;
538
539 for (i = 0; i < count && spl_boot_list[i] != BOOT_DEVICE_NONE; i++) {
540 struct spl_image_loader *loader;
541
Simon Glassc9ef1852016-11-30 15:30:51 -0700542 loader = spl_ll_find_loader(spl_boot_list[i]);
Stefan Roesece21aa12014-11-11 19:03:55 +0100543#if defined(CONFIG_SPL_SERIAL_SUPPORT) && defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
Simon Glass2b530f92016-11-30 15:30:53 -0700544 if (loader)
Andrew F. Davis07009932017-01-12 10:19:55 -0600545 printf("Trying to boot from %s\n", loader->name);
Simon Glass2b530f92016-11-30 15:30:53 -0700546 else
Simon Glassdbd3f112018-11-15 18:43:56 -0700547 puts(SPL_TPL_PROMPT "Unsupported Boot Device!\n");
Stefan Roesece21aa12014-11-11 19:03:55 +0100548#endif
Philipp Tomsich58beb6e2018-05-24 17:15:50 +0200549 if (loader && !spl_load_image(spl_image, loader)) {
550 spl_image->boot_device = spl_boot_list[i];
Simon Glassc9ef1852016-11-30 15:30:51 -0700551 return 0;
Philipp Tomsich58beb6e2018-05-24 17:15:50 +0200552 }
Simon Glassc9ef1852016-11-30 15:30:51 -0700553 }
554
Simon Glassa4996482016-09-24 18:20:12 -0600555 return -ENODEV;
Nikita Kiryanov0a978812015-11-08 17:11:50 +0200556}
557
558void board_init_r(gd_t *dummy1, ulong dummy2)
559{
Simon Glassce8f5092016-09-24 18:20:17 -0600560 u32 spl_boot_list[] = {
561 BOOT_DEVICE_NONE,
562 BOOT_DEVICE_NONE,
563 BOOT_DEVICE_NONE,
564 BOOT_DEVICE_NONE,
565 BOOT_DEVICE_NONE,
566 };
567 struct spl_image_info spl_image;
Simon Glass4e0a52d2018-11-15 18:43:51 -0700568 int ret;
Nikita Kiryanov0a978812015-11-08 17:11:50 +0200569
Simon Glassdbd3f112018-11-15 18:43:56 -0700570 debug(">>" SPL_TPL_PROMPT "board_init_r()\n");
York Suna34ca5f2017-09-28 08:42:10 -0700571
572 spl_set_bd();
573
Nikita Kiryanov0a978812015-11-08 17:11:50 +0200574#if defined(CONFIG_SYS_SPL_MALLOC_START)
575 mem_malloc_init(CONFIG_SYS_SPL_MALLOC_START,
576 CONFIG_SYS_SPL_MALLOC_SIZE);
577 gd->flags |= GD_FLG_FULL_MALLOC_INIT;
578#endif
579 if (!(gd->flags & GD_FLG_SPL_INIT)) {
580 if (spl_init())
581 hang();
582 }
Anatolij Gustschin28674c92017-08-28 17:46:33 +0200583#if !defined(CONFIG_PPC) && !defined(CONFIG_ARCH_MX6)
Nikita Kiryanov0a978812015-11-08 17:11:50 +0200584 /*
585 * timer_init() does not exist on PPC systems. The timer is initialized
586 * and enabled (decrementer) in interrupt_init() here.
587 */
588 timer_init();
589#endif
Simon Glassf1207752019-09-25 08:11:19 -0600590 if (CONFIG_IS_ENABLED(BLOBLIST)) {
591 ret = bloblist_init();
592 if (ret) {
593 debug("%s: Failed to set up bloblist: ret=%d\n",
594 __func__, ret);
595 puts(SPL_TPL_PROMPT "Cannot set up bloblist\n");
596 hang();
597 }
598 }
599 if (CONFIG_IS_ENABLED(HANDOFF)) {
600 int ret;
601
602 ret = setup_spl_handoff();
603 if (ret) {
604 puts(SPL_TPL_PROMPT "Cannot set up SPL handoff\n");
605 hang();
606 }
607 }
Nikita Kiryanov0a978812015-11-08 17:11:50 +0200608
Kever Yang2b5994b2018-01-20 18:00:26 +0800609#if CONFIG_IS_ENABLED(BOARD_INIT)
Nikita Kiryanov0a978812015-11-08 17:11:50 +0200610 spl_board_init();
611#endif
612
Marek Vasut55ec91b2019-06-09 03:46:21 +0200613#if defined(CONFIG_SPL_WATCHDOG_SUPPORT) && CONFIG_IS_ENABLED(WDT)
Stefan Roese502acb02019-04-11 15:58:44 +0200614 initr_watchdog();
615#endif
616
Simon Glasse14f1a22018-11-15 18:44:09 -0700617 if (IS_ENABLED(CONFIG_SPL_OS_BOOT) || CONFIG_IS_ENABLED(HANDOFF))
618 dram_init_banksize();
619
Lukasz Majewskia4858602018-05-02 16:10:54 +0200620 bootcount_inc();
621
Simon Glassce8f5092016-09-24 18:20:17 -0600622 memset(&spl_image, '\0', sizeof(spl_image));
Vikas Manocha62b021c2017-04-07 15:38:13 -0700623#ifdef CONFIG_SYS_SPL_ARGS_ADDR
624 spl_image.arg = (void *)CONFIG_SYS_SPL_ARGS_ADDR;
625#endif
Philipp Tomsich58beb6e2018-05-24 17:15:50 +0200626 spl_image.boot_device = BOOT_DEVICE_NONE;
Nikita Kiryanov3ed94782015-11-08 17:11:51 +0200627 board_boot_order(spl_boot_list);
Nikita Kiryanov3ed94782015-11-08 17:11:51 +0200628
Simon Glassc9ef1852016-11-30 15:30:51 -0700629 if (boot_from_devices(&spl_image, spl_boot_list,
630 ARRAY_SIZE(spl_boot_list))) {
Simon Glassdbd3f112018-11-15 18:43:56 -0700631 puts(SPL_TPL_PROMPT "failed to boot from all boot devices\n");
Nikita Kiryanov0a978812015-11-08 17:11:50 +0200632 hang();
Nikita Kiryanov3ed94782015-11-08 17:11:51 +0200633 }
Nikita Kiryanov0a978812015-11-08 17:11:50 +0200634
Philipp Tomsich58beb6e2018-05-24 17:15:50 +0200635 spl_perform_fixups(&spl_image);
Simon Glasse14f1a22018-11-15 18:44:09 -0700636 if (CONFIG_IS_ENABLED(HANDOFF)) {
637 ret = write_spl_handoff();
638 if (ret)
639 printf(SPL_TPL_PROMPT
640 "SPL hand-off write failed (err=%d)\n", ret);
641 }
Simon Glass4e0a52d2018-11-15 18:43:51 -0700642 if (CONFIG_IS_ENABLED(BLOBLIST)) {
643 ret = bloblist_finish();
644 if (ret)
645 printf("Warning: Failed to finish bloblist (ret=%d)\n",
646 ret);
647 }
Philipp Tomsich58beb6e2018-05-24 17:15:50 +0200648
Vikas Manocha11dd7062017-05-28 12:55:08 -0700649#ifdef CONFIG_CPU_V7M
650 spl_image.entry_point |= 0x1;
651#endif
Simon Schwarze21d2d82011-09-14 15:33:34 -0400652 switch (spl_image.os) {
Aneesh V13a74c12011-07-21 09:10:27 -0400653 case IH_OS_U_BOOT:
654 debug("Jumping to U-Boot\n");
Aneesh V13a74c12011-07-21 09:10:27 -0400655 break;
Philipp Tomsich4ab63e02017-09-13 21:29:35 +0200656#if CONFIG_IS_ENABLED(ATF)
657 case IH_OS_ARM_TRUSTED_FIRMWARE:
658 debug("Jumping to U-Boot via ARM Trusted Firmware\n");
659 spl_invoke_atf(&spl_image);
660 break;
661#endif
Kever Yanga28d42c2018-08-23 17:17:59 +0800662#if CONFIG_IS_ENABLED(OPTEE)
663 case IH_OS_TEE:
664 debug("Jumping to U-Boot via OP-TEE\n");
665 spl_optee_entry(NULL, NULL, spl_image.fdt_addr,
666 (void *)spl_image.entry_point);
667 break;
668#endif
Lukas Auer515b9342019-08-21 21:14:44 +0200669#if CONFIG_IS_ENABLED(OPENSBI)
670 case IH_OS_OPENSBI:
671 debug("Jumping to U-Boot via RISC-V OpenSBI\n");
672 spl_invoke_opensbi(&spl_image);
673 break;
674#endif
Simon Schwarz305bc4c2012-03-15 04:01:38 +0000675#ifdef CONFIG_SPL_OS_BOOT
676 case IH_OS_LINUX:
677 debug("Jumping to Linux\n");
B, Ravi4cf02b12017-04-18 17:27:27 +0530678 spl_fixup_fdt();
Simon Schwarz305bc4c2012-03-15 04:01:38 +0000679 spl_board_prepare_for_linux();
Vikas Manocha62b021c2017-04-07 15:38:13 -0700680 jump_to_image_linux(&spl_image);
Simon Schwarz305bc4c2012-03-15 04:01:38 +0000681#endif
Aneesh V13a74c12011-07-21 09:10:27 -0400682 default:
Tom Rini79178462012-08-27 14:58:28 -0700683 debug("Unsupported OS image.. Jumping nevertheless..\n");
Aneesh V13a74c12011-07-21 09:10:27 -0400684 }
Andy Yan1fa20e4d2017-07-24 17:43:34 +0800685#if CONFIG_VAL(SYS_MALLOC_F_LEN) && !defined(CONFIG_SYS_SPL_MALLOC_SIZE)
Simon Goldschmidt1ddade62018-11-02 21:49:52 +0100686 debug("SPL malloc() used 0x%lx bytes (%ld KB)\n", gd->malloc_ptr,
Simon Glassb2d69942014-11-10 17:16:45 -0700687 gd->malloc_ptr / 1024);
688#endif
Simon Glass01154cb2017-05-22 05:05:35 -0600689#ifdef CONFIG_BOOTSTAGE_STASH
Simon Glass01154cb2017-05-22 05:05:35 -0600690 bootstage_mark_name(BOOTSTAGE_ID_END_SPL, "end_spl");
691 ret = bootstage_stash((void *)CONFIG_BOOTSTAGE_STASH_ADDR,
692 CONFIG_BOOTSTAGE_STASH_SIZE);
693 if (ret)
694 debug("Failed to stash bootstage: err=%d\n", ret);
695#endif
Kever Yangaca62db2017-09-13 18:24:24 +0800696
Kever Yangaca62db2017-09-13 18:24:24 +0800697 debug("loaded - jumping to U-Boot...\n");
Michal Simek7a8465b2016-05-10 07:54:20 +0200698 spl_board_prepare_for_boot();
Allen Martinc67e4852012-10-19 21:08:22 +0000699 jump_to_image_no_args(&spl_image);
Aneesh Vb8e60b92011-07-21 09:10:21 -0400700}
701
Alex Kiernanb09f8922018-04-19 04:32:51 +0000702#ifdef CONFIG_SPL_SERIAL_SUPPORT
Tom Rini31dfba42012-08-22 15:31:05 -0700703/*
704 * This requires UART clocks to be enabled. In order for this to work the
705 * caller must ensure that the gd pointer is valid.
706 */
Aneesh Vb8e60b92011-07-21 09:10:21 -0400707void preloader_console_init(void)
708{
Aneesh Vb8e60b92011-07-21 09:10:21 -0400709 gd->baudrate = CONFIG_BAUDRATE;
710
Aneesh Vb8e60b92011-07-21 09:10:21 -0400711 serial_init(); /* serial communications setup */
712
Ilya Yanok74193c62011-11-01 13:16:03 +0000713 gd->have_console = 1;
714
Simon Glass6324cce2018-11-15 18:43:57 -0700715#if CONFIG_IS_ENABLED(BANNER_PRINT)
Simon Glassdbd3f112018-11-15 18:43:56 -0700716 puts("\nU-Boot " SPL_TPL_NAME " " PLAIN_VERSION " (" U_BOOT_DATE " - "
717 U_BOOT_TIME " " U_BOOT_TZ ")\n");
Anatolij Gustschin6fe74d22018-01-25 18:45:22 +0100718#endif
Tom Rinife3b0c72012-08-13 11:37:56 -0700719#ifdef CONFIG_SPL_DISPLAY_PRINT
720 spl_display_print();
721#endif
Tom Rini09c797b2011-10-04 04:59:23 +0000722}
Alex Kiernanb09f8922018-04-19 04:32:51 +0000723#endif
Simon Glassd8711af2015-03-03 08:03:00 -0700724
725/**
Simon Goldschmidt0b820852019-07-16 22:30:36 +0200726 * This function is called before the stack is changed from initial stack to
727 * relocated stack. It tries to dump the stack size used
728 */
729__weak void spl_relocate_stack_check(void)
730{
731#if CONFIG_IS_ENABLED(SYS_REPORT_STACK_F_USAGE)
732 ulong init_sp = gd->start_addr_sp;
733 ulong stack_bottom = init_sp - CONFIG_VAL(SIZE_LIMIT_PROVIDE_STACK);
734 u8 *ptr = (u8 *)stack_bottom;
735 ulong i;
736
737 for (i = 0; i < CONFIG_VAL(SIZE_LIMIT_PROVIDE_STACK); i++) {
738 if (*ptr != CONFIG_VAL(SYS_STACK_F_CHECK_BYTE))
739 break;
740 ptr++;
741 }
742 printf("SPL initial stack usage: %lu bytes\n",
743 CONFIG_VAL(SIZE_LIMIT_PROVIDE_STACK) - i);
744#endif
745}
746
747/**
Simon Glassd8711af2015-03-03 08:03:00 -0700748 * spl_relocate_stack_gd() - Relocate stack ready for board_init_r() execution
749 *
750 * Sometimes board_init_f() runs with a stack in SRAM but we want to use SDRAM
751 * for the main board_init_r() execution. This is typically because we need
752 * more stack space for things like the MMC sub-system.
753 *
754 * This function calculates the stack position, copies the global_data into
Albert ARIBAUD85260bb2015-11-25 17:56:33 +0100755 * place, sets the new gd (except for ARM, for which setting GD within a C
756 * function may not always work) and returns the new stack position. The
757 * caller is responsible for setting up the sp register and, in the case
758 * of ARM, setting up gd.
759 *
760 * All of this is done using the same layout and alignments as done in
761 * board_init_f_init_reserve() / board_init_f_alloc_reserve().
Simon Glassd8711af2015-03-03 08:03:00 -0700762 *
763 * @return new stack location, or 0 to use the same stack
764 */
765ulong spl_relocate_stack_gd(void)
766{
767#ifdef CONFIG_SPL_STACK_R
768 gd_t *new_gd;
Albert ARIBAUD85260bb2015-11-25 17:56:33 +0100769 ulong ptr = CONFIG_SPL_STACK_R_ADDR;
Simon Glassd8711af2015-03-03 08:03:00 -0700770
Simon Goldschmidt0b820852019-07-16 22:30:36 +0200771 if (CONFIG_IS_ENABLED(SYS_REPORT_STACK_F_USAGE))
772 spl_relocate_stack_check();
773
Philipp Tomsich10139352017-07-28 11:06:03 +0200774#if defined(CONFIG_SPL_SYS_MALLOC_SIMPLE) && CONFIG_VAL(SYS_MALLOC_F_LEN)
Hans de Goede8f280382015-09-13 15:04:17 +0200775 if (CONFIG_SPL_STACK_R_MALLOC_SIMPLE_LEN) {
Simon Goldschmidtb3672af2019-02-26 22:27:52 +0100776 debug("SPL malloc() before relocation used 0x%lx bytes (%ld KB)\n",
777 gd->malloc_ptr, gd->malloc_ptr / 1024);
Hans de Goede8f280382015-09-13 15:04:17 +0200778 ptr -= CONFIG_SPL_STACK_R_MALLOC_SIMPLE_LEN;
779 gd->malloc_base = ptr;
780 gd->malloc_limit = CONFIG_SPL_STACK_R_MALLOC_SIMPLE_LEN;
781 gd->malloc_ptr = 0;
782 }
783#endif
Albert ARIBAUD85260bb2015-11-25 17:56:33 +0100784 /* Get stack position: use 8-byte alignment for ABI compliance */
785 ptr = CONFIG_SPL_STACK_R_ADDR - roundup(sizeof(gd_t),16);
786 new_gd = (gd_t *)ptr;
787 memcpy(new_gd, (void *)gd, sizeof(gd_t));
Simon Glass1b0deee2016-11-13 14:21:58 -0700788#if CONFIG_IS_ENABLED(DM)
789 dm_fixup_for_gd_move(new_gd);
790#endif
Lukas Auer2a2a9252019-08-21 21:14:46 +0200791#if !defined(CONFIG_ARM) && !defined(CONFIG_RISCV)
Albert ARIBAUD85260bb2015-11-25 17:56:33 +0100792 gd = new_gd;
793#endif
Simon Glassd8711af2015-03-03 08:03:00 -0700794 return ptr;
795#else
796 return 0;
797#endif
798}