xref: /openbmc/u-boot/common/spl/spl.c (revision 70c56c138f3776b68f24acb09a9bc3ba67855d0a)
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  #ifdef CONFIG_SPL_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  	puts("\nU-Boot SPL " PLAIN_VERSION " (" U_BOOT_DATE " - " \
481  			U_BOOT_TIME ")\n");
482  #ifdef CONFIG_SPL_DISPLAY_PRINT
483  	spl_display_print();
484  #endif
485  }
486  
487  /**
488   * spl_relocate_stack_gd() - Relocate stack ready for board_init_r() execution
489   *
490   * Sometimes board_init_f() runs with a stack in SRAM but we want to use SDRAM
491   * for the main board_init_r() execution. This is typically because we need
492   * more stack space for things like the MMC sub-system.
493   *
494   * This function calculates the stack position, copies the global_data into
495   * place, sets the new gd (except for ARM, for which setting GD within a C
496   * function may not always work) and returns the new stack position. The
497   * caller is responsible for setting up the sp register and, in the case
498   * of ARM, setting up gd.
499   *
500   * All of this is done using the same layout and alignments as done in
501   * board_init_f_init_reserve() / board_init_f_alloc_reserve().
502   *
503   * @return new stack location, or 0 to use the same stack
504   */
505  ulong spl_relocate_stack_gd(void)
506  {
507  #ifdef CONFIG_SPL_STACK_R
508  	gd_t *new_gd;
509  	ulong ptr = CONFIG_SPL_STACK_R_ADDR;
510  
511  #if defined(CONFIG_SPL_SYS_MALLOC_SIMPLE) && CONFIG_VAL(SYS_MALLOC_F_LEN)
512  	if (CONFIG_SPL_STACK_R_MALLOC_SIMPLE_LEN) {
513  		ptr -= CONFIG_SPL_STACK_R_MALLOC_SIMPLE_LEN;
514  		gd->malloc_base = ptr;
515  		gd->malloc_limit = CONFIG_SPL_STACK_R_MALLOC_SIMPLE_LEN;
516  		gd->malloc_ptr = 0;
517  	}
518  #endif
519  	/* Get stack position: use 8-byte alignment for ABI compliance */
520  	ptr = CONFIG_SPL_STACK_R_ADDR - roundup(sizeof(gd_t),16);
521  	new_gd = (gd_t *)ptr;
522  	memcpy(new_gd, (void *)gd, sizeof(gd_t));
523  #if CONFIG_IS_ENABLED(DM)
524  	dm_fixup_for_gd_move(new_gd);
525  #endif
526  #if !defined(CONFIG_ARM)
527  	gd = new_gd;
528  #endif
529  	return ptr;
530  #else
531  	return 0;
532  #endif
533  }
534