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