]> git.kernelconcepts.de Git - karo-tx-uboot.git/blob - common/spl/spl.c
spl: Change debug to printf for "Unsupported boot-device"
[karo-tx-uboot.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 <spl.h>
11 #include <asm/u-boot.h>
12 #include <nand.h>
13 #include <fat.h>
14 #include <version.h>
15 #include <i2c.h>
16 #include <image.h>
17 #include <malloc.h>
18 #include <linux/compiler.h>
19
20 DECLARE_GLOBAL_DATA_PTR;
21
22 #ifndef CONFIG_SYS_UBOOT_START
23 #define CONFIG_SYS_UBOOT_START  CONFIG_SYS_TEXT_BASE
24 #endif
25 #ifndef CONFIG_SYS_MONITOR_LEN
26 /* Unknown U-Boot size, let's assume it will not be more than 200 KB */
27 #define CONFIG_SYS_MONITOR_LEN  (200 * 1024)
28 #endif
29
30 u32 *boot_params_ptr = NULL;
31 struct spl_image_info spl_image;
32
33 /* Define board data structure */
34 static bd_t bdata __attribute__ ((section(".data")));
35
36 /*
37  * Default function to determine if u-boot or the OS should
38  * be started. This implementation always returns 1.
39  *
40  * Please implement your own board specific funcion to do this.
41  *
42  * RETURN
43  * 0 to not start u-boot
44  * positive if u-boot should start
45  */
46 #ifdef CONFIG_SPL_OS_BOOT
47 __weak int spl_start_uboot(void)
48 {
49         puts("SPL: Please implement spl_start_uboot() for your board\n");
50         puts("SPL: Direct Linux boot not active!\n");
51         return 1;
52 }
53 #endif
54
55 /*
56  * Weak default function for board specific cleanup/preparation before
57  * Linux boot. Some boards/platforms might not need it, so just provide
58  * an empty stub here.
59  */
60 __weak void spl_board_prepare_for_linux(void)
61 {
62         /* Nothing to do! */
63 }
64
65 void spl_set_header_raw_uboot(void)
66 {
67         spl_image.size = CONFIG_SYS_MONITOR_LEN;
68         spl_image.entry_point = CONFIG_SYS_UBOOT_START;
69         spl_image.load_addr = CONFIG_SYS_TEXT_BASE;
70         spl_image.os = IH_OS_U_BOOT;
71         spl_image.name = "U-Boot";
72 }
73
74 void spl_parse_image_header(const struct image_header *header)
75 {
76         u32 header_size = sizeof(struct image_header);
77
78         if (image_get_magic(header) == IH_MAGIC) {
79                 if (spl_image.flags & SPL_COPY_PAYLOAD_ONLY) {
80                         /*
81                          * On some system (e.g. powerpc), the load-address and
82                          * entry-point is located at address 0. We can't load
83                          * to 0-0x40. So skip header in this case.
84                          */
85                         spl_image.load_addr = image_get_load(header);
86                         spl_image.entry_point = image_get_ep(header);
87                         spl_image.size = image_get_data_size(header);
88                 } else {
89                         spl_image.entry_point = image_get_load(header);
90                         /* Load including the header */
91                         spl_image.load_addr = spl_image.entry_point -
92                                 header_size;
93                         spl_image.size = image_get_data_size(header) +
94                                 header_size;
95                 }
96                 spl_image.os = image_get_os(header);
97                 spl_image.name = image_get_name(header);
98                 debug("spl: payload image: %.*s load addr: 0x%x size: %d\n",
99                         (int)sizeof(spl_image.name), spl_image.name,
100                         spl_image.load_addr, spl_image.size);
101         } else {
102                 /* Signature not found - assume u-boot.bin */
103                 debug("mkimage signature not found - ih_magic = %x\n",
104                         header->ih_magic);
105                 spl_set_header_raw_uboot();
106         }
107 }
108
109 __weak void __noreturn jump_to_image_no_args(struct spl_image_info *spl_image)
110 {
111         typedef void __noreturn (*image_entry_noargs_t)(void);
112
113         image_entry_noargs_t image_entry =
114                         (image_entry_noargs_t) spl_image->entry_point;
115
116         debug("image entry point: 0x%X\n", spl_image->entry_point);
117         image_entry();
118 }
119
120 #ifdef CONFIG_SPL_RAM_DEVICE
121 static void spl_ram_load_image(void)
122 {
123         const struct image_header *header;
124
125         /*
126          * Get the header.  It will point to an address defined by handoff
127          * which will tell where the image located inside the flash. For
128          * now, it will temporary fixed to address pointed by U-Boot.
129          */
130         header = (struct image_header *)
131                 (CONFIG_SYS_TEXT_BASE - sizeof(struct image_header));
132
133         spl_parse_image_header(header);
134 }
135 #endif
136
137 void board_init_r(gd_t *dummy1, ulong dummy2)
138 {
139         u32 boot_device;
140         debug(">>spl:board_init_r()\n");
141
142 #ifdef CONFIG_SYS_SPL_MALLOC_START
143         mem_malloc_init(CONFIG_SYS_SPL_MALLOC_START,
144                         CONFIG_SYS_SPL_MALLOC_SIZE);
145 #endif
146
147 #ifndef CONFIG_PPC
148         /*
149          * timer_init() does not exist on PPC systems. The timer is initialized
150          * and enabled (decrementer) in interrupt_init() here.
151          */
152         timer_init();
153 #endif
154
155 #ifdef CONFIG_SPL_BOARD_INIT
156         spl_board_init();
157 #endif
158
159         boot_device = spl_boot_device();
160         debug("boot device - %d\n", boot_device);
161         switch (boot_device) {
162 #ifdef CONFIG_SPL_RAM_DEVICE
163         case BOOT_DEVICE_RAM:
164                 spl_ram_load_image();
165                 break;
166 #endif
167 #ifdef CONFIG_SPL_MMC_SUPPORT
168         case BOOT_DEVICE_MMC1:
169         case BOOT_DEVICE_MMC2:
170         case BOOT_DEVICE_MMC2_2:
171                 spl_mmc_load_image();
172                 break;
173 #endif
174 #ifdef CONFIG_SPL_NAND_SUPPORT
175         case BOOT_DEVICE_NAND:
176                 spl_nand_load_image();
177                 break;
178 #endif
179 #ifdef CONFIG_SPL_ONENAND_SUPPORT
180         case BOOT_DEVICE_ONENAND:
181                 spl_onenand_load_image();
182                 break;
183 #endif
184 #ifdef CONFIG_SPL_NOR_SUPPORT
185         case BOOT_DEVICE_NOR:
186                 spl_nor_load_image();
187                 break;
188 #endif
189 #ifdef CONFIG_SPL_YMODEM_SUPPORT
190         case BOOT_DEVICE_UART:
191                 spl_ymodem_load_image();
192                 break;
193 #endif
194 #ifdef CONFIG_SPL_SPI_SUPPORT
195         case BOOT_DEVICE_SPI:
196                 spl_spi_load_image();
197                 break;
198 #endif
199 #ifdef CONFIG_SPL_ETH_SUPPORT
200         case BOOT_DEVICE_CPGMAC:
201 #ifdef CONFIG_SPL_ETH_DEVICE
202                 spl_net_load_image(CONFIG_SPL_ETH_DEVICE);
203 #else
204                 spl_net_load_image(NULL);
205 #endif
206                 break;
207 #endif
208 #ifdef CONFIG_SPL_USBETH_SUPPORT
209         case BOOT_DEVICE_USBETH:
210                 spl_net_load_image("usb_ether");
211                 break;
212 #endif
213 #ifdef CONFIG_SPL_USB_SUPPORT
214         case BOOT_DEVICE_USB:
215                 spl_usb_load_image();
216                 break;
217 #endif
218 #ifdef CONFIG_SPL_SATA_SUPPORT
219         case BOOT_DEVICE_SATA:
220                 spl_sata_load_image();
221                 break;
222 #endif
223         default:
224 #if defined(CONFIG_SPL_SERIAL_SUPPORT) && defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
225                 printf("SPL: Unsupported Boot Device %d\n", boot_device);
226 #endif
227                 hang();
228         }
229
230         switch (spl_image.os) {
231         case IH_OS_U_BOOT:
232                 debug("Jumping to U-Boot\n");
233                 break;
234 #ifdef CONFIG_SPL_OS_BOOT
235         case IH_OS_LINUX:
236                 debug("Jumping to Linux\n");
237                 spl_board_prepare_for_linux();
238                 jump_to_image_linux((void *)CONFIG_SYS_SPL_ARGS_ADDR);
239 #endif
240         default:
241                 debug("Unsupported OS image.. Jumping nevertheless..\n");
242         }
243         jump_to_image_no_args(&spl_image);
244 }
245
246 /*
247  * This requires UART clocks to be enabled.  In order for this to work the
248  * caller must ensure that the gd pointer is valid.
249  */
250 void preloader_console_init(void)
251 {
252         gd->bd = &bdata;
253         gd->baudrate = CONFIG_BAUDRATE;
254
255         serial_init();          /* serial communications setup */
256
257         gd->have_console = 1;
258
259         puts("\nU-Boot SPL " PLAIN_VERSION " (" U_BOOT_DATE " - " \
260                         U_BOOT_TIME ")\n");
261 #ifdef CONFIG_SPL_DISPLAY_PRINT
262         spl_display_print();
263 #endif
264 }