xref: /openbmc/u-boot/common/spl/spl.c (revision 852cc548)
1 /*
2  * (C) Copyright 2010
3  * Texas Instruments, <www.ti.com>
4  *
5  * Aneesh V <aneesh@ti.com>
6  *
7  * SPDX-License-Identifier:	GPL-2.0+
8  */
9 
10 #include <common.h>
11 #include <binman_sym.h>
12 #include <dm.h>
13 #include <spl.h>
14 #include <asm/u-boot.h>
15 #include <nand.h>
16 #include <fat.h>
17 #include <version.h>
18 #include <image.h>
19 #include <malloc.h>
20 #include <dm/root.h>
21 #include <linux/compiler.h>
22 #include <fdt_support.h>
23 
24 DECLARE_GLOBAL_DATA_PTR;
25 
26 #ifndef CONFIG_SYS_UBOOT_START
27 #define CONFIG_SYS_UBOOT_START	CONFIG_SYS_TEXT_BASE
28 #endif
29 #ifndef CONFIG_SYS_MONITOR_LEN
30 /* Unknown U-Boot size, let's assume it will not be more than 200 KB */
31 #define CONFIG_SYS_MONITOR_LEN	(200 * 1024)
32 #endif
33 
34 u32 *boot_params_ptr = NULL;
35 
36 /* See spl.h for information about this */
37 binman_sym_declare(ulong, u_boot_any, pos);
38 
39 /* Define board data structure */
40 static bd_t bdata __attribute__ ((section(".data")));
41 
42 /*
43  * Board-specific Platform code can reimplement show_boot_progress () if needed
44  */
45 __weak void show_boot_progress(int val) {}
46 
47 /*
48  * Default function to determine if u-boot or the OS should
49  * be started. This implementation always returns 1.
50  *
51  * Please implement your own board specific funcion to do this.
52  *
53  * RETURN
54  * 0 to not start u-boot
55  * positive if u-boot should start
56  */
57 #ifdef CONFIG_SPL_OS_BOOT
58 __weak int spl_start_uboot(void)
59 {
60 	puts("SPL: Please implement spl_start_uboot() for your board\n");
61 	puts("SPL: Direct Linux boot not active!\n");
62 	return 1;
63 }
64 
65 /* weak default platform specific function to initialize
66  * dram banks
67  */
68 __weak int dram_init_banksize(void)
69 {
70 	return 0;
71 }
72 
73 /*
74  * Weak default function for arch specific zImage check. Return zero
75  * and fill start and end address if image is recognized.
76  */
77 int __weak bootz_setup(ulong image, ulong *start, ulong *end)
78 {
79 	 return 1;
80 }
81 #endif
82 
83 void spl_fixup_fdt(void)
84 {
85 #if defined(CONFIG_SPL_OF_LIBFDT) && defined(CONFIG_SYS_SPL_ARGS_ADDR)
86 	void *fdt_blob = (void *)CONFIG_SYS_SPL_ARGS_ADDR;
87 	int err;
88 
89 	err = fdt_check_header(fdt_blob);
90 	if (err < 0) {
91 		printf("fdt_root: %s\n", fdt_strerror(err));
92 		return;
93 	}
94 
95 	/* fixup the memory dt node */
96 	err = fdt_shrink_to_minimum(fdt_blob, 0);
97 	if (err == 0) {
98 		printf("spl: fdt_shrink_to_minimum err - %d\n", err);
99 		return;
100 	}
101 
102 	err = arch_fixup_fdt(fdt_blob);
103 	if (err) {
104 		printf("spl: arch_fixup_fdt err - %d\n", err);
105 		return;
106 	}
107 #endif
108 }
109 
110 /*
111  * Weak default function for board specific cleanup/preparation before
112  * Linux boot. Some boards/platforms might not need it, so just provide
113  * an empty stub here.
114  */
115 __weak void spl_board_prepare_for_linux(void)
116 {
117 	/* Nothing to do! */
118 }
119 
120 __weak void spl_board_prepare_for_boot(void)
121 {
122 	/* Nothing to do! */
123 }
124 
125 void spl_set_header_raw_uboot(struct spl_image_info *spl_image)
126 {
127 	ulong u_boot_pos = binman_sym(ulong, u_boot_any, pos);
128 
129 	spl_image->size = CONFIG_SYS_MONITOR_LEN;
130 	if (u_boot_pos != BINMAN_SYM_MISSING) {
131 		/* biman does not support separate entry addresses at present */
132 		spl_image->entry_point = u_boot_pos;
133 		spl_image->load_addr = u_boot_pos;
134 	} else {
135 		spl_image->entry_point = CONFIG_SYS_UBOOT_START;
136 		spl_image->load_addr = CONFIG_SYS_TEXT_BASE;
137 	}
138 	spl_image->os = IH_OS_U_BOOT;
139 	spl_image->name = "U-Boot";
140 }
141 
142 int spl_parse_image_header(struct spl_image_info *spl_image,
143 			   const struct image_header *header)
144 {
145 	if (image_get_magic(header) == IH_MAGIC) {
146 #ifdef CONFIG_SPL_LEGACY_IMAGE_SUPPORT
147 		u32 header_size = sizeof(struct image_header);
148 
149 		if (spl_image->flags & SPL_COPY_PAYLOAD_ONLY) {
150 			/*
151 			 * On some system (e.g. powerpc), the load-address and
152 			 * entry-point is located at address 0. We can't load
153 			 * to 0-0x40. So skip header in this case.
154 			 */
155 			spl_image->load_addr = image_get_load(header);
156 			spl_image->entry_point = image_get_ep(header);
157 			spl_image->size = image_get_data_size(header);
158 		} else {
159 			spl_image->entry_point = image_get_load(header);
160 			/* Load including the header */
161 			spl_image->load_addr = spl_image->entry_point -
162 				header_size;
163 			spl_image->size = image_get_data_size(header) +
164 				header_size;
165 		}
166 		spl_image->os = image_get_os(header);
167 		spl_image->name = image_get_name(header);
168 		debug("spl: payload image: %.*s load addr: 0x%lx size: %d\n",
169 			IH_NMLEN, spl_image->name,
170 			spl_image->load_addr, spl_image->size);
171 #else
172 		/* LEGACY image not supported */
173 		debug("Legacy boot image support not enabled, proceeding to other boot methods\n");
174 		return -EINVAL;
175 #endif
176 	} else {
177 #ifdef CONFIG_SPL_PANIC_ON_RAW_IMAGE
178 		/*
179 		 * CONFIG_SPL_PANIC_ON_RAW_IMAGE is defined when the
180 		 * code which loads images in SPL cannot guarantee that
181 		 * absolutely all read errors will be reported.
182 		 * An example is the LPC32XX MLC NAND driver, which
183 		 * will consider that a completely unreadable NAND block
184 		 * is bad, and thus should be skipped silently.
185 		 */
186 		panic("** no mkimage signature but raw image not supported");
187 #endif
188 
189 #ifdef CONFIG_SPL_OS_BOOT
190 		ulong start, end;
191 
192 		if (!bootz_setup((ulong)header, &start, &end)) {
193 			spl_image->name = "Linux";
194 			spl_image->os = IH_OS_LINUX;
195 			spl_image->load_addr = CONFIG_SYS_LOAD_ADDR;
196 			spl_image->entry_point = CONFIG_SYS_LOAD_ADDR;
197 			spl_image->size = end - start;
198 			debug("spl: payload zImage, load addr: 0x%lx size: %d\n",
199 			      spl_image->load_addr, spl_image->size);
200 			return 0;
201 		}
202 #endif
203 
204 #ifdef CONFIG_SPL_RAW_IMAGE_SUPPORT
205 		/* Signature not found - assume u-boot.bin */
206 		debug("mkimage signature not found - ih_magic = %x\n",
207 			header->ih_magic);
208 		spl_set_header_raw_uboot(spl_image);
209 #else
210 		/* RAW image not supported, proceed to other boot methods. */
211 		debug("Raw boot image support not enabled, proceeding to other boot methods\n");
212 		return -EINVAL;
213 #endif
214 	}
215 
216 	return 0;
217 }
218 
219 __weak void __noreturn jump_to_image_no_args(struct spl_image_info *spl_image)
220 {
221 	typedef void __noreturn (*image_entry_noargs_t)(void);
222 
223 	image_entry_noargs_t image_entry =
224 		(image_entry_noargs_t)spl_image->entry_point;
225 
226 	debug("image entry point: 0x%lX\n", spl_image->entry_point);
227 	image_entry();
228 }
229 
230 static int spl_common_init(bool setup_malloc)
231 {
232 	int ret;
233 
234 	debug("spl_early_init()\n");
235 
236 #if CONFIG_VAL(SYS_MALLOC_F_LEN)
237 	if (setup_malloc) {
238 #ifdef CONFIG_MALLOC_F_ADDR
239 		gd->malloc_base = CONFIG_MALLOC_F_ADDR;
240 #endif
241 		gd->malloc_limit = CONFIG_VAL(SYS_MALLOC_F_LEN);
242 		gd->malloc_ptr = 0;
243 	}
244 #endif
245 	ret = bootstage_init(true);
246 	if (ret) {
247 		debug("%s: Failed to set up bootstage: ret=%d\n", __func__,
248 		      ret);
249 		return ret;
250 	}
251 	bootstage_mark_name(BOOTSTAGE_ID_START_SPL, "spl");
252 	if (CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)) {
253 		ret = fdtdec_setup();
254 		if (ret) {
255 			debug("fdtdec_setup() returned error %d\n", ret);
256 			return ret;
257 		}
258 	}
259 	if (CONFIG_IS_ENABLED(DM)) {
260 		bootstage_start(BOOTSTATE_ID_ACCUM_DM_SPL, "dm_spl");
261 		/* With CONFIG_SPL_OF_PLATDATA, bring in all devices */
262 		ret = dm_init_and_scan(!CONFIG_IS_ENABLED(OF_PLATDATA));
263 		bootstage_accum(BOOTSTATE_ID_ACCUM_DM_SPL);
264 		if (ret) {
265 			debug("dm_init_and_scan() returned error %d\n", ret);
266 			return ret;
267 		}
268 	}
269 
270 	return 0;
271 }
272 
273 void spl_set_bd(void)
274 {
275 	if (!gd->bd)
276 		gd->bd = &bdata;
277 }
278 
279 int spl_early_init(void)
280 {
281 	int ret;
282 
283 	ret = spl_common_init(true);
284 	if (ret)
285 		return ret;
286 	gd->flags |= GD_FLG_SPL_EARLY_INIT;
287 
288 	return 0;
289 }
290 
291 int spl_init(void)
292 {
293 	int ret;
294 	bool setup_malloc = !(IS_ENABLED(CONFIG_SPL_STACK_R) &&
295 			IS_ENABLED(CONFIG_SPL_SYS_MALLOC_SIMPLE));
296 
297 	if (!(gd->flags & GD_FLG_SPL_EARLY_INIT)) {
298 		ret = spl_common_init(setup_malloc);
299 		if (ret)
300 			return ret;
301 	}
302 	gd->flags |= GD_FLG_SPL_INIT;
303 
304 	return 0;
305 }
306 
307 #ifndef BOOT_DEVICE_NONE
308 #define BOOT_DEVICE_NONE 0xdeadbeef
309 #endif
310 
311 __weak void board_boot_order(u32 *spl_boot_list)
312 {
313 	spl_boot_list[0] = spl_boot_device();
314 }
315 
316 static struct spl_image_loader *spl_ll_find_loader(uint boot_device)
317 {
318 	struct spl_image_loader *drv =
319 		ll_entry_start(struct spl_image_loader, spl_image_loader);
320 	const int n_ents =
321 		ll_entry_count(struct spl_image_loader, spl_image_loader);
322 	struct spl_image_loader *entry;
323 
324 	for (entry = drv; entry != drv + n_ents; entry++) {
325 		if (boot_device == entry->boot_device)
326 			return entry;
327 	}
328 
329 	/* Not found */
330 	return NULL;
331 }
332 
333 static int spl_load_image(struct spl_image_info *spl_image,
334 			  struct spl_image_loader *loader)
335 {
336 	struct spl_boot_device bootdev;
337 
338 	bootdev.boot_device = loader->boot_device;
339 	bootdev.boot_device_name = NULL;
340 
341 	return loader->load_image(spl_image, &bootdev);
342 }
343 
344 /**
345  * boot_from_devices() - Try loading an booting U-Boot from a list of devices
346  *
347  * @spl_image: Place to put the image details if successful
348  * @spl_boot_list: List of boot devices to try
349  * @count: Number of elements in spl_boot_list
350  * @return 0 if OK, -ve on error
351  */
352 static int boot_from_devices(struct spl_image_info *spl_image,
353 			     u32 spl_boot_list[], int count)
354 {
355 	int i;
356 
357 	for (i = 0; i < count && spl_boot_list[i] != BOOT_DEVICE_NONE; i++) {
358 		struct spl_image_loader *loader;
359 
360 		loader = spl_ll_find_loader(spl_boot_list[i]);
361 #if defined(CONFIG_SPL_SERIAL_SUPPORT) && defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
362 		if (loader)
363 			printf("Trying to boot from %s\n", loader->name);
364 		else
365 			puts("SPL: Unsupported Boot Device!\n");
366 #endif
367 		if (loader && !spl_load_image(spl_image, loader))
368 			return 0;
369 	}
370 
371 	return -ENODEV;
372 }
373 
374 void board_init_r(gd_t *dummy1, ulong dummy2)
375 {
376 	u32 spl_boot_list[] = {
377 		BOOT_DEVICE_NONE,
378 		BOOT_DEVICE_NONE,
379 		BOOT_DEVICE_NONE,
380 		BOOT_DEVICE_NONE,
381 		BOOT_DEVICE_NONE,
382 	};
383 	struct spl_image_info spl_image;
384 
385 	debug(">>spl:board_init_r()\n");
386 
387 	spl_set_bd();
388 
389 #ifdef CONFIG_SPL_OS_BOOT
390 	dram_init_banksize();
391 #endif
392 
393 #if defined(CONFIG_SYS_SPL_MALLOC_START)
394 	mem_malloc_init(CONFIG_SYS_SPL_MALLOC_START,
395 			CONFIG_SYS_SPL_MALLOC_SIZE);
396 	gd->flags |= GD_FLG_FULL_MALLOC_INIT;
397 #endif
398 	if (!(gd->flags & GD_FLG_SPL_INIT)) {
399 		if (spl_init())
400 			hang();
401 	}
402 #if !defined(CONFIG_PPC) && !defined(CONFIG_ARCH_MX6)
403 	/*
404 	 * timer_init() does not exist on PPC systems. The timer is initialized
405 	 * and enabled (decrementer) in interrupt_init() here.
406 	 */
407 	timer_init();
408 #endif
409 
410 #if CONFIG_IS_ENABLED(BOARD_INIT)
411 	spl_board_init();
412 #endif
413 
414 	memset(&spl_image, '\0', sizeof(spl_image));
415 #ifdef CONFIG_SYS_SPL_ARGS_ADDR
416 	spl_image.arg = (void *)CONFIG_SYS_SPL_ARGS_ADDR;
417 #endif
418 	board_boot_order(spl_boot_list);
419 
420 	if (boot_from_devices(&spl_image, spl_boot_list,
421 			      ARRAY_SIZE(spl_boot_list))) {
422 		puts("SPL: failed to boot from all boot devices\n");
423 		hang();
424 	}
425 
426 #ifdef CONFIG_CPU_V7M
427 	spl_image.entry_point |= 0x1;
428 #endif
429 	switch (spl_image.os) {
430 	case IH_OS_U_BOOT:
431 		debug("Jumping to U-Boot\n");
432 		break;
433 #if CONFIG_IS_ENABLED(ATF)
434 	case IH_OS_ARM_TRUSTED_FIRMWARE:
435 		debug("Jumping to U-Boot via ARM Trusted Firmware\n");
436 		spl_invoke_atf(&spl_image);
437 		break;
438 #endif
439 #ifdef CONFIG_SPL_OS_BOOT
440 	case IH_OS_LINUX:
441 		debug("Jumping to Linux\n");
442 		spl_fixup_fdt();
443 		spl_board_prepare_for_linux();
444 		jump_to_image_linux(&spl_image);
445 #endif
446 	default:
447 		debug("Unsupported OS image.. Jumping nevertheless..\n");
448 	}
449 #if CONFIG_VAL(SYS_MALLOC_F_LEN) && !defined(CONFIG_SYS_SPL_MALLOC_SIZE)
450 	debug("SPL malloc() used %#lx bytes (%ld KB)\n", gd->malloc_ptr,
451 	      gd->malloc_ptr / 1024);
452 #endif
453 #ifdef CONFIG_BOOTSTAGE_STASH
454 	int ret;
455 
456 	bootstage_mark_name(BOOTSTAGE_ID_END_SPL, "end_spl");
457 	ret = bootstage_stash((void *)CONFIG_BOOTSTAGE_STASH_ADDR,
458 			      CONFIG_BOOTSTAGE_STASH_SIZE);
459 	if (ret)
460 		debug("Failed to stash bootstage: err=%d\n", ret);
461 #endif
462 
463 	debug("loaded - jumping to U-Boot...\n");
464 	spl_board_prepare_for_boot();
465 	jump_to_image_no_args(&spl_image);
466 }
467 
468 /*
469  * This requires UART clocks to be enabled.  In order for this to work the
470  * caller must ensure that the gd pointer is valid.
471  */
472 void preloader_console_init(void)
473 {
474 	gd->baudrate = CONFIG_BAUDRATE;
475 
476 	serial_init();		/* serial communications setup */
477 
478 	gd->have_console = 1;
479 
480 #ifndef CONFIG_SPL_DISABLE_BANNER_PRINT
481 	puts("\nU-Boot SPL " PLAIN_VERSION " (" U_BOOT_DATE " - " \
482 			U_BOOT_TIME " " U_BOOT_TZ ")\n");
483 #endif
484 #ifdef CONFIG_SPL_DISPLAY_PRINT
485 	spl_display_print();
486 #endif
487 }
488 
489 /**
490  * spl_relocate_stack_gd() - Relocate stack ready for board_init_r() execution
491  *
492  * Sometimes board_init_f() runs with a stack in SRAM but we want to use SDRAM
493  * for the main board_init_r() execution. This is typically because we need
494  * more stack space for things like the MMC sub-system.
495  *
496  * This function calculates the stack position, copies the global_data into
497  * place, sets the new gd (except for ARM, for which setting GD within a C
498  * function may not always work) and returns the new stack position. The
499  * caller is responsible for setting up the sp register and, in the case
500  * of ARM, setting up gd.
501  *
502  * All of this is done using the same layout and alignments as done in
503  * board_init_f_init_reserve() / board_init_f_alloc_reserve().
504  *
505  * @return new stack location, or 0 to use the same stack
506  */
507 ulong spl_relocate_stack_gd(void)
508 {
509 #ifdef CONFIG_SPL_STACK_R
510 	gd_t *new_gd;
511 	ulong ptr = CONFIG_SPL_STACK_R_ADDR;
512 
513 #if defined(CONFIG_SPL_SYS_MALLOC_SIMPLE) && CONFIG_VAL(SYS_MALLOC_F_LEN)
514 	if (CONFIG_SPL_STACK_R_MALLOC_SIMPLE_LEN) {
515 		ptr -= CONFIG_SPL_STACK_R_MALLOC_SIMPLE_LEN;
516 		gd->malloc_base = ptr;
517 		gd->malloc_limit = CONFIG_SPL_STACK_R_MALLOC_SIMPLE_LEN;
518 		gd->malloc_ptr = 0;
519 	}
520 #endif
521 	/* Get stack position: use 8-byte alignment for ABI compliance */
522 	ptr = CONFIG_SPL_STACK_R_ADDR - roundup(sizeof(gd_t),16);
523 	new_gd = (gd_t *)ptr;
524 	memcpy(new_gd, (void *)gd, sizeof(gd_t));
525 #if CONFIG_IS_ENABLED(DM)
526 	dm_fixup_for_gd_move(new_gd);
527 #endif
528 #if !defined(CONFIG_ARM)
529 	gd = new_gd;
530 #endif
531 	return ptr;
532 #else
533 	return 0;
534 #endif
535 }
536