xref: /openbmc/u-boot/common/spl/spl.c (revision 2290fe06) 
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 #include <common.h>
10 #include <dm.h>
11 #include <spl.h>
12 #include <asm/u-boot.h>
13 #include <nand.h>
14 #include <fat.h>
15 #include <version.h>
16 #include <i2c.h>
17 #include <image.h>
18 #include <malloc.h>
19 #include <dm/root.h>
20 #include <linux/compiler.h>
21 
22 DECLARE_GLOBAL_DATA_PTR;
23 
24 #ifndef CONFIG_SYS_UBOOT_START
25 #define CONFIG_SYS_UBOOT_START	CONFIG_SYS_TEXT_BASE
26 #endif
27 #ifndef CONFIG_SYS_MONITOR_LEN
28 /* Unknown U-Boot size, let's assume it will not be more than 200 KB */
29 #define CONFIG_SYS_MONITOR_LEN	(200 * 1024)
30 #endif
31 
32 u32 *boot_params_ptr = NULL;
33 struct spl_image_info spl_image;
34 
35 /* Define board data structure */
36 static bd_t bdata __attribute__ ((section(".data")));
37 
38 /*
39  * Board-specific Platform code can reimplement show_boot_progress () if needed
40  */
41 __weak void show_boot_progress(int val) {}
42 
43 /*
44  * Default function to determine if u-boot or the OS should
45  * be started. This implementation always returns 1.
46  *
47  * Please implement your own board specific funcion to do this.
48  *
49  * RETURN
50  * 0 to not start u-boot
51  * positive if u-boot should start
52  */
53 #ifdef CONFIG_SPL_OS_BOOT
54 __weak int spl_start_uboot(void)
55 {
56 	puts("SPL: Please implement spl_start_uboot() for your board\n");
57 	puts("SPL: Direct Linux boot not active!\n");
58 	return 1;
59 }
60 #endif
61 
62 /*
63  * Weak default function for board specific cleanup/preparation before
64  * Linux boot. Some boards/platforms might not need it, so just provide
65  * an empty stub here.
66  */
67 __weak void spl_board_prepare_for_linux(void)
68 {
69 	/* Nothing to do! */
70 }
71 
72 __weak void spl_board_prepare_for_boot(void)
73 {
74 	/* Nothing to do! */
75 }
76 
77 void spl_set_header_raw_uboot(void)
78 {
79 	spl_image.size = CONFIG_SYS_MONITOR_LEN;
80 	spl_image.entry_point = CONFIG_SYS_UBOOT_START;
81 	spl_image.load_addr = CONFIG_SYS_TEXT_BASE;
82 	spl_image.os = IH_OS_U_BOOT;
83 	spl_image.name = "U-Boot";
84 }
85 
86 int spl_parse_image_header(const struct image_header *header)
87 {
88 	u32 header_size = sizeof(struct image_header);
89 
90 	if (image_get_magic(header) == IH_MAGIC) {
91 		if (spl_image.flags & SPL_COPY_PAYLOAD_ONLY) {
92 			/*
93 			 * On some system (e.g. powerpc), the load-address and
94 			 * entry-point is located at address 0. We can't load
95 			 * to 0-0x40. So skip header in this case.
96 			 */
97 			spl_image.load_addr = image_get_load(header);
98 			spl_image.entry_point = image_get_ep(header);
99 			spl_image.size = image_get_data_size(header);
100 		} else {
101 			spl_image.entry_point = image_get_load(header);
102 			/* Load including the header */
103 			spl_image.load_addr = spl_image.entry_point -
104 				header_size;
105 			spl_image.size = image_get_data_size(header) +
106 				header_size;
107 		}
108 		spl_image.os = image_get_os(header);
109 		spl_image.name = image_get_name(header);
110 		debug("spl: payload image: %.*s load addr: 0x%x size: %d\n",
111 			(int)sizeof(spl_image.name), spl_image.name,
112 			spl_image.load_addr, spl_image.size);
113 	} else {
114 #ifdef CONFIG_SPL_PANIC_ON_RAW_IMAGE
115 		/*
116 		 * CONFIG_SPL_PANIC_ON_RAW_IMAGE is defined when the
117 		 * code which loads images in SPL cannot guarantee that
118 		 * absolutely all read errors will be reported.
119 		 * An example is the LPC32XX MLC NAND driver, which
120 		 * will consider that a completely unreadable NAND block
121 		 * is bad, and thus should be skipped silently.
122 		 */
123 		panic("** no mkimage signature but raw image not supported");
124 #elif defined(CONFIG_SPL_ABORT_ON_RAW_IMAGE)
125 		/* Signature not found, proceed to other boot methods. */
126 		return -EINVAL;
127 #else
128 		/* Signature not found - assume u-boot.bin */
129 		debug("mkimage signature not found - ih_magic = %x\n",
130 			header->ih_magic);
131 		spl_set_header_raw_uboot();
132 #endif
133 	}
134 	return 0;
135 }
136 
137 __weak void __noreturn jump_to_image_no_args(struct spl_image_info *spl_image)
138 {
139 	typedef void __noreturn (*image_entry_noargs_t)(void);
140 
141 	image_entry_noargs_t image_entry =
142 		(image_entry_noargs_t)(unsigned long)spl_image->entry_point;
143 
144 	debug("image entry point: 0x%X\n", spl_image->entry_point);
145 	image_entry();
146 }
147 
148 #ifndef CONFIG_SPL_LOAD_FIT_ADDRESS
149 # define CONFIG_SPL_LOAD_FIT_ADDRESS	0
150 #endif
151 
152 #ifdef CONFIG_SPL_RAM_DEVICE
153 static ulong spl_ram_load_read(struct spl_load_info *load, ulong sector,
154 			       ulong count, void *buf)
155 {
156 	debug("%s: sector %lx, count %lx, buf %lx\n",
157 	      __func__, sector, count, (ulong)buf);
158 	memcpy(buf, (void *)(CONFIG_SPL_LOAD_FIT_ADDRESS + sector), count);
159 	return count;
160 }
161 
162 static int spl_ram_load_image(void)
163 {
164 	struct image_header *header;
165 
166 	header = (struct image_header *)CONFIG_SPL_LOAD_FIT_ADDRESS;
167 
168 	if (IS_ENABLED(CONFIG_SPL_LOAD_FIT) &&
169 	    image_get_magic(header) == FDT_MAGIC) {
170 		struct spl_load_info load;
171 
172 		debug("Found FIT\n");
173 		load.bl_len = 1;
174 		load.read = spl_ram_load_read;
175 		spl_load_simple_fit(&load, 0, header);
176 	} else {
177 		debug("Legacy image\n");
178 		/*
179 		 * Get the header.  It will point to an address defined by
180 		 * handoff which will tell where the image located inside
181 		 * the flash. For now, it will temporary fixed to address
182 		 * pointed by U-Boot.
183 		 */
184 		header = (struct image_header *)
185 			(CONFIG_SYS_TEXT_BASE -	sizeof(struct image_header));
186 
187 		spl_parse_image_header(header);
188 	}
189 
190 	return 0;
191 }
192 #endif
193 
194 int spl_init(void)
195 {
196 	int ret;
197 
198 	debug("spl_init()\n");
199 #if defined(CONFIG_SYS_MALLOC_F_LEN)
200 #ifdef CONFIG_MALLOC_F_ADDR
201 	gd->malloc_base = CONFIG_MALLOC_F_ADDR;
202 #endif
203 	gd->malloc_limit = CONFIG_SYS_MALLOC_F_LEN;
204 	gd->malloc_ptr = 0;
205 #endif
206 	if (CONFIG_IS_ENABLED(OF_CONTROL)) {
207 		ret = fdtdec_setup();
208 		if (ret) {
209 			debug("fdtdec_setup() returned error %d\n", ret);
210 			return ret;
211 		}
212 	}
213 	if (IS_ENABLED(CONFIG_SPL_DM)) {
214 		ret = dm_init_and_scan(true);
215 		if (ret) {
216 			debug("dm_init_and_scan() returned error %d\n", ret);
217 			return ret;
218 		}
219 	}
220 	gd->flags |= GD_FLG_SPL_INIT;
221 
222 	return 0;
223 }
224 
225 #ifndef BOOT_DEVICE_NONE
226 #define BOOT_DEVICE_NONE 0xdeadbeef
227 #endif
228 
229 static u32 spl_boot_list[] = {
230 	BOOT_DEVICE_NONE,
231 	BOOT_DEVICE_NONE,
232 	BOOT_DEVICE_NONE,
233 	BOOT_DEVICE_NONE,
234 	BOOT_DEVICE_NONE,
235 };
236 
237 __weak void board_boot_order(u32 *spl_boot_list)
238 {
239 	spl_boot_list[0] = spl_boot_device();
240 }
241 
242 #ifdef CONFIG_SPL_BOARD_LOAD_IMAGE
243 __weak void spl_board_announce_boot_device(void) { }
244 #endif
245 
246 #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
247 struct boot_device_name {
248 	u32 boot_dev;
249 	const char *name;
250 };
251 
252 struct boot_device_name boot_name_table[] = {
253 #ifdef CONFIG_SPL_RAM_DEVICE
254 	{ BOOT_DEVICE_RAM, "RAM" },
255 #endif
256 #ifdef CONFIG_SPL_MMC_SUPPORT
257 	{ BOOT_DEVICE_MMC1, "MMC1" },
258 	{ BOOT_DEVICE_MMC2, "MMC2" },
259 	{ BOOT_DEVICE_MMC2_2, "MMC2_2" },
260 #endif
261 #ifdef CONFIG_SPL_NAND_SUPPORT
262 	{ BOOT_DEVICE_NAND, "NAND" },
263 #endif
264 #ifdef CONFIG_SPL_ONENAND_SUPPORT
265 	{ BOOT_DEVICE_ONENAND, "OneNAND" },
266 #endif
267 #ifdef CONFIG_SPL_NOR_SUPPORT
268 	{ BOOT_DEVICE_NOR, "NOR" },
269 #endif
270 #ifdef CONFIG_SPL_YMODEM_SUPPORT
271 	{ BOOT_DEVICE_UART, "UART" },
272 #endif
273 #ifdef CONFIG_SPL_SPI_SUPPORT
274 	{ BOOT_DEVICE_SPI, "SPI" },
275 #endif
276 #ifdef CONFIG_SPL_ETH_SUPPORT
277 #ifdef CONFIG_SPL_ETH_DEVICE
278 	{ BOOT_DEVICE_CPGMAC, "eth device" },
279 #else
280 	{ BOOT_DEVICE_CPGMAC, "net" },
281 #endif
282 #endif
283 #ifdef CONFIG_SPL_USBETH_SUPPORT
284 	{ BOOT_DEVICE_USBETH, "USB eth" },
285 #endif
286 #ifdef CONFIG_SPL_USB_SUPPORT
287 	{ BOOT_DEVICE_USB, "USB" },
288 #endif
289 #ifdef CONFIG_SPL_SATA_SUPPORT
290 	{ BOOT_DEVICE_SATA, "SATA" },
291 #endif
292 	/* Keep this entry last */
293 	{ BOOT_DEVICE_NONE, "unknown boot device" },
294 };
295 
296 static void announce_boot_device(u32 boot_device)
297 {
298 	int i;
299 
300 	puts("Trying to boot from ");
301 
302 #ifdef CONFIG_SPL_BOARD_LOAD_IMAGE
303 	if (boot_device == BOOT_DEVICE_BOARD) {
304 		spl_board_announce_boot_device();
305 		puts("\n");
306 		return;
307 	}
308 #endif
309 	for (i = 0; i < ARRAY_SIZE(boot_name_table) - 1; i++) {
310 		if (boot_name_table[i].boot_dev == boot_device)
311 			break;
312 	}
313 
314 	printf("%s\n", boot_name_table[i].name);
315 }
316 #else
317 static inline void announce_boot_device(u32 boot_device) { }
318 #endif
319 
320 static int spl_load_image(u32 boot_device)
321 {
322 	switch (boot_device) {
323 #ifdef CONFIG_SPL_RAM_DEVICE
324 	case BOOT_DEVICE_RAM:
325 		return spl_ram_load_image();
326 #endif
327 #ifdef CONFIG_SPL_MMC_SUPPORT
328 	case BOOT_DEVICE_MMC1:
329 	case BOOT_DEVICE_MMC2:
330 	case BOOT_DEVICE_MMC2_2:
331 		return spl_mmc_load_image(boot_device);
332 #endif
333 #ifdef CONFIG_SPL_NAND_SUPPORT
334 	case BOOT_DEVICE_NAND:
335 		return spl_nand_load_image();
336 #endif
337 #ifdef CONFIG_SPL_ONENAND_SUPPORT
338 	case BOOT_DEVICE_ONENAND:
339 		return spl_onenand_load_image();
340 #endif
341 #ifdef CONFIG_SPL_NOR_SUPPORT
342 	case BOOT_DEVICE_NOR:
343 		return spl_nor_load_image();
344 #endif
345 #ifdef CONFIG_SPL_YMODEM_SUPPORT
346 	case BOOT_DEVICE_UART:
347 		return spl_ymodem_load_image();
348 #endif
349 #ifdef CONFIG_SPL_SPI_SUPPORT
350 	case BOOT_DEVICE_SPI:
351 		return spl_spi_load_image();
352 #endif
353 #ifdef CONFIG_SPL_ETH_SUPPORT
354 	case BOOT_DEVICE_CPGMAC:
355 #ifdef CONFIG_SPL_ETH_DEVICE
356 		return spl_net_load_image(CONFIG_SPL_ETH_DEVICE);
357 #else
358 		return spl_net_load_image(NULL);
359 #endif
360 #endif
361 #ifdef CONFIG_SPL_USBETH_SUPPORT
362 	case BOOT_DEVICE_USBETH:
363 		return spl_net_load_image("usb_ether");
364 #endif
365 #ifdef CONFIG_SPL_USB_SUPPORT
366 	case BOOT_DEVICE_USB:
367 		return spl_usb_load_image();
368 #endif
369 #ifdef CONFIG_SPL_SATA_SUPPORT
370 	case BOOT_DEVICE_SATA:
371 		return spl_sata_load_image();
372 #endif
373 #ifdef CONFIG_SPL_BOARD_LOAD_IMAGE
374 	case BOOT_DEVICE_BOARD:
375 		return spl_board_load_image();
376 #endif
377 	default:
378 #if defined(CONFIG_SPL_SERIAL_SUPPORT) && defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
379 		puts("SPL: Unsupported Boot Device!\n");
380 #endif
381 		return -ENODEV;
382 	}
383 
384 	return -EINVAL;
385 }
386 
387 void board_init_r(gd_t *dummy1, ulong dummy2)
388 {
389 	int i;
390 
391 	debug(">>spl:board_init_r()\n");
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 #ifndef CONFIG_PPC
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 #ifdef CONFIG_SPL_BOARD_INIT
411 	spl_board_init();
412 #endif
413 
414 	board_boot_order(spl_boot_list);
415 	for (i = 0; i < ARRAY_SIZE(spl_boot_list) &&
416 			spl_boot_list[i] != BOOT_DEVICE_NONE; i++) {
417 		announce_boot_device(spl_boot_list[i]);
418 		if (!spl_load_image(spl_boot_list[i]))
419 			break;
420 	}
421 
422 	if (i == ARRAY_SIZE(spl_boot_list) ||
423 	    spl_boot_list[i] == BOOT_DEVICE_NONE) {
424 		puts("SPL: failed to boot from all boot devices\n");
425 		hang();
426 	}
427 
428 	switch (spl_image.os) {
429 	case IH_OS_U_BOOT:
430 		debug("Jumping to U-Boot\n");
431 		break;
432 #ifdef CONFIG_SPL_OS_BOOT
433 	case IH_OS_LINUX:
434 		debug("Jumping to Linux\n");
435 		spl_board_prepare_for_linux();
436 		jump_to_image_linux((void *)CONFIG_SYS_SPL_ARGS_ADDR);
437 #endif
438 	default:
439 		debug("Unsupported OS image.. Jumping nevertheless..\n");
440 	}
441 #if defined(CONFIG_SYS_MALLOC_F_LEN) && !defined(CONFIG_SYS_SPL_MALLOC_SIZE)
442 	debug("SPL malloc() used %#lx bytes (%ld KB)\n", gd->malloc_ptr,
443 	      gd->malloc_ptr / 1024);
444 #endif
445 
446 	debug("loaded - jumping to U-Boot...");
447 	spl_board_prepare_for_boot();
448 	jump_to_image_no_args(&spl_image);
449 }
450 
451 /*
452  * This requires UART clocks to be enabled.  In order for this to work the
453  * caller must ensure that the gd pointer is valid.
454  */
455 void preloader_console_init(void)
456 {
457 	gd->bd = &bdata;
458 	gd->baudrate = CONFIG_BAUDRATE;
459 
460 	serial_init();		/* serial communications setup */
461 
462 	gd->have_console = 1;
463 
464 	puts("\nU-Boot SPL " PLAIN_VERSION " (" U_BOOT_DATE " - " \
465 			U_BOOT_TIME ")\n");
466 #ifdef CONFIG_SPL_DISPLAY_PRINT
467 	spl_display_print();
468 #endif
469 }
470 
471 /**
472  * spl_relocate_stack_gd() - Relocate stack ready for board_init_r() execution
473  *
474  * Sometimes board_init_f() runs with a stack in SRAM but we want to use SDRAM
475  * for the main board_init_r() execution. This is typically because we need
476  * more stack space for things like the MMC sub-system.
477  *
478  * This function calculates the stack position, copies the global_data into
479  * place, sets the new gd (except for ARM, for which setting GD within a C
480  * function may not always work) and returns the new stack position. The
481  * caller is responsible for setting up the sp register and, in the case
482  * of ARM, setting up gd.
483  *
484  * All of this is done using the same layout and alignments as done in
485  * board_init_f_init_reserve() / board_init_f_alloc_reserve().
486  *
487  * @return new stack location, or 0 to use the same stack
488  */
489 ulong spl_relocate_stack_gd(void)
490 {
491 #ifdef CONFIG_SPL_STACK_R
492 	gd_t *new_gd;
493 	ulong ptr = CONFIG_SPL_STACK_R_ADDR;
494 
495 #ifdef CONFIG_SPL_SYS_MALLOC_SIMPLE
496 	if (CONFIG_SPL_STACK_R_MALLOC_SIMPLE_LEN) {
497 		ptr -= CONFIG_SPL_STACK_R_MALLOC_SIMPLE_LEN;
498 		gd->malloc_base = ptr;
499 		gd->malloc_limit = CONFIG_SPL_STACK_R_MALLOC_SIMPLE_LEN;
500 		gd->malloc_ptr = 0;
501 	}
502 #endif
503 	/* Get stack position: use 8-byte alignment for ABI compliance */
504 	ptr = CONFIG_SPL_STACK_R_ADDR - roundup(sizeof(gd_t),16);
505 	new_gd = (gd_t *)ptr;
506 	memcpy(new_gd, (void *)gd, sizeof(gd_t));
507 #if !defined(CONFIG_ARM)
508 	gd = new_gd;
509 #endif
510 	return ptr;
511 #else
512 	return 0;
513 #endif
514 }
515