blob: 7f67d41e49c8784867f87b57d68584cfed7856ef [file] [log] [blame]
Aneesh Vbcae7212011-07-21 09:10:21 -04001/*
2 * (C) Copyright 2010
3 * Texas Instruments, <www.ti.com>
4 *
5 * Aneesh V <aneesh@ti.com>
6 *
Wolfgang Denk1a459662013-07-08 09:37:19 +02007 * SPDX-License-Identifier: GPL-2.0+
Aneesh Vbcae7212011-07-21 09:10:21 -04008 */
9#include <common.h>
Simon Glass11516512014-11-10 17:16:46 -070010#include <dm.h>
Tom Rini47f7bca2012-08-13 12:03:19 -070011#include <spl.h>
Aneesh Vbcae7212011-07-21 09:10:21 -040012#include <asm/u-boot.h>
Simon Schwarzbb085b82011-09-14 15:29:26 -040013#include <nand.h>
Aneesh V8cf686e2011-07-21 09:10:27 -040014#include <fat.h>
Simon Glassefb21722011-10-10 08:55:19 +000015#include <version.h>
Aneesh V8cf686e2011-07-21 09:10:27 -040016#include <image.h>
Aneesh V2d01dd92011-10-21 12:29:34 -040017#include <malloc.h>
Simon Glass11516512014-11-10 17:16:46 -070018#include <dm/root.h>
Andreas Müller761ca312012-01-04 15:26:24 +000019#include <linux/compiler.h>
Aneesh Vbcae7212011-07-21 09:10:21 -040020
21DECLARE_GLOBAL_DATA_PTR;
22
Stefan Roese3c6f8a02012-08-28 10:50:59 +020023#ifndef CONFIG_SYS_UBOOT_START
24#define CONFIG_SYS_UBOOT_START CONFIG_SYS_TEXT_BASE
25#endif
Stefano Babicae83d882012-08-23 12:46:16 +020026#ifndef CONFIG_SYS_MONITOR_LEN
Andreas Bießmanne76caa62014-10-25 02:54:55 +020027/* Unknown U-Boot size, let's assume it will not be more than 200 KB */
Stefano Babicae83d882012-08-23 12:46:16 +020028#define CONFIG_SYS_MONITOR_LEN (200 * 1024)
29#endif
30
Tom Rini47f7bca2012-08-13 12:03:19 -070031u32 *boot_params_ptr = NULL;
Simon Schwarz9ea5c6e2011-09-14 15:33:34 -040032struct spl_image_info spl_image;
33
Tom Rini6507f132012-08-22 15:31:05 -070034/* Define board data structure */
Aneesh Vbcae7212011-07-21 09:10:21 -040035static bd_t bdata __attribute__ ((section(".data")));
36
Simon Schwarz379c19a2012-03-15 04:01:38 +000037/*
Heiko Schocher496c5482016-06-07 08:31:20 +020038 * Board-specific Platform code can reimplement show_boot_progress () if needed
39 */
40__weak void show_boot_progress(int val) {}
41
42/*
Simon Schwarz379c19a2012-03-15 04:01:38 +000043 * Default function to determine if u-boot or the OS should
44 * be started. This implementation always returns 1.
45 *
46 * Please implement your own board specific funcion to do this.
47 *
48 * RETURN
49 * 0 to not start u-boot
50 * positive if u-boot should start
51 */
52#ifdef CONFIG_SPL_OS_BOOT
53__weak int spl_start_uboot(void)
54{
Tom Rini026b2fe2012-08-14 12:06:43 -070055 puts("SPL: Please implement spl_start_uboot() for your board\n");
56 puts("SPL: Direct Linux boot not active!\n");
Simon Schwarz379c19a2012-03-15 04:01:38 +000057 return 1;
58}
Ladislav Michl431889d2016-07-12 20:28:14 +020059
60/*
61 * Weak default function for arch specific zImage check. Return zero
62 * and fill start and end address if image is recognized.
63 */
64int __weak bootz_setup(ulong image, ulong *start, ulong *end)
65{
66 return 1;
67}
Simon Schwarz379c19a2012-03-15 04:01:38 +000068#endif
69
Stefan Roeseea8256f2012-08-23 08:34:21 +020070/*
71 * Weak default function for board specific cleanup/preparation before
72 * Linux boot. Some boards/platforms might not need it, so just provide
73 * an empty stub here.
74 */
75__weak void spl_board_prepare_for_linux(void)
76{
77 /* Nothing to do! */
78}
79
Michal Simek3a3b9142016-05-10 07:54:20 +020080__weak void spl_board_prepare_for_boot(void)
81{
82 /* Nothing to do! */
83}
84
Simon Glassd95ceb92016-09-24 18:19:52 -060085void spl_set_header_raw_uboot(struct spl_image_info *spl_image)
Heiko Schocher0c3117b2014-10-31 08:31:00 +010086{
Simon Glassd95ceb92016-09-24 18:19:52 -060087 spl_image->size = CONFIG_SYS_MONITOR_LEN;
88 spl_image->entry_point = CONFIG_SYS_UBOOT_START;
89 spl_image->load_addr = CONFIG_SYS_TEXT_BASE;
90 spl_image->os = IH_OS_U_BOOT;
91 spl_image->name = "U-Boot";
Heiko Schocher0c3117b2014-10-31 08:31:00 +010092}
93
Simon Glass71316c12016-09-24 18:19:53 -060094int spl_parse_image_header(struct spl_image_info *spl_image,
95 const struct image_header *header)
Aneesh V8cf686e2011-07-21 09:10:27 -040096{
97 u32 header_size = sizeof(struct image_header);
98
Stefan Roese77552b02012-08-27 12:50:57 +020099 if (image_get_magic(header) == IH_MAGIC) {
Simon Glass71316c12016-09-24 18:19:53 -0600100 if (spl_image->flags & SPL_COPY_PAYLOAD_ONLY) {
Stefan Roese022b4972012-08-27 12:50:58 +0200101 /*
102 * On some system (e.g. powerpc), the load-address and
103 * entry-point is located at address 0. We can't load
104 * to 0-0x40. So skip header in this case.
105 */
Simon Glass71316c12016-09-24 18:19:53 -0600106 spl_image->load_addr = image_get_load(header);
107 spl_image->entry_point = image_get_ep(header);
108 spl_image->size = image_get_data_size(header);
Stefan Roese022b4972012-08-27 12:50:58 +0200109 } else {
Simon Glass71316c12016-09-24 18:19:53 -0600110 spl_image->entry_point = image_get_load(header);
Stefan Roese022b4972012-08-27 12:50:58 +0200111 /* Load including the header */
Simon Glass71316c12016-09-24 18:19:53 -0600112 spl_image->load_addr = spl_image->entry_point -
Stefan Roese022b4972012-08-27 12:50:58 +0200113 header_size;
Simon Glass71316c12016-09-24 18:19:53 -0600114 spl_image->size = image_get_data_size(header) +
Stefan Roese022b4972012-08-27 12:50:58 +0200115 header_size;
116 }
Simon Glass71316c12016-09-24 18:19:53 -0600117 spl_image->os = image_get_os(header);
118 spl_image->name = image_get_name(header);
Taras Kondratiuk62cf11c2013-07-16 14:45:01 +0300119 debug("spl: payload image: %.*s load addr: 0x%x size: %d\n",
Simon Glass71316c12016-09-24 18:19:53 -0600120 (int)sizeof(spl_image->name), spl_image->name,
121 spl_image->load_addr, spl_image->size);
Aneesh V8cf686e2011-07-21 09:10:27 -0400122 } else {
Albert ARIBAUD \(3ADEV\)8c80eb32015-03-31 11:40:50 +0200123#ifdef CONFIG_SPL_PANIC_ON_RAW_IMAGE
124 /*
125 * CONFIG_SPL_PANIC_ON_RAW_IMAGE is defined when the
126 * code which loads images in SPL cannot guarantee that
127 * absolutely all read errors will be reported.
128 * An example is the LPC32XX MLC NAND driver, which
129 * will consider that a completely unreadable NAND block
130 * is bad, and thus should be skipped silently.
131 */
132 panic("** no mkimage signature but raw image not supported");
Paul Kocialkowski85a37722016-08-24 20:04:42 +0200133#endif
134
Ladislav Michl431889d2016-07-12 20:28:14 +0200135#ifdef CONFIG_SPL_OS_BOOT
136 ulong start, end;
137
138 if (!bootz_setup((ulong)header, &start, &end)) {
Simon Glass71316c12016-09-24 18:19:53 -0600139 spl_image->name = "Linux";
140 spl_image->os = IH_OS_LINUX;
141 spl_image->load_addr = CONFIG_SYS_LOAD_ADDR;
142 spl_image->entry_point = CONFIG_SYS_LOAD_ADDR;
143 spl_image->size = end - start;
Ladislav Michl431889d2016-07-12 20:28:14 +0200144 debug("spl: payload zImage, load addr: 0x%x size: %d\n",
Simon Glass71316c12016-09-24 18:19:53 -0600145 spl_image->load_addr, spl_image->size);
Ladislav Michl431889d2016-07-12 20:28:14 +0200146 return 0;
147 }
148#endif
Paul Kocialkowski85a37722016-08-24 20:04:42 +0200149
150#ifdef CONFIG_SPL_ABORT_ON_RAW_IMAGE
151 /* Signature not found, proceed to other boot methods. */
152 return -EINVAL;
153#else
Aneesh V8cf686e2011-07-21 09:10:27 -0400154 /* Signature not found - assume u-boot.bin */
Tom Rini026b2fe2012-08-14 12:06:43 -0700155 debug("mkimage signature not found - ih_magic = %x\n",
Aneesh V8cf686e2011-07-21 09:10:27 -0400156 header->ih_magic);
Simon Glass71316c12016-09-24 18:19:53 -0600157 spl_set_header_raw_uboot(spl_image);
Albert ARIBAUD \(3ADEV\)8c80eb32015-03-31 11:40:50 +0200158#endif
Aneesh V8cf686e2011-07-21 09:10:27 -0400159 }
Marek Vasut7e0f2262016-04-29 00:44:54 +0200160 return 0;
Aneesh V8cf686e2011-07-21 09:10:27 -0400161}
162
Allen Martina759f1e2012-10-19 21:08:22 +0000163__weak void __noreturn jump_to_image_no_args(struct spl_image_info *spl_image)
Aneesh V8cf686e2011-07-21 09:10:27 -0400164{
SRICHARAN R4a0eb752013-04-24 00:41:24 +0000165 typedef void __noreturn (*image_entry_noargs_t)(void);
166
Aneesh V8cf686e2011-07-21 09:10:27 -0400167 image_entry_noargs_t image_entry =
Scott Woodb2d5ac52015-03-24 13:25:02 -0700168 (image_entry_noargs_t)(unsigned long)spl_image->entry_point;
Aneesh V8cf686e2011-07-21 09:10:27 -0400169
Allen Martina759f1e2012-10-19 21:08:22 +0000170 debug("image entry point: 0x%X\n", spl_image->entry_point);
SRICHARAN R4a0eb752013-04-24 00:41:24 +0000171 image_entry();
Aneesh V8cf686e2011-07-21 09:10:27 -0400172}
173
Michal Simek8d16e1d2016-04-28 09:54:16 +0200174#ifndef CONFIG_SPL_LOAD_FIT_ADDRESS
175# define CONFIG_SPL_LOAD_FIT_ADDRESS 0
176#endif
177
B, Ravi6f8387f2016-07-28 17:39:17 +0530178#if defined(CONFIG_SPL_RAM_DEVICE) || defined(CONFIG_SPL_DFU_SUPPORT)
Michal Simek8d16e1d2016-04-28 09:54:16 +0200179static ulong spl_ram_load_read(struct spl_load_info *load, ulong sector,
180 ulong count, void *buf)
181{
182 debug("%s: sector %lx, count %lx, buf %lx\n",
183 __func__, sector, count, (ulong)buf);
184 memcpy(buf, (void *)(CONFIG_SPL_LOAD_FIT_ADDRESS + sector), count);
185 return count;
186}
187
Nikita Kiryanov36afd452015-11-08 17:11:49 +0200188static int spl_ram_load_image(void)
Pavel Machekc57b9532012-08-30 22:42:11 +0200189{
Michal Simek8d16e1d2016-04-28 09:54:16 +0200190 struct image_header *header;
Pavel Machekc57b9532012-08-30 22:42:11 +0200191
Michal Simek8d16e1d2016-04-28 09:54:16 +0200192 header = (struct image_header *)CONFIG_SPL_LOAD_FIT_ADDRESS;
Pavel Machekc57b9532012-08-30 22:42:11 +0200193
Michal Simek8d16e1d2016-04-28 09:54:16 +0200194 if (IS_ENABLED(CONFIG_SPL_LOAD_FIT) &&
195 image_get_magic(header) == FDT_MAGIC) {
196 struct spl_load_info load;
197
198 debug("Found FIT\n");
199 load.bl_len = 1;
200 load.read = spl_ram_load_read;
201 spl_load_simple_fit(&load, 0, header);
202 } else {
203 debug("Legacy image\n");
204 /*
205 * Get the header. It will point to an address defined by
206 * handoff which will tell where the image located inside
207 * the flash. For now, it will temporary fixed to address
208 * pointed by U-Boot.
209 */
210 header = (struct image_header *)
211 (CONFIG_SYS_TEXT_BASE - sizeof(struct image_header));
212
Simon Glass71316c12016-09-24 18:19:53 -0600213 spl_parse_image_header(&spl_image, header);
Michal Simek8d16e1d2016-04-28 09:54:16 +0200214 }
Nikita Kiryanov36afd452015-11-08 17:11:49 +0200215
216 return 0;
Pavel Machekc57b9532012-08-30 22:42:11 +0200217}
218#endif
219
Simon Glass070d00b2015-06-23 15:39:10 -0600220int spl_init(void)
Aneesh Vbcae7212011-07-21 09:10:21 -0400221{
Simon Glassf3d46bd2015-02-27 22:06:42 -0700222 int ret;
223
Simon Glass070d00b2015-06-23 15:39:10 -0600224 debug("spl_init()\n");
225#if defined(CONFIG_SYS_MALLOC_F_LEN)
Marek Vasut94b9e222016-05-25 02:14:56 +0200226#ifdef CONFIG_MALLOC_F_ADDR
227 gd->malloc_base = CONFIG_MALLOC_F_ADDR;
228#endif
Simon Glass293f16b2015-02-27 22:06:37 -0700229 gd->malloc_limit = CONFIG_SYS_MALLOC_F_LEN;
Simon Glassfb4f5e72014-11-10 17:16:45 -0700230 gd->malloc_ptr = 0;
Tom Rini24dafad2012-08-13 14:13:07 -0700231#endif
Simon Glassd223e0a2016-07-04 11:57:56 -0600232 if (CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)) {
Simon Glassf3d46bd2015-02-27 22:06:42 -0700233 ret = fdtdec_setup();
234 if (ret) {
235 debug("fdtdec_setup() returned error %d\n", ret);
Simon Glass070d00b2015-06-23 15:39:10 -0600236 return ret;
Simon Glassf3d46bd2015-02-27 22:06:42 -0700237 }
238 }
239 if (IS_ENABLED(CONFIG_SPL_DM)) {
Simon Glass7d23b9c2016-07-04 11:58:14 -0600240 /* With CONFIG_OF_PLATDATA, bring in all devices */
241 ret = dm_init_and_scan(!CONFIG_IS_ENABLED(OF_PLATDATA));
Simon Glassf3d46bd2015-02-27 22:06:42 -0700242 if (ret) {
243 debug("dm_init_and_scan() returned error %d\n", ret);
Simon Glass070d00b2015-06-23 15:39:10 -0600244 return ret;
Simon Glassf3d46bd2015-02-27 22:06:42 -0700245 }
246 }
Simon Glass070d00b2015-06-23 15:39:10 -0600247 gd->flags |= GD_FLG_SPL_INIT;
Aneesh V2d01dd92011-10-21 12:29:34 -0400248
Simon Glass070d00b2015-06-23 15:39:10 -0600249 return 0;
250}
251
Nikita Kiryanovf101e4b2015-11-08 17:11:51 +0200252#ifndef BOOT_DEVICE_NONE
253#define BOOT_DEVICE_NONE 0xdeadbeef
254#endif
255
256static u32 spl_boot_list[] = {
257 BOOT_DEVICE_NONE,
258 BOOT_DEVICE_NONE,
259 BOOT_DEVICE_NONE,
260 BOOT_DEVICE_NONE,
261 BOOT_DEVICE_NONE,
262};
263
264__weak void board_boot_order(u32 *spl_boot_list)
265{
266 spl_boot_list[0] = spl_boot_device();
267}
268
Nikita Kiryanov310c8462015-11-08 17:11:52 +0200269#ifdef CONFIG_SPL_BOARD_LOAD_IMAGE
270__weak void spl_board_announce_boot_device(void) { }
271#endif
272
273#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
274struct boot_device_name {
275 u32 boot_dev;
276 const char *name;
277};
278
279struct boot_device_name boot_name_table[] = {
280#ifdef CONFIG_SPL_RAM_DEVICE
281 { BOOT_DEVICE_RAM, "RAM" },
282#endif
283#ifdef CONFIG_SPL_MMC_SUPPORT
Hans de Goede8f10b5c2016-03-20 14:17:10 +0100284 { BOOT_DEVICE_MMC1, "MMC1" },
285 { BOOT_DEVICE_MMC2, "MMC2" },
286 { BOOT_DEVICE_MMC2_2, "MMC2_2" },
Nikita Kiryanov310c8462015-11-08 17:11:52 +0200287#endif
288#ifdef CONFIG_SPL_NAND_SUPPORT
289 { BOOT_DEVICE_NAND, "NAND" },
290#endif
291#ifdef CONFIG_SPL_ONENAND_SUPPORT
292 { BOOT_DEVICE_ONENAND, "OneNAND" },
293#endif
294#ifdef CONFIG_SPL_NOR_SUPPORT
295 { BOOT_DEVICE_NOR, "NOR" },
296#endif
297#ifdef CONFIG_SPL_YMODEM_SUPPORT
298 { BOOT_DEVICE_UART, "UART" },
299#endif
Siarhei Siamashka19e99fb2016-06-07 14:28:34 +0300300#if defined(CONFIG_SPL_SPI_SUPPORT) || defined(CONFIG_SPL_SPI_FLASH_SUPPORT)
Nikita Kiryanov310c8462015-11-08 17:11:52 +0200301 { BOOT_DEVICE_SPI, "SPI" },
302#endif
303#ifdef CONFIG_SPL_ETH_SUPPORT
304#ifdef CONFIG_SPL_ETH_DEVICE
305 { BOOT_DEVICE_CPGMAC, "eth device" },
306#else
307 { BOOT_DEVICE_CPGMAC, "net" },
308#endif
309#endif
310#ifdef CONFIG_SPL_USBETH_SUPPORT
311 { BOOT_DEVICE_USBETH, "USB eth" },
312#endif
313#ifdef CONFIG_SPL_USB_SUPPORT
314 { BOOT_DEVICE_USB, "USB" },
315#endif
B, Ravi6f8387f2016-07-28 17:39:17 +0530316#ifdef CONFIG_SPL_DFU_SUPPORT
317 { BOOT_DEVICE_DFU, "USB DFU" },
318#endif
Nikita Kiryanov310c8462015-11-08 17:11:52 +0200319#ifdef CONFIG_SPL_SATA_SUPPORT
320 { BOOT_DEVICE_SATA, "SATA" },
321#endif
322 /* Keep this entry last */
323 { BOOT_DEVICE_NONE, "unknown boot device" },
324};
325
326static void announce_boot_device(u32 boot_device)
327{
328 int i;
329
330 puts("Trying to boot from ");
331
332#ifdef CONFIG_SPL_BOARD_LOAD_IMAGE
333 if (boot_device == BOOT_DEVICE_BOARD) {
334 spl_board_announce_boot_device();
335 puts("\n");
336 return;
337 }
338#endif
339 for (i = 0; i < ARRAY_SIZE(boot_name_table) - 1; i++) {
340 if (boot_name_table[i].boot_dev == boot_device)
341 break;
342 }
343
344 printf("%s\n", boot_name_table[i].name);
345}
346#else
347static inline void announce_boot_device(u32 boot_device) { }
348#endif
349
Nikita Kiryanov5211b872015-11-08 17:11:50 +0200350static int spl_load_image(u32 boot_device)
351{
352 switch (boot_device) {
353#ifdef CONFIG_SPL_RAM_DEVICE
354 case BOOT_DEVICE_RAM:
355 return spl_ram_load_image();
356#endif
357#ifdef CONFIG_SPL_MMC_SUPPORT
358 case BOOT_DEVICE_MMC1:
359 case BOOT_DEVICE_MMC2:
360 case BOOT_DEVICE_MMC2_2:
Nikita Kiryanova1e56cf2015-11-08 17:11:54 +0200361 return spl_mmc_load_image(boot_device);
Nikita Kiryanov5211b872015-11-08 17:11:50 +0200362#endif
Ladislav Michlbf55cd42016-07-12 20:28:13 +0200363#ifdef CONFIG_SPL_UBI
364 case BOOT_DEVICE_NAND:
365 case BOOT_DEVICE_ONENAND:
366 return spl_ubi_load_image(boot_device);
367#else
Nikita Kiryanov5211b872015-11-08 17:11:50 +0200368#ifdef CONFIG_SPL_NAND_SUPPORT
369 case BOOT_DEVICE_NAND:
370 return spl_nand_load_image();
371#endif
372#ifdef CONFIG_SPL_ONENAND_SUPPORT
373 case BOOT_DEVICE_ONENAND:
374 return spl_onenand_load_image();
375#endif
Ladislav Michlbf55cd42016-07-12 20:28:13 +0200376#endif
Nikita Kiryanov5211b872015-11-08 17:11:50 +0200377#ifdef CONFIG_SPL_NOR_SUPPORT
378 case BOOT_DEVICE_NOR:
379 return spl_nor_load_image();
380#endif
381#ifdef CONFIG_SPL_YMODEM_SUPPORT
382 case BOOT_DEVICE_UART:
383 return spl_ymodem_load_image();
384#endif
Siarhei Siamashka19e99fb2016-06-07 14:28:34 +0300385#if defined(CONFIG_SPL_SPI_SUPPORT) || defined(CONFIG_SPL_SPI_FLASH_SUPPORT)
Nikita Kiryanov5211b872015-11-08 17:11:50 +0200386 case BOOT_DEVICE_SPI:
387 return spl_spi_load_image();
388#endif
389#ifdef CONFIG_SPL_ETH_SUPPORT
390 case BOOT_DEVICE_CPGMAC:
391#ifdef CONFIG_SPL_ETH_DEVICE
392 return spl_net_load_image(CONFIG_SPL_ETH_DEVICE);
393#else
394 return spl_net_load_image(NULL);
395#endif
396#endif
397#ifdef CONFIG_SPL_USBETH_SUPPORT
398 case BOOT_DEVICE_USBETH:
399 return spl_net_load_image("usb_ether");
400#endif
401#ifdef CONFIG_SPL_USB_SUPPORT
402 case BOOT_DEVICE_USB:
403 return spl_usb_load_image();
404#endif
B, Ravi6f8387f2016-07-28 17:39:17 +0530405#ifdef CONFIG_SPL_DFU_SUPPORT
406 case BOOT_DEVICE_DFU:
407 spl_dfu_cmd(0, "dfu_alt_info_ram", "ram", "0");
408 return spl_ram_load_image();
409#endif
Nikita Kiryanov5211b872015-11-08 17:11:50 +0200410#ifdef CONFIG_SPL_SATA_SUPPORT
411 case BOOT_DEVICE_SATA:
412 return spl_sata_load_image();
413#endif
414#ifdef CONFIG_SPL_BOARD_LOAD_IMAGE
415 case BOOT_DEVICE_BOARD:
416 return spl_board_load_image();
417#endif
418 default:
419#if defined(CONFIG_SPL_SERIAL_SUPPORT) && defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
420 puts("SPL: Unsupported Boot Device!\n");
421#endif
422 return -ENODEV;
423 }
424
425 return -EINVAL;
426}
427
Simon Glass070d00b2015-06-23 15:39:10 -0600428void board_init_r(gd_t *dummy1, ulong dummy2)
429{
Nikita Kiryanovf101e4b2015-11-08 17:11:51 +0200430 int i;
Simon Glass070d00b2015-06-23 15:39:10 -0600431
432 debug(">>spl:board_init_r()\n");
433
434#if defined(CONFIG_SYS_SPL_MALLOC_START)
435 mem_malloc_init(CONFIG_SYS_SPL_MALLOC_START,
436 CONFIG_SYS_SPL_MALLOC_SIZE);
437 gd->flags |= GD_FLG_FULL_MALLOC_INIT;
438#endif
439 if (!(gd->flags & GD_FLG_SPL_INIT)) {
440 if (spl_init())
441 hang();
442 }
Stefan Roeseea8256f2012-08-23 08:34:21 +0200443#ifndef CONFIG_PPC
444 /*
445 * timer_init() does not exist on PPC systems. The timer is initialized
446 * and enabled (decrementer) in interrupt_init() here.
447 */
Ilya Yanok4063c772012-09-17 10:26:26 +0000448 timer_init();
Stefan Roeseea8256f2012-08-23 08:34:21 +0200449#endif
Ilya Yanok4063c772012-09-17 10:26:26 +0000450
Tom Riniee08a822011-11-23 05:13:06 +0000451#ifdef CONFIG_SPL_BOARD_INIT
452 spl_board_init();
453#endif
454
Nikita Kiryanovf101e4b2015-11-08 17:11:51 +0200455 board_boot_order(spl_boot_list);
456 for (i = 0; i < ARRAY_SIZE(spl_boot_list) &&
457 spl_boot_list[i] != BOOT_DEVICE_NONE; i++) {
Nikita Kiryanov310c8462015-11-08 17:11:52 +0200458 announce_boot_device(spl_boot_list[i]);
Nikita Kiryanovf101e4b2015-11-08 17:11:51 +0200459 if (!spl_load_image(spl_boot_list[i]))
460 break;
461 }
462
463 if (i == ARRAY_SIZE(spl_boot_list) ||
464 spl_boot_list[i] == BOOT_DEVICE_NONE) {
465 puts("SPL: failed to boot from all boot devices\n");
Aneesh V8cf686e2011-07-21 09:10:27 -0400466 hang();
Nikita Kiryanovf101e4b2015-11-08 17:11:51 +0200467 }
Aneesh V8cf686e2011-07-21 09:10:27 -0400468
Simon Schwarz9ea5c6e2011-09-14 15:33:34 -0400469 switch (spl_image.os) {
Aneesh V8cf686e2011-07-21 09:10:27 -0400470 case IH_OS_U_BOOT:
471 debug("Jumping to U-Boot\n");
Aneesh V8cf686e2011-07-21 09:10:27 -0400472 break;
Simon Schwarz379c19a2012-03-15 04:01:38 +0000473#ifdef CONFIG_SPL_OS_BOOT
474 case IH_OS_LINUX:
475 debug("Jumping to Linux\n");
476 spl_board_prepare_for_linux();
477 jump_to_image_linux((void *)CONFIG_SYS_SPL_ARGS_ADDR);
Simon Schwarz379c19a2012-03-15 04:01:38 +0000478#endif
Aneesh V8cf686e2011-07-21 09:10:27 -0400479 default:
Tom Rini42120982012-08-27 14:58:28 -0700480 debug("Unsupported OS image.. Jumping nevertheless..\n");
Aneesh V8cf686e2011-07-21 09:10:27 -0400481 }
Simon Glassfb4f5e72014-11-10 17:16:45 -0700482#if defined(CONFIG_SYS_MALLOC_F_LEN) && !defined(CONFIG_SYS_SPL_MALLOC_SIZE)
483 debug("SPL malloc() used %#lx bytes (%ld KB)\n", gd->malloc_ptr,
484 gd->malloc_ptr / 1024);
485#endif
486
Simon Glassaea3d402015-06-23 15:39:11 -0600487 debug("loaded - jumping to U-Boot...");
Michal Simek3a3b9142016-05-10 07:54:20 +0200488 spl_board_prepare_for_boot();
Allen Martina759f1e2012-10-19 21:08:22 +0000489 jump_to_image_no_args(&spl_image);
Aneesh Vbcae7212011-07-21 09:10:21 -0400490}
491
Tom Rini6507f132012-08-22 15:31:05 -0700492/*
493 * This requires UART clocks to be enabled. In order for this to work the
494 * caller must ensure that the gd pointer is valid.
495 */
Aneesh Vbcae7212011-07-21 09:10:21 -0400496void preloader_console_init(void)
497{
Aneesh Vbcae7212011-07-21 09:10:21 -0400498 gd->bd = &bdata;
Aneesh Vbcae7212011-07-21 09:10:21 -0400499 gd->baudrate = CONFIG_BAUDRATE;
500
Aneesh Vbcae7212011-07-21 09:10:21 -0400501 serial_init(); /* serial communications setup */
502
Ilya Yanokb88befa2011-11-01 13:16:03 +0000503 gd->have_console = 1;
504
Tom Rini026b2fe2012-08-14 12:06:43 -0700505 puts("\nU-Boot SPL " PLAIN_VERSION " (" U_BOOT_DATE " - " \
506 U_BOOT_TIME ")\n");
Tom Rini861a86f2012-08-13 11:37:56 -0700507#ifdef CONFIG_SPL_DISPLAY_PRINT
508 spl_display_print();
509#endif
Tom Rinicc3f7052011-10-04 04:59:23 +0000510}
Simon Glassdb910352015-03-03 08:03:00 -0700511
512/**
513 * spl_relocate_stack_gd() - Relocate stack ready for board_init_r() execution
514 *
515 * Sometimes board_init_f() runs with a stack in SRAM but we want to use SDRAM
516 * for the main board_init_r() execution. This is typically because we need
517 * more stack space for things like the MMC sub-system.
518 *
519 * This function calculates the stack position, copies the global_data into
Albert ARIBAUDadc421e2015-11-25 17:56:33 +0100520 * place, sets the new gd (except for ARM, for which setting GD within a C
521 * function may not always work) and returns the new stack position. The
522 * caller is responsible for setting up the sp register and, in the case
523 * of ARM, setting up gd.
524 *
525 * All of this is done using the same layout and alignments as done in
526 * board_init_f_init_reserve() / board_init_f_alloc_reserve().
Simon Glassdb910352015-03-03 08:03:00 -0700527 *
528 * @return new stack location, or 0 to use the same stack
529 */
530ulong spl_relocate_stack_gd(void)
531{
532#ifdef CONFIG_SPL_STACK_R
533 gd_t *new_gd;
Albert ARIBAUDadc421e2015-11-25 17:56:33 +0100534 ulong ptr = CONFIG_SPL_STACK_R_ADDR;
Simon Glassdb910352015-03-03 08:03:00 -0700535
Hans de Goededcfcb8d2015-09-13 15:04:17 +0200536#ifdef CONFIG_SPL_SYS_MALLOC_SIMPLE
537 if (CONFIG_SPL_STACK_R_MALLOC_SIMPLE_LEN) {
Hans de Goededcfcb8d2015-09-13 15:04:17 +0200538 ptr -= CONFIG_SPL_STACK_R_MALLOC_SIMPLE_LEN;
539 gd->malloc_base = ptr;
540 gd->malloc_limit = CONFIG_SPL_STACK_R_MALLOC_SIMPLE_LEN;
541 gd->malloc_ptr = 0;
542 }
543#endif
Albert ARIBAUDadc421e2015-11-25 17:56:33 +0100544 /* Get stack position: use 8-byte alignment for ABI compliance */
545 ptr = CONFIG_SPL_STACK_R_ADDR - roundup(sizeof(gd_t),16);
546 new_gd = (gd_t *)ptr;
547 memcpy(new_gd, (void *)gd, sizeof(gd_t));
548#if !defined(CONFIG_ARM)
549 gd = new_gd;
550#endif
Simon Glassdb910352015-03-03 08:03:00 -0700551 return ptr;
552#else
553 return 0;
554#endif
555}