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