blob: d5e3f680f4cb61bfa054684db5fd657425436c2c [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 Glass11516512014-11-10 17:16:46 -070012#include <dm.h>
Simon Glassb0edea32018-11-15 18:44:09 -070013#include <handoff.h>
Tom Rini47f7bca2012-08-13 12:03:19 -070014#include <spl.h>
Aneesh Vbcae7212011-07-21 09:10:21 -040015#include <asm/u-boot.h>
Simon Schwarzbb085b82011-09-14 15:29:26 -040016#include <nand.h>
Aneesh V8cf686e2011-07-21 09:10:27 -040017#include <fat.h>
Simon Glassefb21722011-10-10 08:55:19 +000018#include <version.h>
Aneesh V8cf686e2011-07-21 09:10:27 -040019#include <image.h>
Aneesh V2d01dd92011-10-21 12:29:34 -040020#include <malloc.h>
Simon Glass11516512014-11-10 17:16:46 -070021#include <dm/root.h>
Andreas Müller761ca312012-01-04 15:26:24 +000022#include <linux/compiler.h>
B, Ravi6e7585b2017-04-18 17:27:27 +053023#include <fdt_support.h>
Lukasz Majewskia8be2492018-05-02 16:10:54 +020024#include <bootcount.h>
Stefan Roese06985282019-04-11 15:58:44 +020025#include <wdt.h>
Aneesh Vbcae7212011-07-21 09:10:21 -040026
27DECLARE_GLOBAL_DATA_PTR;
28
Stefan Roese3c6f8a02012-08-28 10:50:59 +020029#ifndef CONFIG_SYS_UBOOT_START
30#define CONFIG_SYS_UBOOT_START CONFIG_SYS_TEXT_BASE
31#endif
Stefano Babicae83d882012-08-23 12:46:16 +020032#ifndef CONFIG_SYS_MONITOR_LEN
Andreas Bießmanne76caa62014-10-25 02:54:55 +020033/* Unknown U-Boot size, let's assume it will not be more than 200 KB */
Stefano Babicae83d882012-08-23 12:46:16 +020034#define CONFIG_SYS_MONITOR_LEN (200 * 1024)
35#endif
36
Tom Rini47f7bca2012-08-13 12:03:19 -070037u32 *boot_params_ptr = NULL;
Simon Schwarz9ea5c6e2011-09-14 15:33:34 -040038
Simon Glass8bee2d22017-11-13 18:55:03 -070039/* See spl.h for information about this */
Simon Glassdbf6be92018-08-01 15:22:42 -060040binman_sym_declare(ulong, u_boot_any, image_pos);
Simon Glass8bee2d22017-11-13 18:55:03 -070041
Tom Rini6507f132012-08-22 15:31:05 -070042/* Define board data structure */
Aneesh Vbcae7212011-07-21 09:10:21 -040043static bd_t bdata __attribute__ ((section(".data")));
44
Simon Schwarz379c19a2012-03-15 04:01:38 +000045/*
Heiko Schocher496c5482016-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 Glassb0edea32018-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 Schocher496c5482016-06-07 08:31:20 +020058/*
Simon Schwarz379c19a2012-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 Glassd6330062018-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 Schwarz379c19a2012-03-15 04:01:38 +000074 return 1;
75}
Ladislav Michl431889d2016-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 Schwarz379c19a2012-03-15 04:01:38 +000085#endif
86
Philipp Tomsichde5dd4c2018-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, Ravi6e7585b2017-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 Glassd6330062018-11-15 18:43:56 -0700107 printf(SPL_TPL_PROMPT "fdt_shrink_to_minimum err - %d\n", err);
B, Ravi6e7585b2017-04-18 17:27:27 +0530108 return;
109 }
110
111 err = arch_fixup_fdt(fdt_blob);
112 if (err) {
Simon Glassd6330062018-11-15 18:43:56 -0700113 printf(SPL_TPL_PROMPT "arch_fixup_fdt err - %d\n", err);
B, Ravi6e7585b2017-04-18 17:27:27 +0530114 return;
115 }
116#endif
117}
118
Stefan Roeseea8256f2012-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 Simek3a3b9142016-05-10 07:54:20 +0200129__weak void spl_board_prepare_for_boot(void)
130{
131 /* Nothing to do! */
132}
133
Marek Vasut04ce5422018-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 Glassd95ceb92016-09-24 18:19:52 -0600139void spl_set_header_raw_uboot(struct spl_image_info *spl_image)
Heiko Schocher0c3117b2014-10-31 08:31:00 +0100140{
Simon Glassdbf6be92018-08-01 15:22:42 -0600141 ulong u_boot_pos = binman_sym(ulong, u_boot_any, image_pos);
Simon Glass8bee2d22017-11-13 18:55:03 -0700142
Simon Glassd95ceb92016-09-24 18:19:52 -0600143 spl_image->size = CONFIG_SYS_MONITOR_LEN;
Miquel Raynal55fe0e22018-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 Glass8bee2d22017-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 Glassd95ceb92016-09-24 18:19:52 -0600158 spl_image->os = IH_OS_U_BOOT;
159 spl_image->name = "U-Boot";
Heiko Schocher0c3117b2014-10-31 08:31:00 +0100160}
161
Marek Vasut8a9dc162018-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 Glassd6330062018-11-15 18:43:56 -0700192 debug(SPL_TPL_PROMPT "payload image: %32s load addr: 0x%lx size: %d\n",
Simon Goldschmidt30c07402018-11-02 21:49:52 +0100193 spl_image->name, spl_image->load_addr, spl_image->size);
Marek Vasut8a9dc162018-05-13 00:23:17 +0200194
195#ifdef CONFIG_SPL_FIT_SIGNATURE
196 images.verify = 1;
197#endif
Marek Vasuta9a82712019-05-07 21:17:02 +0200198 ret = fit_image_load(&images, (ulong)header,
Marek Vasut8a9dc162018-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 Vasuta9a82712019-05-07 21:17:02 +0200202 if (ret >= 0)
203 spl_image->fdt_addr = (void *)dt_data;
Marek Vasut8a9dc162018-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 Glass71316c12016-09-24 18:19:53 -0600232int spl_parse_image_header(struct spl_image_info *spl_image,
233 const struct image_header *header)
Aneesh V8cf686e2011-07-21 09:10:27 -0400234{
Marek Vasut8a9dc162018-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 Roese77552b02012-08-27 12:50:57 +0200241 if (image_get_magic(header) == IH_MAGIC) {
Andrew F. Davis722a6b12017-02-16 11:18:39 -0600242#ifdef CONFIG_SPL_LEGACY_IMAGE_SUPPORT
243 u32 header_size = sizeof(struct image_header);
244
Simon Goldschmidtdae5c2d2019-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 Glass71316c12016-09-24 18:19:53 -0600253 if (spl_image->flags & SPL_COPY_PAYLOAD_ONLY) {
Stefan Roese022b4972012-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 Glass71316c12016-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 Roese022b4972012-08-27 12:50:58 +0200262 } else {
Simon Glass71316c12016-09-24 18:19:53 -0600263 spl_image->entry_point = image_get_load(header);
Stefan Roese022b4972012-08-27 12:50:58 +0200264 /* Load including the header */
Simon Glass71316c12016-09-24 18:19:53 -0600265 spl_image->load_addr = spl_image->entry_point -
Stefan Roese022b4972012-08-27 12:50:58 +0200266 header_size;
Simon Glass71316c12016-09-24 18:19:53 -0600267 spl_image->size = image_get_data_size(header) +
Stefan Roese022b4972012-08-27 12:50:58 +0200268 header_size;
269 }
Simon Goldschmidtdae5c2d2019-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 Glass71316c12016-09-24 18:19:53 -0600277 spl_image->os = image_get_os(header);
278 spl_image->name = image_get_name(header);
Simon Glassd6330062018-11-15 18:43:56 -0700279 debug(SPL_TPL_PROMPT
280 "payload image: %32s load addr: 0x%lx size: %d\n",
Simon Goldschmidt30c07402018-11-02 21:49:52 +0100281 spl_image->name, spl_image->load_addr, spl_image->size);
Andrew F. Davis722a6b12017-02-16 11:18:39 -0600282#else
283 /* LEGACY image not supported */
Anatolij Gustschin2d2531b2017-08-01 16:17:12 +0200284 debug("Legacy boot image support not enabled, proceeding to other boot methods\n");
Andrew F. Davis722a6b12017-02-16 11:18:39 -0600285 return -EINVAL;
286#endif
Aneesh V8cf686e2011-07-21 09:10:27 -0400287 } else {
Albert ARIBAUD \(3ADEV\)8c80eb32015-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 Kocialkowski85a37722016-08-24 20:04:42 +0200298#endif
299
Ladislav Michl431889d2016-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 Glass71316c12016-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 Glassd6330062018-11-15 18:43:56 -0700309 debug(SPL_TPL_PROMPT
310 "payload zImage, load addr: 0x%lx size: %d\n",
Simon Glass71316c12016-09-24 18:19:53 -0600311 spl_image->load_addr, spl_image->size);
Ladislav Michl431889d2016-07-12 20:28:14 +0200312 return 0;
313 }
314#endif
Paul Kocialkowski85a37722016-08-24 20:04:42 +0200315
Andrew F. Davis24eb39b2017-02-16 11:18:38 -0600316#ifdef CONFIG_SPL_RAW_IMAGE_SUPPORT
Aneesh V8cf686e2011-07-21 09:10:27 -0400317 /* Signature not found - assume u-boot.bin */
Tom Rini026b2fe2012-08-14 12:06:43 -0700318 debug("mkimage signature not found - ih_magic = %x\n",
Aneesh V8cf686e2011-07-21 09:10:27 -0400319 header->ih_magic);
Simon Glass71316c12016-09-24 18:19:53 -0600320 spl_set_header_raw_uboot(spl_image);
Andrew F. Davis24eb39b2017-02-16 11:18:38 -0600321#else
322 /* RAW image not supported, proceed to other boot methods. */
Anatolij Gustschin2d2531b2017-08-01 16:17:12 +0200323 debug("Raw boot image support not enabled, proceeding to other boot methods\n");
Andrew F. Davis24eb39b2017-02-16 11:18:38 -0600324 return -EINVAL;
Albert ARIBAUD \(3ADEV\)8c80eb32015-03-31 11:40:50 +0200325#endif
Aneesh V8cf686e2011-07-21 09:10:27 -0400326 }
Andrew F. Davis24eb39b2017-02-16 11:18:38 -0600327
Marek Vasut7e0f2262016-04-29 00:44:54 +0200328 return 0;
Aneesh V8cf686e2011-07-21 09:10:27 -0400329}
330
Allen Martina759f1e2012-10-19 21:08:22 +0000331__weak void __noreturn jump_to_image_no_args(struct spl_image_info *spl_image)
Aneesh V8cf686e2011-07-21 09:10:27 -0400332{
SRICHARAN R4a0eb752013-04-24 00:41:24 +0000333 typedef void __noreturn (*image_entry_noargs_t)(void);
334
Aneesh V8cf686e2011-07-21 09:10:27 -0400335 image_entry_noargs_t image_entry =
Andre Przywara11e14792017-01-02 11:48:31 +0000336 (image_entry_noargs_t)spl_image->entry_point;
Aneesh V8cf686e2011-07-21 09:10:27 -0400337
Simon Goldschmidt30c07402018-11-02 21:49:52 +0100338 debug("image entry point: 0x%lx\n", spl_image->entry_point);
SRICHARAN R4a0eb752013-04-24 00:41:24 +0000339 image_entry();
Aneesh V8cf686e2011-07-21 09:10:27 -0400340}
341
Simon Glassb0edea32018-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
359static int write_spl_handoff(void)
360{
361 struct spl_handoff *ho;
362
363 ho = bloblist_find(BLOBLISTT_SPL_HANDOFF, sizeof(struct spl_handoff));
364 if (!ho)
365 return -ENOENT;
366 handoff_save_dram(ho);
367#ifdef CONFIG_SANDBOX
368 ho->arch.magic = TEST_HANDOFF_MAGIC;
369#endif
370 debug(SPL_TPL_PROMPT "Wrote SPL handoff\n");
371
372 return 0;
373}
374#else
375static inline int setup_spl_handoff(void) { return 0; }
376static inline int write_spl_handoff(void) { return 0; }
377
378#endif /* HANDOFF */
379
Eddie Cai340f4182017-03-15 08:43:28 -0600380static int spl_common_init(bool setup_malloc)
Aneesh Vbcae7212011-07-21 09:10:21 -0400381{
Simon Glassf3d46bd2015-02-27 22:06:42 -0700382 int ret;
383
Andy Yanf1896c42017-07-24 17:43:34 +0800384#if CONFIG_VAL(SYS_MALLOC_F_LEN)
Eddie Cai340f4182017-03-15 08:43:28 -0600385 if (setup_malloc) {
Marek Vasut94b9e222016-05-25 02:14:56 +0200386#ifdef CONFIG_MALLOC_F_ADDR
Eddie Cai340f4182017-03-15 08:43:28 -0600387 gd->malloc_base = CONFIG_MALLOC_F_ADDR;
Marek Vasut94b9e222016-05-25 02:14:56 +0200388#endif
Andy Yanf1896c42017-07-24 17:43:34 +0800389 gd->malloc_limit = CONFIG_VAL(SYS_MALLOC_F_LEN);
Eddie Cai340f4182017-03-15 08:43:28 -0600390 gd->malloc_ptr = 0;
391 }
Tom Rini24dafad2012-08-13 14:13:07 -0700392#endif
Simon Glass824bb1b2017-05-22 05:05:35 -0600393 ret = bootstage_init(true);
394 if (ret) {
395 debug("%s: Failed to set up bootstage: ret=%d\n", __func__,
396 ret);
397 return ret;
398 }
399 bootstage_mark_name(BOOTSTAGE_ID_START_SPL, "spl");
Simon Glass4d8d3052018-11-15 18:43:49 -0700400#if CONFIG_IS_ENABLED(LOG)
401 ret = log_init();
402 if (ret) {
403 debug("%s: Failed to set up logging\n", __func__);
404 return ret;
405 }
406#endif
Simon Glasse945a722018-11-15 18:43:51 -0700407 if (CONFIG_IS_ENABLED(BLOBLIST)) {
408 ret = bloblist_init();
409 if (ret) {
410 debug("%s: Failed to set up bloblist: ret=%d\n",
411 __func__, ret);
412 return ret;
413 }
414 }
Simon Glassb0edea32018-11-15 18:44:09 -0700415 if (CONFIG_IS_ENABLED(HANDOFF)) {
416 int ret;
417
418 ret = setup_spl_handoff();
419 if (ret) {
420 puts(SPL_TPL_PROMPT "Cannot set up SPL handoff\n");
421 hang();
422 }
423 }
Simon Glassd223e0a2016-07-04 11:57:56 -0600424 if (CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)) {
Simon Glassf3d46bd2015-02-27 22:06:42 -0700425 ret = fdtdec_setup();
426 if (ret) {
427 debug("fdtdec_setup() returned error %d\n", ret);
Simon Glass070d00b2015-06-23 15:39:10 -0600428 return ret;
Simon Glassf3d46bd2015-02-27 22:06:42 -0700429 }
430 }
Philipp Tomsichf1c6e192017-06-30 19:02:53 +0200431 if (CONFIG_IS_ENABLED(DM)) {
Simon Glass824bb1b2017-05-22 05:05:35 -0600432 bootstage_start(BOOTSTATE_ID_ACCUM_DM_SPL, "dm_spl");
Tom Rini7f73ca42017-01-14 12:20:23 -0500433 /* With CONFIG_SPL_OF_PLATDATA, bring in all devices */
Simon Glass7d23b9c2016-07-04 11:58:14 -0600434 ret = dm_init_and_scan(!CONFIG_IS_ENABLED(OF_PLATDATA));
Simon Glass824bb1b2017-05-22 05:05:35 -0600435 bootstage_accum(BOOTSTATE_ID_ACCUM_DM_SPL);
Simon Glassf3d46bd2015-02-27 22:06:42 -0700436 if (ret) {
437 debug("dm_init_and_scan() returned error %d\n", ret);
Simon Glass070d00b2015-06-23 15:39:10 -0600438 return ret;
Simon Glassf3d46bd2015-02-27 22:06:42 -0700439 }
440 }
Eddie Cai340f4182017-03-15 08:43:28 -0600441
442 return 0;
443}
444
York Sund1fc0a32017-09-28 08:42:10 -0700445void spl_set_bd(void)
446{
Simon Glassc21f4072018-11-15 18:43:58 -0700447 /*
448 * NOTE: On some platforms (e.g. x86) bdata may be in flash and not
449 * writeable.
450 */
York Sund1fc0a32017-09-28 08:42:10 -0700451 if (!gd->bd)
452 gd->bd = &bdata;
453}
454
Eddie Cai340f4182017-03-15 08:43:28 -0600455int spl_early_init(void)
456{
457 int ret;
458
Simon Goldschmidt94cb9862018-08-13 11:24:05 +0200459 debug("%s\n", __func__);
460
Eddie Cai340f4182017-03-15 08:43:28 -0600461 ret = spl_common_init(true);
462 if (ret)
463 return ret;
464 gd->flags |= GD_FLG_SPL_EARLY_INIT;
465
466 return 0;
467}
468
469int spl_init(void)
470{
471 int ret;
Tom Rinicf334ed2017-03-20 14:19:27 -0400472 bool setup_malloc = !(IS_ENABLED(CONFIG_SPL_STACK_R) &&
473 IS_ENABLED(CONFIG_SPL_SYS_MALLOC_SIMPLE));
Eddie Cai340f4182017-03-15 08:43:28 -0600474
Simon Goldschmidt94cb9862018-08-13 11:24:05 +0200475 debug("%s\n", __func__);
476
Eddie Cai340f4182017-03-15 08:43:28 -0600477 if (!(gd->flags & GD_FLG_SPL_EARLY_INIT)) {
Tom Rinicf334ed2017-03-20 14:19:27 -0400478 ret = spl_common_init(setup_malloc);
Eddie Cai340f4182017-03-15 08:43:28 -0600479 if (ret)
480 return ret;
481 }
Simon Glass070d00b2015-06-23 15:39:10 -0600482 gd->flags |= GD_FLG_SPL_INIT;
Aneesh V2d01dd92011-10-21 12:29:34 -0400483
Simon Glass070d00b2015-06-23 15:39:10 -0600484 return 0;
485}
486
Nikita Kiryanovf101e4b2015-11-08 17:11:51 +0200487#ifndef BOOT_DEVICE_NONE
488#define BOOT_DEVICE_NONE 0xdeadbeef
489#endif
490
Nikita Kiryanovf101e4b2015-11-08 17:11:51 +0200491__weak void board_boot_order(u32 *spl_boot_list)
492{
493 spl_boot_list[0] = spl_boot_device();
494}
495
Simon Glassa0a80292016-09-24 18:19:58 -0600496static struct spl_image_loader *spl_ll_find_loader(uint boot_device)
497{
498 struct spl_image_loader *drv =
499 ll_entry_start(struct spl_image_loader, spl_image_loader);
500 const int n_ents =
501 ll_entry_count(struct spl_image_loader, spl_image_loader);
502 struct spl_image_loader *entry;
503
504 for (entry = drv; entry != drv + n_ents; entry++) {
505 if (boot_device == entry->boot_device)
506 return entry;
507 }
508
509 /* Not found */
510 return NULL;
511}
512
Simon Glass29d357d2016-11-30 15:30:52 -0700513static int spl_load_image(struct spl_image_info *spl_image,
514 struct spl_image_loader *loader)
Nikita Kiryanov5211b872015-11-08 17:11:50 +0200515{
Simon Goldschmidtdae5c2d2019-02-10 21:34:37 +0100516 int ret;
Simon Glassecdfd692016-09-24 18:19:57 -0600517 struct spl_boot_device bootdev;
518
Simon Glass29d357d2016-11-30 15:30:52 -0700519 bootdev.boot_device = loader->boot_device;
Simon Glassecdfd692016-09-24 18:19:57 -0600520 bootdev.boot_device_name = NULL;
521
Simon Goldschmidtdae5c2d2019-02-10 21:34:37 +0100522 ret = loader->load_image(spl_image, &bootdev);
523#ifdef CONFIG_SPL_LEGACY_IMAGE_CRC_CHECK
524 if (!ret && spl_image->dcrc_length) {
525 /* check data crc */
526 ulong dcrc = crc32_wd(0, (unsigned char *)spl_image->dcrc_data,
527 spl_image->dcrc_length, CHUNKSZ_CRC32);
528 if (dcrc != spl_image->dcrc) {
529 puts("SPL: Image data CRC check failed!\n");
530 ret = -EINVAL;
531 }
532 }
533#endif
534 return ret;
Simon Glass540bfe72016-11-30 15:30:51 -0700535}
536
537/**
Miquel Raynalfd4ee982019-05-07 14:18:43 +0200538 * boot_from_devices() - Try loading a booting U-Boot from a list of devices
Simon Glass540bfe72016-11-30 15:30:51 -0700539 *
540 * @spl_image: Place to put the image details if successful
541 * @spl_boot_list: List of boot devices to try
542 * @count: Number of elements in spl_boot_list
543 * @return 0 if OK, -ve on error
544 */
545static int boot_from_devices(struct spl_image_info *spl_image,
546 u32 spl_boot_list[], int count)
547{
548 int i;
549
550 for (i = 0; i < count && spl_boot_list[i] != BOOT_DEVICE_NONE; i++) {
551 struct spl_image_loader *loader;
552
Simon Glass540bfe72016-11-30 15:30:51 -0700553 loader = spl_ll_find_loader(spl_boot_list[i]);
Nikita Kiryanov5211b872015-11-08 17:11:50 +0200554#if defined(CONFIG_SPL_SERIAL_SUPPORT) && defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
Simon Glass2acf35d2016-11-30 15:30:53 -0700555 if (loader)
Andrew F. Daviscf947da2017-01-12 10:19:55 -0600556 printf("Trying to boot from %s\n", loader->name);
Simon Glass2acf35d2016-11-30 15:30:53 -0700557 else
Simon Glassd6330062018-11-15 18:43:56 -0700558 puts(SPL_TPL_PROMPT "Unsupported Boot Device!\n");
Nikita Kiryanov5211b872015-11-08 17:11:50 +0200559#endif
Philipp Tomsichde5dd4c2018-05-24 17:15:50 +0200560 if (loader && !spl_load_image(spl_image, loader)) {
561 spl_image->boot_device = spl_boot_list[i];
Simon Glass540bfe72016-11-30 15:30:51 -0700562 return 0;
Philipp Tomsichde5dd4c2018-05-24 17:15:50 +0200563 }
Simon Glass540bfe72016-11-30 15:30:51 -0700564 }
565
Simon Glass97d9df02016-09-24 18:20:12 -0600566 return -ENODEV;
Nikita Kiryanov5211b872015-11-08 17:11:50 +0200567}
568
Simon Glass070d00b2015-06-23 15:39:10 -0600569void board_init_r(gd_t *dummy1, ulong dummy2)
570{
Simon Glassd32b2d12016-09-24 18:20:17 -0600571 u32 spl_boot_list[] = {
572 BOOT_DEVICE_NONE,
573 BOOT_DEVICE_NONE,
574 BOOT_DEVICE_NONE,
575 BOOT_DEVICE_NONE,
576 BOOT_DEVICE_NONE,
577 };
578 struct spl_image_info spl_image;
Simon Glasse945a722018-11-15 18:43:51 -0700579 int ret;
Simon Glass070d00b2015-06-23 15:39:10 -0600580
Simon Glassd6330062018-11-15 18:43:56 -0700581 debug(">>" SPL_TPL_PROMPT "board_init_r()\n");
York Sund1fc0a32017-09-28 08:42:10 -0700582
583 spl_set_bd();
584
Simon Glass070d00b2015-06-23 15:39:10 -0600585#if defined(CONFIG_SYS_SPL_MALLOC_START)
586 mem_malloc_init(CONFIG_SYS_SPL_MALLOC_START,
587 CONFIG_SYS_SPL_MALLOC_SIZE);
588 gd->flags |= GD_FLG_FULL_MALLOC_INIT;
589#endif
590 if (!(gd->flags & GD_FLG_SPL_INIT)) {
591 if (spl_init())
592 hang();
593 }
Anatolij Gustschinf9d42d82017-08-28 17:46:33 +0200594#if !defined(CONFIG_PPC) && !defined(CONFIG_ARCH_MX6)
Stefan Roeseea8256f2012-08-23 08:34:21 +0200595 /*
596 * timer_init() does not exist on PPC systems. The timer is initialized
597 * and enabled (decrementer) in interrupt_init() here.
598 */
Ilya Yanok4063c772012-09-17 10:26:26 +0000599 timer_init();
Stefan Roeseea8256f2012-08-23 08:34:21 +0200600#endif
Ilya Yanok4063c772012-09-17 10:26:26 +0000601
Kever Yangaf2f4422018-01-20 18:00:26 +0800602#if CONFIG_IS_ENABLED(BOARD_INIT)
Tom Riniee08a822011-11-23 05:13:06 +0000603 spl_board_init();
604#endif
605
Stefan Roese06985282019-04-11 15:58:44 +0200606#if defined(CONFIG_SPL_WATCHDOG_SUPPORT) && defined(CONFIG_WDT)
607 initr_watchdog();
608#endif
609
Simon Glassb0edea32018-11-15 18:44:09 -0700610 if (IS_ENABLED(CONFIG_SPL_OS_BOOT) || CONFIG_IS_ENABLED(HANDOFF))
611 dram_init_banksize();
612
Lukasz Majewskia8be2492018-05-02 16:10:54 +0200613 bootcount_inc();
614
Simon Glassd32b2d12016-09-24 18:20:17 -0600615 memset(&spl_image, '\0', sizeof(spl_image));
Vikas Manocha5bf52502017-04-07 15:38:13 -0700616#ifdef CONFIG_SYS_SPL_ARGS_ADDR
617 spl_image.arg = (void *)CONFIG_SYS_SPL_ARGS_ADDR;
618#endif
Philipp Tomsichde5dd4c2018-05-24 17:15:50 +0200619 spl_image.boot_device = BOOT_DEVICE_NONE;
Nikita Kiryanovf101e4b2015-11-08 17:11:51 +0200620 board_boot_order(spl_boot_list);
Nikita Kiryanovf101e4b2015-11-08 17:11:51 +0200621
Simon Glass540bfe72016-11-30 15:30:51 -0700622 if (boot_from_devices(&spl_image, spl_boot_list,
623 ARRAY_SIZE(spl_boot_list))) {
Simon Glassd6330062018-11-15 18:43:56 -0700624 puts(SPL_TPL_PROMPT "failed to boot from all boot devices\n");
Aneesh V8cf686e2011-07-21 09:10:27 -0400625 hang();
Nikita Kiryanovf101e4b2015-11-08 17:11:51 +0200626 }
Aneesh V8cf686e2011-07-21 09:10:27 -0400627
Philipp Tomsichde5dd4c2018-05-24 17:15:50 +0200628 spl_perform_fixups(&spl_image);
Simon Glassb0edea32018-11-15 18:44:09 -0700629 if (CONFIG_IS_ENABLED(HANDOFF)) {
630 ret = write_spl_handoff();
631 if (ret)
632 printf(SPL_TPL_PROMPT
633 "SPL hand-off write failed (err=%d)\n", ret);
634 }
Simon Glasse945a722018-11-15 18:43:51 -0700635 if (CONFIG_IS_ENABLED(BLOBLIST)) {
636 ret = bloblist_finish();
637 if (ret)
638 printf("Warning: Failed to finish bloblist (ret=%d)\n",
639 ret);
640 }
Philipp Tomsichde5dd4c2018-05-24 17:15:50 +0200641
Vikas Manocha6bcdd662017-05-28 12:55:08 -0700642#ifdef CONFIG_CPU_V7M
643 spl_image.entry_point |= 0x1;
644#endif
Simon Schwarz9ea5c6e2011-09-14 15:33:34 -0400645 switch (spl_image.os) {
Aneesh V8cf686e2011-07-21 09:10:27 -0400646 case IH_OS_U_BOOT:
647 debug("Jumping to U-Boot\n");
Aneesh V8cf686e2011-07-21 09:10:27 -0400648 break;
Philipp Tomsich1d379092017-09-13 21:29:35 +0200649#if CONFIG_IS_ENABLED(ATF)
650 case IH_OS_ARM_TRUSTED_FIRMWARE:
651 debug("Jumping to U-Boot via ARM Trusted Firmware\n");
652 spl_invoke_atf(&spl_image);
653 break;
654#endif
Kever Yang70fe2872018-08-23 17:17:59 +0800655#if CONFIG_IS_ENABLED(OPTEE)
656 case IH_OS_TEE:
657 debug("Jumping to U-Boot via OP-TEE\n");
658 spl_optee_entry(NULL, NULL, spl_image.fdt_addr,
659 (void *)spl_image.entry_point);
660 break;
661#endif
Simon Schwarz379c19a2012-03-15 04:01:38 +0000662#ifdef CONFIG_SPL_OS_BOOT
663 case IH_OS_LINUX:
664 debug("Jumping to Linux\n");
B, Ravi6e7585b2017-04-18 17:27:27 +0530665 spl_fixup_fdt();
Simon Schwarz379c19a2012-03-15 04:01:38 +0000666 spl_board_prepare_for_linux();
Vikas Manocha5bf52502017-04-07 15:38:13 -0700667 jump_to_image_linux(&spl_image);
Simon Schwarz379c19a2012-03-15 04:01:38 +0000668#endif
Aneesh V8cf686e2011-07-21 09:10:27 -0400669 default:
Tom Rini42120982012-08-27 14:58:28 -0700670 debug("Unsupported OS image.. Jumping nevertheless..\n");
Aneesh V8cf686e2011-07-21 09:10:27 -0400671 }
Andy Yanf1896c42017-07-24 17:43:34 +0800672#if CONFIG_VAL(SYS_MALLOC_F_LEN) && !defined(CONFIG_SYS_SPL_MALLOC_SIZE)
Simon Goldschmidt30c07402018-11-02 21:49:52 +0100673 debug("SPL malloc() used 0x%lx bytes (%ld KB)\n", gd->malloc_ptr,
Simon Glassfb4f5e72014-11-10 17:16:45 -0700674 gd->malloc_ptr / 1024);
675#endif
Simon Glass824bb1b2017-05-22 05:05:35 -0600676#ifdef CONFIG_BOOTSTAGE_STASH
Simon Glass824bb1b2017-05-22 05:05:35 -0600677 bootstage_mark_name(BOOTSTAGE_ID_END_SPL, "end_spl");
678 ret = bootstage_stash((void *)CONFIG_BOOTSTAGE_STASH_ADDR,
679 CONFIG_BOOTSTAGE_STASH_SIZE);
680 if (ret)
681 debug("Failed to stash bootstage: err=%d\n", ret);
682#endif
Kever Yanga8c51122017-09-13 18:24:24 +0800683
Kever Yanga8c51122017-09-13 18:24:24 +0800684 debug("loaded - jumping to U-Boot...\n");
Michal Simek3a3b9142016-05-10 07:54:20 +0200685 spl_board_prepare_for_boot();
Allen Martina759f1e2012-10-19 21:08:22 +0000686 jump_to_image_no_args(&spl_image);
Aneesh Vbcae7212011-07-21 09:10:21 -0400687}
688
Alex Kiernan117a0e02018-04-19 04:32:51 +0000689#ifdef CONFIG_SPL_SERIAL_SUPPORT
Tom Rini6507f132012-08-22 15:31:05 -0700690/*
691 * This requires UART clocks to be enabled. In order for this to work the
692 * caller must ensure that the gd pointer is valid.
693 */
Aneesh Vbcae7212011-07-21 09:10:21 -0400694void preloader_console_init(void)
695{
Aneesh Vbcae7212011-07-21 09:10:21 -0400696 gd->baudrate = CONFIG_BAUDRATE;
697
Aneesh Vbcae7212011-07-21 09:10:21 -0400698 serial_init(); /* serial communications setup */
699
Ilya Yanokb88befa2011-11-01 13:16:03 +0000700 gd->have_console = 1;
701
Simon Glassaedc08b2018-11-15 18:43:57 -0700702#if CONFIG_IS_ENABLED(BANNER_PRINT)
Simon Glassd6330062018-11-15 18:43:56 -0700703 puts("\nU-Boot " SPL_TPL_NAME " " PLAIN_VERSION " (" U_BOOT_DATE " - "
704 U_BOOT_TIME " " U_BOOT_TZ ")\n");
Anatolij Gustschin0292bc02018-01-25 18:45:22 +0100705#endif
Tom Rini861a86f2012-08-13 11:37:56 -0700706#ifdef CONFIG_SPL_DISPLAY_PRINT
707 spl_display_print();
708#endif
Tom Rinicc3f7052011-10-04 04:59:23 +0000709}
Alex Kiernan117a0e02018-04-19 04:32:51 +0000710#endif
Simon Glassdb910352015-03-03 08:03:00 -0700711
712/**
713 * spl_relocate_stack_gd() - Relocate stack ready for board_init_r() execution
714 *
715 * Sometimes board_init_f() runs with a stack in SRAM but we want to use SDRAM
716 * for the main board_init_r() execution. This is typically because we need
717 * more stack space for things like the MMC sub-system.
718 *
719 * This function calculates the stack position, copies the global_data into
Albert ARIBAUDadc421e2015-11-25 17:56:33 +0100720 * place, sets the new gd (except for ARM, for which setting GD within a C
721 * function may not always work) and returns the new stack position. The
722 * caller is responsible for setting up the sp register and, in the case
723 * of ARM, setting up gd.
724 *
725 * All of this is done using the same layout and alignments as done in
726 * board_init_f_init_reserve() / board_init_f_alloc_reserve().
Simon Glassdb910352015-03-03 08:03:00 -0700727 *
728 * @return new stack location, or 0 to use the same stack
729 */
730ulong spl_relocate_stack_gd(void)
731{
732#ifdef CONFIG_SPL_STACK_R
733 gd_t *new_gd;
Albert ARIBAUDadc421e2015-11-25 17:56:33 +0100734 ulong ptr = CONFIG_SPL_STACK_R_ADDR;
Simon Glassdb910352015-03-03 08:03:00 -0700735
Philipp Tomsichae2cee22017-07-28 11:06:03 +0200736#if defined(CONFIG_SPL_SYS_MALLOC_SIMPLE) && CONFIG_VAL(SYS_MALLOC_F_LEN)
Hans de Goededcfcb8d2015-09-13 15:04:17 +0200737 if (CONFIG_SPL_STACK_R_MALLOC_SIMPLE_LEN) {
Simon Goldschmidt438dcab2019-02-26 22:27:52 +0100738 debug("SPL malloc() before relocation used 0x%lx bytes (%ld KB)\n",
739 gd->malloc_ptr, gd->malloc_ptr / 1024);
Hans de Goededcfcb8d2015-09-13 15:04:17 +0200740 ptr -= CONFIG_SPL_STACK_R_MALLOC_SIMPLE_LEN;
741 gd->malloc_base = ptr;
742 gd->malloc_limit = CONFIG_SPL_STACK_R_MALLOC_SIMPLE_LEN;
743 gd->malloc_ptr = 0;
744 }
745#endif
Albert ARIBAUDadc421e2015-11-25 17:56:33 +0100746 /* Get stack position: use 8-byte alignment for ABI compliance */
747 ptr = CONFIG_SPL_STACK_R_ADDR - roundup(sizeof(gd_t),16);
748 new_gd = (gd_t *)ptr;
749 memcpy(new_gd, (void *)gd, sizeof(gd_t));
Simon Glass2f11cd92016-11-13 14:21:58 -0700750#if CONFIG_IS_ENABLED(DM)
751 dm_fixup_for_gd_move(new_gd);
752#endif
Albert ARIBAUDadc421e2015-11-25 17:56:33 +0100753#if !defined(CONFIG_ARM)
754 gd = new_gd;
755#endif
Simon Glassdb910352015-03-03 08:03:00 -0700756 return ptr;
757#else
758 return 0;
759#endif
760}