]>
Commit | Line | Data |
---|---|---|
83d290c5 | 1 | /* SPDX-License-Identifier: GPL-2.0+ */ |
47f7bcae TR |
2 | /* |
3 | * (C) Copyright 2012 | |
4 | * Texas Instruments, <www.ti.com> | |
47f7bcae TR |
5 | */ |
6 | #ifndef _SPL_H_ | |
7 | #define _SPL_H_ | |
8 | ||
8bee2d25 | 9 | #include <binman_sym.h> |
f7ae49fc | 10 | #include <linker_lists.h> |
8bee2d25 | 11 | |
47f7bcae | 12 | /* Platform-specific defines */ |
6507f133 | 13 | #include <linux/compiler.h> |
271cf2f4 | 14 | #include <asm/global_data.h> |
47f7bcae | 15 | #include <asm/spl.h> |
b0edea3c | 16 | #include <handoff.h> |
59073573 | 17 | #include <mmc.h> |
47f7bcae | 18 | |
271cf2f4 | 19 | struct blk_desc; |
f3543e69 | 20 | struct legacy_img_hdr; |
271cf2f4 | 21 | |
32ba8952 SG |
22 | /* Value in r0 indicates we booted from U-Boot */ |
23 | #define UBOOT_NOT_LOADED_FROM_SPL 0x13578642 | |
773b5940 | 24 | |
47f7bcae TR |
25 | /* Boot type */ |
26 | #define MMCSD_MODE_UNDEFINED 0 | |
27 | #define MMCSD_MODE_RAW 1 | |
205b4f33 | 28 | #define MMCSD_MODE_FS 2 |
7dbe63bc | 29 | #define MMCSD_MODE_EMMCBOOT 3 |
47f7bcae | 30 | |
e6f6f9e6 | 31 | struct blk_desc; |
f3543e69 | 32 | struct legacy_img_hdr; |
2e0429bc | 33 | struct spl_boot_device; |
c3dc39a2 | 34 | |
e945a726 SG |
35 | /* |
36 | * u_boot_first_phase() - check if this is the first U-Boot phase | |
37 | * | |
38 | * U-Boot has up to three phases: TPL, SPL and U-Boot proper. Depending on the | |
39 | * build flags we can determine whether the current build is for the first | |
40 | * phase of U-Boot or not. If there is no SPL, then this is U-Boot proper. If | |
41 | * there is SPL but no TPL, the the first phase is SPL. If there is TPL, then | |
42 | * it is the first phase. | |
43 | * | |
44 | * @returns true if this is the first phase of U-Boot | |
45 | * | |
46 | */ | |
47 | static inline bool u_boot_first_phase(void) | |
48 | { | |
49 | if (IS_ENABLED(CONFIG_TPL)) { | |
50 | if (IS_ENABLED(CONFIG_TPL_BUILD)) | |
51 | return true; | |
52 | } else if (IS_ENABLED(CONFIG_SPL)) { | |
53 | if (IS_ENABLED(CONFIG_SPL_BUILD)) | |
54 | return true; | |
55 | } else { | |
56 | return true; | |
57 | } | |
58 | ||
59 | return false; | |
60 | } | |
61 | ||
8e83b76d | 62 | enum u_boot_phase { |
09d9ba90 | 63 | PHASE_NONE, /* Invalid phase, signifying before U-Boot */ |
59c871bc | 64 | PHASE_TPL, /* Running in TPL */ |
f86ca5ad | 65 | PHASE_VPL, /* Running in VPL */ |
59c871bc SG |
66 | PHASE_SPL, /* Running in SPL */ |
67 | PHASE_BOARD_F, /* Running in U-Boot before relocation */ | |
68 | PHASE_BOARD_R, /* Running in U-Boot after relocation */ | |
8e83b76d SG |
69 | }; |
70 | ||
71 | /** | |
72 | * spl_phase() - Find out the phase of U-Boot | |
73 | * | |
74 | * This can be used to avoid #ifdef logic and use if() instead. | |
75 | * | |
76 | * For example, to include code only in TPL, you might do: | |
77 | * | |
78 | * #ifdef CONFIG_TPL_BUILD | |
79 | * ... | |
80 | * #endif | |
81 | * | |
82 | * but with this you can use: | |
83 | * | |
84 | * if (spl_phase() == PHASE_TPL) { | |
85 | * ... | |
86 | * } | |
87 | * | |
88 | * To include code only in SPL, you might do: | |
89 | * | |
90 | * #if defined(CONFIG_SPL_BUILD) && !defined(CONFIG_TPL_BUILD) | |
91 | * ... | |
92 | * #endif | |
93 | * | |
94 | * but with this you can use: | |
95 | * | |
96 | * if (spl_phase() == PHASE_SPL) { | |
97 | * ... | |
98 | * } | |
99 | * | |
100 | * To include code only in U-Boot proper, you might do: | |
101 | * | |
102 | * #ifndef CONFIG_SPL_BUILD | |
103 | * ... | |
104 | * #endif | |
105 | * | |
106 | * but with this you can use: | |
107 | * | |
59c871bc | 108 | * if (spl_phase() == PHASE_BOARD_F) { |
8e83b76d SG |
109 | * ... |
110 | * } | |
111 | * | |
185f812c | 112 | * Return: U-Boot phase |
8e83b76d SG |
113 | */ |
114 | static inline enum u_boot_phase spl_phase(void) | |
115 | { | |
116 | #ifdef CONFIG_TPL_BUILD | |
117 | return PHASE_TPL; | |
f86ca5ad SG |
118 | #elif defined(CONFIG_VPL_BUILD) |
119 | return PHASE_VPL; | |
120 | #elif defined(CONFIG_SPL_BUILD) | |
8e83b76d SG |
121 | return PHASE_SPL; |
122 | #else | |
59c871bc SG |
123 | DECLARE_GLOBAL_DATA_PTR; |
124 | ||
125 | if (!(gd->flags & GD_FLG_RELOC)) | |
126 | return PHASE_BOARD_F; | |
127 | else | |
128 | return PHASE_BOARD_R; | |
8e83b76d SG |
129 | #endif |
130 | } | |
131 | ||
09d9ba90 SG |
132 | /** |
133 | * spl_prev_phase() - Figure out the previous U-Boot phase | |
134 | * | |
185f812c | 135 | * Return: the previous phase from this one, e.g. if called in SPL this returns |
09d9ba90 SG |
136 | * PHASE_TPL, if TPL is enabled |
137 | */ | |
138 | static inline enum u_boot_phase spl_prev_phase(void) | |
139 | { | |
140 | #ifdef CONFIG_TPL_BUILD | |
141 | return PHASE_NONE; | |
f86ca5ad SG |
142 | #elif defined(CONFIG_VPL_BUILD) |
143 | return PHASE_TPL; /* VPL requires TPL */ | |
09d9ba90 | 144 | #elif defined(CONFIG_SPL_BUILD) |
f86ca5ad SG |
145 | return IS_ENABLED(CONFIG_VPL) ? PHASE_VPL : |
146 | IS_ENABLED(CONFIG_TPL) ? PHASE_TPL : | |
147 | PHASE_NONE; | |
09d9ba90 | 148 | #else |
f86ca5ad SG |
149 | return IS_ENABLED(CONFIG_SPL) ? PHASE_SPL : |
150 | PHASE_NONE; | |
09d9ba90 SG |
151 | #endif |
152 | } | |
153 | ||
154 | /** | |
155 | * spl_next_phase() - Figure out the next U-Boot phase | |
156 | * | |
185f812c | 157 | * Return: the next phase from this one, e.g. if called in TPL this returns |
09d9ba90 SG |
158 | * PHASE_SPL |
159 | */ | |
160 | static inline enum u_boot_phase spl_next_phase(void) | |
161 | { | |
162 | #ifdef CONFIG_TPL_BUILD | |
f86ca5ad SG |
163 | return IS_ENABLED(CONFIG_VPL) ? PHASE_VPL : PHASE_SPL; |
164 | #elif defined(CONFIG_VPL_BUILD) | |
09d9ba90 SG |
165 | return PHASE_SPL; |
166 | #else | |
167 | return PHASE_BOARD_F; | |
168 | #endif | |
169 | } | |
170 | ||
171 | /** | |
172 | * spl_phase_name() - Get the name of the current phase | |
173 | * | |
185f812c | 174 | * Return: phase name |
09d9ba90 SG |
175 | */ |
176 | static inline const char *spl_phase_name(enum u_boot_phase phase) | |
177 | { | |
178 | switch (phase) { | |
179 | case PHASE_TPL: | |
180 | return "TPL"; | |
f86ca5ad SG |
181 | case PHASE_VPL: |
182 | return "VPL"; | |
09d9ba90 SG |
183 | case PHASE_SPL: |
184 | return "SPL"; | |
185 | case PHASE_BOARD_F: | |
186 | case PHASE_BOARD_R: | |
187 | return "U-Boot"; | |
188 | default: | |
189 | return "phase?"; | |
190 | } | |
191 | } | |
192 | ||
f178bebf SG |
193 | /** |
194 | * spl_phase_prefix() - Get the prefix of the current phase | |
195 | * | |
196 | * @phase: Phase to look up | |
185f812c | 197 | * Return: phase prefix ("spl", "tpl", etc.) |
f178bebf SG |
198 | */ |
199 | static inline const char *spl_phase_prefix(enum u_boot_phase phase) | |
200 | { | |
201 | switch (phase) { | |
202 | case PHASE_TPL: | |
203 | return "tpl"; | |
f86ca5ad SG |
204 | case PHASE_VPL: |
205 | return "vpl"; | |
f178bebf SG |
206 | case PHASE_SPL: |
207 | return "spl"; | |
208 | case PHASE_BOARD_F: | |
209 | case PHASE_BOARD_R: | |
210 | return ""; | |
211 | default: | |
212 | return "phase?"; | |
213 | } | |
214 | } | |
215 | ||
d6330064 SG |
216 | /* A string name for SPL or TPL */ |
217 | #ifdef CONFIG_SPL_BUILD | |
218 | # ifdef CONFIG_TPL_BUILD | |
8fb2391e | 219 | # define SPL_TPL_NAME "TPL" |
f86ca5ad SG |
220 | # elif defined(CONFIG_VPL_BUILD) |
221 | # define SPL_TPL_NAME "VPL" | |
d6330064 | 222 | # else |
8fb2391e | 223 | # define SPL_TPL_NAME "SPL" |
d6330064 SG |
224 | # endif |
225 | # define SPL_TPL_PROMPT SPL_TPL_NAME ": " | |
226 | #else | |
227 | # define SPL_TPL_NAME "" | |
228 | # define SPL_TPL_PROMPT "" | |
229 | #endif | |
230 | ||
47f7bcae TR |
231 | struct spl_image_info { |
232 | const char *name; | |
233 | u8 os; | |
f2efe678 PT |
234 | uintptr_t load_addr; |
235 | uintptr_t entry_point; | |
a9a8271e | 236 | #if CONFIG_IS_ENABLED(LOAD_FIT) || CONFIG_IS_ENABLED(LOAD_FIT_FULL) |
75014470 PT |
237 | void *fdt_addr; |
238 | #endif | |
de5dd4c4 | 239 | u32 boot_device; |
5fce2875 | 240 | u32 offset; |
47f7bcae | 241 | u32 size; |
022b4975 | 242 | u32 flags; |
5bf5250e | 243 | void *arg; |
dae5c2dc SG |
244 | #ifdef CONFIG_SPL_LEGACY_IMAGE_CRC_CHECK |
245 | ulong dcrc_data; | |
246 | ulong dcrc_length; | |
247 | ulong dcrc; | |
248 | #endif | |
47f7bcae TR |
249 | }; |
250 | ||
146a17ad | 251 | /** |
f1dcee59 SG |
252 | * Information required to load data from a device |
253 | * | |
254 | * @dev: Pointer to the device, e.g. struct mmc * | |
255 | * @priv: Private data for the device | |
256 | * @bl_len: Block length for reading in bytes | |
eafd5410 | 257 | * @filename: Name of the fit image file. |
f1dcee59 SG |
258 | * @read: Function to call to read from the device |
259 | */ | |
260 | struct spl_load_info { | |
261 | void *dev; | |
262 | void *priv; | |
263 | int bl_len; | |
eafd5410 | 264 | const char *filename; |
2e059e4a SG |
265 | /** |
266 | * read() - Read from device | |
267 | * | |
268 | * @load: Information about the load state | |
269 | * @sector: Sector number to read from (each @load->bl_len bytes) | |
270 | * @count: Number of sectors to read | |
271 | * @buf: Buffer to read into | |
272 | * @return number of sectors read, 0 on error | |
273 | */ | |
f1dcee59 SG |
274 | ulong (*read)(struct spl_load_info *load, ulong sector, ulong count, |
275 | void *buf); | |
276 | }; | |
277 | ||
8bee2d25 SG |
278 | /* |
279 | * We need to know the position of U-Boot in memory so we can jump to it. We | |
280 | * allow any U-Boot binary to be used (u-boot.bin, u-boot-nodtb.bin, | |
281 | * u-boot.img), hence the '_any'. These is no checking here that the correct | |
e82c624d | 282 | * image is found. For example if u-boot.img is used we don't check that |
8bee2d25 | 283 | * spl_parse_image_header() can parse a valid header. |
e82c624d SG |
284 | * |
285 | * Similarly for SPL, so that TPL can jump to SPL. | |
8bee2d25 | 286 | */ |
dbf6be9f | 287 | binman_sym_extern(ulong, u_boot_any, image_pos); |
e82c624d | 288 | binman_sym_extern(ulong, u_boot_any, size); |
00959d87 SG |
289 | binman_sym_extern(ulong, u_boot_spl, image_pos); |
290 | binman_sym_extern(ulong, u_boot_spl, size); | |
5204823c ANY |
291 | binman_sym_extern(ulong, u_boot_vpl, image_pos); |
292 | binman_sym_extern(ulong, u_boot_vpl, size); | |
e82c624d SG |
293 | |
294 | /** | |
295 | * spl_get_image_pos() - get the image position of the next phase | |
296 | * | |
297 | * This returns the image position to use to load the next phase of U-Boot | |
298 | */ | |
299 | ulong spl_get_image_pos(void); | |
300 | ||
301 | /** | |
302 | * spl_get_image_size() - get the size of the next phase | |
303 | * | |
304 | * This returns the size to use to load the next phase of U-Boot | |
305 | */ | |
306 | ulong spl_get_image_size(void); | |
8bee2d25 | 307 | |
86c372af SG |
308 | /** |
309 | * spl_get_image_text_base() - get the text base of the next phase | |
310 | * | |
311 | * This returns the address that the next stage is linked to run at, i.e. | |
98463903 | 312 | * CONFIG_SPL_TEXT_BASE or CONFIG_TEXT_BASE |
86c372af | 313 | * |
185f812c | 314 | * Return: text-base address |
86c372af SG |
315 | */ |
316 | ulong spl_get_image_text_base(void); | |
317 | ||
e1eb6ada AD |
318 | /** |
319 | * spl_load_simple_fit_skip_processing() - Hook to allow skipping the FIT | |
320 | * image processing during spl_load_simple_fit(). | |
321 | * | |
322 | * Return true to skip FIT processing, false to preserve the full code flow | |
323 | * of spl_load_simple_fit(). | |
324 | */ | |
325 | bool spl_load_simple_fit_skip_processing(void); | |
326 | ||
884ba50a HS |
327 | /** |
328 | * spl_load_simple_fit_fix_load() - Hook to make fixes | |
329 | * after fit image header is loaded | |
330 | * | |
331 | * Returns pointer to fit | |
332 | */ | |
333 | void *spl_load_simple_fit_fix_load(const void *fit); | |
334 | ||
eafd5410 LV |
335 | /** |
336 | * spl_load_simple_fit() - Loads a fit image from a device. | |
f4d7d859 | 337 | * @spl_image: Image description to set up |
eafd5410 LV |
338 | * @info: Structure containing the information required to load data. |
339 | * @sector: Sector number where FIT image is located in the device | |
340 | * @fdt: Pointer to the copied FIT header. | |
341 | * | |
342 | * Reads the FIT image @sector in the device. Loads u-boot image to | |
343 | * specified load address and copies the dtb to end of u-boot image. | |
344 | * Returns 0 on success. | |
345 | */ | |
f4d7d859 SG |
346 | int spl_load_simple_fit(struct spl_image_info *spl_image, |
347 | struct spl_load_info *info, ulong sector, void *fdt); | |
f1dcee59 | 348 | |
022b4975 | 349 | #define SPL_COPY_PAYLOAD_ONLY 1 |
e246bfcf | 350 | #define SPL_FIT_FOUND 2 |
022b4975 | 351 | |
2fc91ed3 SR |
352 | /** |
353 | * spl_load_legacy_img() - Loads a legacy image from a device. | |
354 | * @spl_image: Image description to set up | |
355 | * @load: Structure containing the information required to load data. | |
06377c5a RQ |
356 | * @offset: Pointer to image |
357 | * @hdr: Pointer to image header | |
2fc91ed3 SR |
358 | * |
359 | * Reads an legacy image from the device. Loads u-boot image to | |
360 | * specified load address. | |
361 | * Returns 0 on success. | |
362 | */ | |
363 | int spl_load_legacy_img(struct spl_image_info *spl_image, | |
2e0429bc | 364 | struct spl_boot_device *bootdev, |
06377c5a RQ |
365 | struct spl_load_info *load, ulong offset, |
366 | struct legacy_img_hdr *hdr); | |
367 | ||
2fc91ed3 | 368 | |
dd7d0911 PF |
369 | /** |
370 | * spl_load_imx_container() - Loads a imx container image from a device. | |
371 | * @spl_image: Image description to set up | |
372 | * @info: Structure containing the information required to load data. | |
373 | * @sector: Sector number where container image is located in the device | |
374 | * | |
375 | * Reads the container image @sector in the device. Loads u-boot image to | |
376 | * specified load address. | |
377 | */ | |
378 | int spl_load_imx_container(struct spl_image_info *spl_image, | |
379 | struct spl_load_info *info, ulong sector); | |
380 | ||
47f7bcae TR |
381 | /* SPL common functions */ |
382 | void preloader_console_init(void); | |
383 | u32 spl_boot_device(void); | |
e9759065 | 384 | |
6dd18a65 VA |
385 | /** |
386 | * spl_spi_boot_bus() - Lookup function for the SPI boot bus source. | |
387 | * | |
388 | * This function returns the SF bus to load from. | |
389 | * If not overridden, it is weakly defined in common/spl/spl_spi.c. | |
390 | */ | |
391 | u32 spl_spi_boot_bus(void); | |
392 | ||
393 | /** | |
394 | * spl_spi_boot_cs() - Lookup function for the SPI boot CS source. | |
395 | * | |
396 | * This function returns the SF CS to load from. | |
397 | * If not overridden, it is weakly defined in common/spl/spl_spi.c. | |
398 | */ | |
399 | u32 spl_spi_boot_cs(void); | |
400 | ||
e9759065 HS |
401 | /** |
402 | * spl_mmc_boot_mode() - Lookup function for the mode of an MMC boot source. | |
403 | * @boot_device: ID of the device which the MMC driver wants to read | |
404 | * from. Common values are e.g. BOOT_DEVICE_MMC1, | |
405 | * BOOT_DEVICE_MMC2, BOOT_DEVICE_MMC2_2. | |
406 | * | |
407 | * This function should return one of MMCSD_MODE_FS, MMCSD_MODE_EMMCBOOT, or | |
408 | * MMCSD_MODE_RAW for each MMC boot source which is defined for the target. The | |
409 | * boot_device parameter tells which device the MMC driver is interested in. | |
410 | * | |
411 | * If not overridden, it is weakly defined in common/spl/spl_mmc.c. | |
412 | * | |
413 | * Note: It is important to use the boot_device parameter instead of e.g. | |
414 | * spl_boot_device() as U-Boot is not always loaded from the same device as SPL. | |
415 | */ | |
59073573 | 416 | u32 spl_mmc_boot_mode(struct mmc *mmc, const u32 boot_device); |
c51b7518 HS |
417 | |
418 | /** | |
419 | * spl_mmc_boot_partition() - MMC partition to load U-Boot from. | |
420 | * @boot_device: ID of the device which the MMC driver wants to load | |
421 | * U-Boot from. | |
422 | * | |
423 | * This function should return the partition number which the SPL | |
424 | * should load U-Boot from (on the given boot_device) when | |
425 | * CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_USE_PARTITION is set. | |
426 | * | |
427 | * If not overridden, it is weakly defined in common/spl/spl_mmc.c. | |
428 | */ | |
429 | int spl_mmc_boot_partition(const u32 boot_device); | |
9b191591 MV |
430 | |
431 | struct mmc; | |
432 | /** | |
433 | * default_spl_mmc_emmc_boot_partition() - eMMC boot partition to load U-Boot from. | |
434 | * mmc: Pointer for the mmc device structure | |
435 | * | |
436 | * This function should return the eMMC boot partition number which | |
437 | * the SPL should load U-Boot from (on the given boot_device). | |
438 | */ | |
439 | int default_spl_mmc_emmc_boot_partition(struct mmc *mmc); | |
440 | ||
441 | /** | |
442 | * spl_mmc_emmc_boot_partition() - eMMC boot partition to load U-Boot from. | |
443 | * mmc: Pointer for the mmc device structure | |
444 | * | |
445 | * This function should return the eMMC boot partition number which | |
446 | * the SPL should load U-Boot from (on the given boot_device). | |
447 | * | |
448 | * If not overridden, it is weakly defined in common/spl/spl_mmc.c | |
449 | * and calls default_spl_mmc_emmc_boot_partition(); | |
450 | */ | |
451 | int spl_mmc_emmc_boot_partition(struct mmc *mmc); | |
452 | ||
58b504e5 | 453 | void spl_set_bd(void); |
d95ceb97 SG |
454 | |
455 | /** | |
456 | * spl_set_header_raw_uboot() - Set up a standard SPL image structure | |
457 | * | |
458 | * This sets up the given spl_image which the standard values obtained from | |
459 | * config options: CONFIG_SYS_MONITOR_LEN, CONFIG_SYS_UBOOT_START, | |
98463903 | 460 | * CONFIG_TEXT_BASE. |
d95ceb97 | 461 | * |
71316c1d | 462 | * @spl_image: Image description to set up |
d95ceb97 SG |
463 | */ |
464 | void spl_set_header_raw_uboot(struct spl_image_info *spl_image); | |
465 | ||
71316c1d SG |
466 | /** |
467 | * spl_parse_image_header() - parse the image header and set up info | |
468 | * | |
469 | * This parses the legacy image header information at @header and sets up | |
470 | * @spl_image according to what is found. If no image header is found, then | |
471 | * a raw image or bootz is assumed. If CONFIG_SPL_PANIC_ON_RAW_IMAGE is | |
24eb39b5 | 472 | * enabled, then this causes a panic. If CONFIG_SPL_RAW_IMAGE_SUPPORT is not |
71316c1d SG |
473 | * enabled then U-Boot gives up. Otherwise U-Boot sets up the image using |
474 | * spl_set_header_raw_uboot(), or possibly the bootz header. | |
475 | * | |
476 | * @spl_image: Image description to set up | |
477 | * @header image header to parse | |
185f812c | 478 | * Return: 0 if a header was correctly parsed, -ve on error |
71316c1d SG |
479 | */ |
480 | int spl_parse_image_header(struct spl_image_info *spl_image, | |
2e0429bc | 481 | const struct spl_boot_device *bootdev, |
f3543e69 | 482 | const struct legacy_img_hdr *header); |
71316c1d | 483 | |
47f7bcae | 484 | void spl_board_prepare_for_linux(void); |
a25d6b65 AG |
485 | |
486 | /** | |
487 | * spl_board_prepare_for_optee() - Prepare board for an OPTEE payload | |
488 | * | |
489 | * Prepares the board for booting an OP-TEE payload. Initialization is platform | |
490 | * specific, and may include configuring the TrustZone memory, and other | |
491 | * initialization steps required by OP-TEE. | |
492 | * Note that @fdt is not used directly by OP-TEE. OP-TEE passes this @fdt to | |
493 | * its normal world target. This target is not guaranteed to be u-boot, so @fdt | |
494 | * changes that would normally be done by u-boot should be done in this step. | |
495 | * | |
496 | * @fdt: Devicetree that will be passed on, or NULL | |
497 | */ | |
498 | void spl_board_prepare_for_optee(void *fdt); | |
3a3b9147 | 499 | void spl_board_prepare_for_boot(void); |
bf55cd4f | 500 | int spl_board_ubi_load_image(u32 boot_device); |
40eeb9c4 | 501 | int spl_board_boot_device(u32 boot_device); |
ca12e65c | 502 | |
c5922923 HT |
503 | /** |
504 | * spl_board_loader_name() - Return a name for the loader | |
505 | * | |
506 | * This is a weak function which might be overridden by the board code. With | |
507 | * that a board specific value for the device where the U-Boot will be loaded | |
508 | * from can be set. By default it returns NULL. | |
509 | * | |
510 | * @boot_device: ID of the device which SPL wants to load U-Boot from. | |
511 | */ | |
512 | const char *spl_board_loader_name(u32 boot_device); | |
513 | ||
ca12e65c SG |
514 | /** |
515 | * jump_to_image_linux() - Jump to a Linux kernel from SPL | |
516 | * | |
517 | * This jumps into a Linux kernel using the information in @spl_image. | |
518 | * | |
519 | * @spl_image: Image description to set up | |
ca12e65c | 520 | */ |
5bf5250e | 521 | void __noreturn jump_to_image_linux(struct spl_image_info *spl_image); |
f59961e3 | 522 | |
949eb228 RS |
523 | /** |
524 | * jump_to_image_linux() - Jump to OP-TEE OS from SPL | |
525 | * | |
526 | * This jumps into OP-TEE OS using the information in @spl_image. | |
527 | * | |
528 | * @spl_image: Image description to set up | |
529 | */ | |
530 | void __noreturn jump_to_image_optee(struct spl_image_info *spl_image); | |
531 | ||
f59961e3 SG |
532 | /** |
533 | * spl_start_uboot() - Check if SPL should start the kernel or U-Boot | |
534 | * | |
535 | * This is called by the various SPL loaders to determine whether the board | |
536 | * wants to load the kernel or U-Boot. This function should be provided by | |
537 | * the board. | |
538 | * | |
185f812c | 539 | * Return: 0 if SPL should start the kernel, 1 if U-Boot must be started |
f59961e3 | 540 | */ |
47f7bcae | 541 | int spl_start_uboot(void); |
f59961e3 | 542 | |
a807ab33 SG |
543 | /** |
544 | * spl_display_print() - Display a board-specific message in SPL | |
545 | * | |
546 | * If CONFIG_SPL_DISPLAY_PRINT is enabled, U-Boot will call this function | |
547 | * immediately after displaying the SPL console banner ("U-Boot SPL ..."). | |
548 | * This function should be provided by the board. | |
549 | */ | |
47f7bcae TR |
550 | void spl_display_print(void); |
551 | ||
ecdfd69a SG |
552 | /** |
553 | * struct spl_boot_device - Describes a boot device used by SPL | |
554 | * | |
555 | * @boot_device: A number indicating the BOOT_DEVICE type. There are various | |
556 | * BOOT_DEVICE... #defines and enums in U-Boot and they are not consistently | |
557 | * numbered. | |
558 | * @boot_device_name: Named boot device, or NULL if none. | |
559 | * | |
560 | * Note: Additional fields can be added here, bearing in mind that SPL is | |
561 | * size-sensitive and common fields will be present on all boards. This | |
562 | * struct can also be used to return additional information about the load | |
563 | * process if that becomes useful. | |
564 | */ | |
565 | struct spl_boot_device { | |
566 | uint boot_device; | |
567 | const char *boot_device_name; | |
568 | }; | |
569 | ||
a0a80290 SG |
570 | /** |
571 | * Holds information about a way of loading an SPL image | |
572 | * | |
ebc4ef61 | 573 | * @name: User-friendly name for this method (e.g. "MMC") |
a0a80290 SG |
574 | * @boot_device: Boot device that this loader supports |
575 | * @load_image: Function to call to load image | |
576 | */ | |
577 | struct spl_image_loader { | |
ebc4ef61 SG |
578 | #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT |
579 | const char *name; | |
580 | #endif | |
a0a80290 SG |
581 | uint boot_device; |
582 | /** | |
583 | * load_image() - Load an SPL image | |
584 | * | |
2a2ee2ac | 585 | * @spl_image: place to put image information |
a0a80290 SG |
586 | * @bootdev: describes the boot device to load from |
587 | */ | |
2a2ee2ac SG |
588 | int (*load_image)(struct spl_image_info *spl_image, |
589 | struct spl_boot_device *bootdev); | |
a0a80290 SG |
590 | }; |
591 | ||
7d84fbb5 SG |
592 | /* Helper function for accessing the name */ |
593 | static inline const char *spl_loader_name(const struct spl_image_loader *loader) | |
594 | { | |
595 | #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT | |
c5922923 HT |
596 | const char *name; |
597 | name = spl_board_loader_name(loader->boot_device); | |
598 | return name ?: loader->name; | |
7d84fbb5 SG |
599 | #else |
600 | return NULL; | |
601 | #endif | |
602 | } | |
603 | ||
a0a80290 SG |
604 | /* Declare an SPL image loader */ |
605 | #define SPL_LOAD_IMAGE(__name) \ | |
606 | ll_entry_declare(struct spl_image_loader, __name, spl_image_loader) | |
607 | ||
608 | /* | |
0d3b0591 | 609 | * _priority is the priority of this method, 0 meaning it will be the top |
a0a80290 | 610 | * choice for this device, 9 meaning it is the bottom choice. |
0d3b0591 SG |
611 | * _boot_device is the BOOT_DEVICE_... value |
612 | * _method is the load_image function to call | |
a0a80290 | 613 | */ |
ebc4ef61 SG |
614 | #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT |
615 | #define SPL_LOAD_IMAGE_METHOD(_name, _priority, _boot_device, _method) \ | |
e1500a6c | 616 | SPL_LOAD_IMAGE(_boot_device ## _priority ## _method) = { \ |
ebc4ef61 SG |
617 | .name = _name, \ |
618 | .boot_device = _boot_device, \ | |
619 | .load_image = _method, \ | |
620 | } | |
621 | #else | |
622 | #define SPL_LOAD_IMAGE_METHOD(_name, _priority, _boot_device, _method) \ | |
e1500a6c | 623 | SPL_LOAD_IMAGE(_boot_device ## _priority ## _method) = { \ |
0d3b0591 SG |
624 | .boot_device = _boot_device, \ |
625 | .load_image = _method, \ | |
a0a80290 | 626 | } |
ebc4ef61 | 627 | #endif |
a0a80290 | 628 | |
773b5940 | 629 | /* SPL FAT image functions */ |
710e9ca5 | 630 | int spl_load_image_fat(struct spl_image_info *spl_image, |
2e0429bc | 631 | struct spl_boot_device *bootdev, |
710e9ca5 | 632 | struct blk_desc *block_dev, int partition, |
4101f687 | 633 | const char *filename); |
710e9ca5 | 634 | int spl_load_image_fat_os(struct spl_image_info *spl_image, |
2e0429bc | 635 | struct spl_boot_device *bootdev, |
710e9ca5 | 636 | struct blk_desc *block_dev, int partition); |
773b5940 | 637 | |
ce048224 JH |
638 | void __noreturn jump_to_image_no_args(struct spl_image_info *spl_image); |
639 | ||
592f9222 | 640 | /* SPL EXT image functions */ |
b4a6c2aa | 641 | int spl_load_image_ext(struct spl_image_info *spl_image, |
2e0429bc | 642 | struct spl_boot_device *bootdev, |
b4a6c2aa | 643 | struct blk_desc *block_dev, int partition, |
4101f687 | 644 | const char *filename); |
b4a6c2aa | 645 | int spl_load_image_ext_os(struct spl_image_info *spl_image, |
2e0429bc | 646 | struct spl_boot_device *bootdev, |
b4a6c2aa | 647 | struct blk_desc *block_dev, int partition); |
592f9222 | 648 | |
070d00b8 | 649 | /** |
340f418a | 650 | * spl_early_init() - Set up device tree and driver model in SPL if enabled |
070d00b8 SG |
651 | * |
652 | * Call this function in board_init_f() if you want to use device tree and | |
340f418a EC |
653 | * driver model early, before board_init_r() is called. |
654 | * | |
655 | * If this is not called, then driver model will be inactive in SPL's | |
656 | * board_init_f(), and no device tree will be available. | |
657 | */ | |
658 | int spl_early_init(void); | |
659 | ||
660 | /** | |
661 | * spl_init() - Set up device tree and driver model in SPL if enabled | |
662 | * | |
663 | * You can optionally call spl_early_init(), then optionally call spl_init(). | |
664 | * This function will be called from board_init_r() if not called earlier. | |
665 | * | |
666 | * Both spl_early_init() and spl_init() perform a similar function except that | |
667 | * the latter will not set up the malloc() area if | |
668 | * CONFIG_SPL_STACK_R_MALLOC_SIMPLE_LEN is enabled, since it is assumed to | |
669 | * already be done by a calll to spl_relocate_stack_gd() before board_init_r() | |
670 | * is reached. | |
671 | * | |
672 | * This function will be called from board_init_r() if not called earlier. | |
070d00b8 SG |
673 | * |
674 | * If this is not called, then driver model will be inactive in SPL's | |
675 | * board_init_f(), and no device tree will be available. | |
676 | */ | |
677 | int spl_init(void); | |
678 | ||
47f7bcae TR |
679 | #ifdef CONFIG_SPL_BOARD_INIT |
680 | void spl_board_init(void); | |
681 | #endif | |
32ba8952 SG |
682 | |
683 | /** | |
684 | * spl_was_boot_source() - check if U-Boot booted from SPL | |
685 | * | |
686 | * This will normally be true, but if U-Boot jumps to second U-Boot, it will | |
687 | * be false. This should be implemented by board-specific code. | |
688 | * | |
185f812c | 689 | * Return: true if U-Boot booted from SPL, else false |
32ba8952 SG |
690 | */ |
691 | bool spl_was_boot_source(void); | |
692 | ||
52f2acc5 R |
693 | /** |
694 | * spl_dfu_cmd- run dfu command with chosen mmc device interface | |
695 | * @param usb_index - usb controller number | |
696 | * @param mmc_dev - mmc device nubmer | |
697 | * | |
185f812c | 698 | * Return: 0 on success, otherwise error code |
52f2acc5 R |
699 | */ |
700 | int spl_dfu_cmd(int usbctrl, char *dfu_alt_info, char *interface, char *devstr); | |
e50d76cc | 701 | |
09410c65 MV |
702 | int spl_mmc_load_image(struct spl_image_info *spl_image, |
703 | struct spl_boot_device *bootdev); | |
704 | ||
e1eb6ada AD |
705 | /** |
706 | * spl_mmc_load() - Load an image file from MMC/SD media | |
707 | * | |
708 | * @param spl_image Image data filled in by loading process | |
709 | * @param bootdev Describes which device to load from | |
710 | * @param filename Name of file to load (in FS mode) | |
711 | * @param raw_part Partition to load from (in RAW mode) | |
712 | * @param raw_sect Sector to load from (in RAW mode) | |
713 | * | |
185f812c | 714 | * Return: 0 on success, otherwise error code |
e1eb6ada AD |
715 | */ |
716 | int spl_mmc_load(struct spl_image_info *spl_image, | |
717 | struct spl_boot_device *bootdev, | |
718 | const char *filename, | |
719 | int raw_part, | |
720 | unsigned long raw_sect); | |
721 | ||
c3ab97c1 FA |
722 | /** |
723 | * spl_usb_load() - Load an image file from USB mass storage | |
724 | * | |
725 | * @param spl_image Image data filled in by loading process | |
726 | * @param bootdev Describes which device to load from | |
727 | * @param raw_part Fat partition to load from | |
728 | * @param filename Name of file to load | |
729 | * | |
185f812c | 730 | * Return: 0 on success, otherwise error code |
c3ab97c1 FA |
731 | */ |
732 | int spl_usb_load(struct spl_image_info *spl_image, | |
733 | struct spl_boot_device *bootdev, | |
734 | int partition, const char *filename); | |
735 | ||
e413033d AD |
736 | int spl_ymodem_load_image(struct spl_image_info *spl_image, |
737 | struct spl_boot_device *bootdev); | |
738 | ||
f2efe678 PT |
739 | /** |
740 | * spl_invoke_atf - boot using an ARM trusted firmware image | |
741 | */ | |
742 | void spl_invoke_atf(struct spl_image_info *spl_image); | |
225d30b7 | 743 | |
5c03c990 | 744 | /** |
d2cb0c8f MW |
745 | * bl2_plat_get_bl31_params() - return params for bl31. |
746 | * @bl32_entry: address of BL32 executable (secure) | |
747 | * @bl33_entry: address of BL33 executable (non secure) | |
748 | * @fdt_addr: address of Flat Device Tree | |
5c03c990 | 749 | * |
d2cb0c8f MW |
750 | * This is a weak function which might be overridden by the board code. By |
751 | * default it will just call bl2_plat_get_bl31_params_default(). | |
5c03c990 | 752 | * |
d2cb0c8f MW |
753 | * If you just want to manipulate or add some parameters, you can override |
754 | * this function, call bl2_plat_get_bl31_params_default and operate on the | |
755 | * returned bl31 params. | |
756 | * | |
757 | * Return: bl31 params structure pointer | |
5c03c990 MS |
758 | */ |
759 | struct bl31_params *bl2_plat_get_bl31_params(uintptr_t bl32_entry, | |
760 | uintptr_t bl33_entry, | |
761 | uintptr_t fdt_addr); | |
762 | ||
d2cb0c8f MW |
763 | /** |
764 | * bl2_plat_get_bl31_params_default() - prepare params for bl31. | |
765 | * @bl32_entry: address of BL32 executable (secure) | |
766 | * @bl33_entry: address of BL33 executable (non secure) | |
767 | * @fdt_addr: address of Flat Device Tree | |
768 | * | |
769 | * This is the default implementation of bl2_plat_get_bl31_params(). It assigns | |
770 | * a pointer to the memory that the platform has kept aside to pass platform | |
771 | * specific and trusted firmware related information to BL31. This memory is | |
772 | * allocated by allocating memory to bl2_to_bl31_params_mem structure which is | |
773 | * a superset of all the structure whose information is passed to BL31 | |
774 | * | |
775 | * NOTE: The memory is statically allocated, thus this function should be | |
776 | * called only once. All subsequent calls will overwrite any changes. | |
777 | * | |
778 | * Return: bl31 params structure pointer | |
779 | */ | |
780 | struct bl31_params *bl2_plat_get_bl31_params_default(uintptr_t bl32_entry, | |
781 | uintptr_t bl33_entry, | |
782 | uintptr_t fdt_addr); | |
7b866825 MW |
783 | |
784 | /** | |
785 | * bl2_plat_get_bl31_params_v2() - return params for bl31 | |
786 | * @bl32_entry: address of BL32 executable (secure) | |
787 | * @bl33_entry: address of BL33 executable (non secure) | |
788 | * @fdt_addr: address of Flat Device Tree | |
789 | * | |
790 | * This function does the same as bl2_plat_get_bl31_params() except that is is | |
791 | * used for the new LOAD_IMAGE_V2 option, which uses a slightly different | |
792 | * method to pass the parameters. | |
793 | * | |
794 | * Return: bl31 params structure pointer | |
795 | */ | |
796 | struct bl_params *bl2_plat_get_bl31_params_v2(uintptr_t bl32_entry, | |
797 | uintptr_t bl33_entry, | |
798 | uintptr_t fdt_addr); | |
799 | ||
800 | /** | |
801 | * bl2_plat_get_bl31_params_v2_default() - prepare params for bl31. | |
802 | * @bl32_entry: address of BL32 executable (secure) | |
803 | * @bl33_entry: address of BL33 executable (non secure) | |
804 | * @fdt_addr: address of Flat Device Tree | |
805 | * | |
806 | * This is the default implementation of bl2_plat_get_bl31_params_v2(). It | |
807 | * prepares the linked list of the bl31 params, populates the image types and | |
808 | * set the entry points for bl32 and bl33 (if available). | |
809 | * | |
810 | * NOTE: The memory is statically allocated, thus this function should be | |
811 | * called only once. All subsequent calls will overwrite any changes. | |
812 | * | |
813 | * Return: bl31 params structure pointer | |
814 | */ | |
815 | struct bl_params *bl2_plat_get_bl31_params_v2_default(uintptr_t bl32_entry, | |
816 | uintptr_t bl33_entry, | |
817 | uintptr_t fdt_addr); | |
70fe2876 KY |
818 | /** |
819 | * spl_optee_entry - entry function for optee | |
820 | * | |
821 | * args defind in op-tee project | |
822 | * https://github.com/OP-TEE/optee_os/ | |
823 | * core/arch/arm/kernel/generic_entry_a32.S | |
824 | * @arg0: pagestore | |
825 | * @arg1: (ARMv7 standard bootarg #1) | |
826 | * @arg2: device tree address, (ARMv7 standard bootarg #2) | |
827 | * @arg3: non-secure entry address (ARMv7 bootarg #0) | |
828 | */ | |
949eb228 | 829 | void __noreturn spl_optee_entry(void *arg0, void *arg1, void *arg2, void *arg3); |
70fe2876 | 830 | |
5e30e45c LA |
831 | /** |
832 | * spl_invoke_opensbi - boot using a RISC-V OpenSBI image | |
833 | */ | |
834 | void spl_invoke_opensbi(struct spl_image_info *spl_image); | |
835 | ||
225d30b7 PT |
836 | /** |
837 | * board_return_to_bootrom - allow for boards to continue with the boot ROM | |
838 | * | |
839 | * If a board (e.g. the Rockchip RK3368 boards) provide some | |
840 | * supporting functionality for SPL in their boot ROM and the SPL | |
841 | * stage wants to return to the ROM code to continue booting, boards | |
842 | * can implement 'board_return_to_bootrom'. | |
843 | */ | |
cda789a5 PF |
844 | int board_return_to_bootrom(struct spl_image_info *spl_image, |
845 | struct spl_boot_device *bootdev); | |
de5dd4c4 | 846 | |
28ded1f3 PF |
847 | /** |
848 | * board_spl_fit_post_load - allow process images after loading finished | |
efc4ad0b | 849 | * @fit: Pointer to a valid Flattened Image Tree blob |
28ded1f3 | 850 | */ |
efc4ad0b | 851 | void board_spl_fit_post_load(const void *fit); |
28ded1f3 PF |
852 | |
853 | /** | |
854 | * board_spl_fit_size_align - specific size align before processing payload | |
855 | * | |
856 | */ | |
857 | ulong board_spl_fit_size_align(ulong size); | |
858 | ||
de5dd4c4 PT |
859 | /** |
860 | * spl_perform_fixups() - arch/board-specific callback before processing | |
861 | * the boot-payload | |
862 | */ | |
863 | void spl_perform_fixups(struct spl_image_info *spl_image); | |
04ce5427 MV |
864 | |
865 | /* | |
866 | * spl_get_load_buffer() - get buffer for loading partial image data | |
867 | * | |
868 | * Returns memory area which can be populated by partial image data, | |
869 | * ie. uImage or fitImage header. | |
870 | */ | |
f3543e69 | 871 | struct legacy_img_hdr *spl_get_load_buffer(ssize_t offset, size_t size); |
04ce5427 | 872 | |
6aead233 | 873 | void spl_save_restore_data(void); |
47f7bcae | 874 | #endif |