blob: 90395fedb0fd35e0d2b5ceb52295dca81334580b [file] [log] [blame]
Tom Rini10e47792018-05-06 17:58:06 -04001/* SPDX-License-Identifier: GPL-2.0+ */
Tom Rini28591df2012-08-13 12:03:19 -07002/*
3 * (C) Copyright 2012
4 * Texas Instruments, <www.ti.com>
Tom Rini28591df2012-08-13 12:03:19 -07005 */
6#ifndef _SPL_H_
7#define _SPL_H_
8
Simon Glass867a3982017-11-13 18:55:03 -07009#include <binman_sym.h>
10
Tom Rini28591df2012-08-13 12:03:19 -070011/* Platform-specific defines */
Tom Rini31dfba42012-08-22 15:31:05 -070012#include <linux/compiler.h>
Masahiro Yamada5a5ef782020-02-25 02:25:46 +090013#include <asm/global_data.h>
Tom Rini28591df2012-08-13 12:03:19 -070014#include <asm/spl.h>
Simon Glasse14f1a22018-11-15 18:44:09 -070015#include <handoff.h>
Tom Rini28591df2012-08-13 12:03:19 -070016
Masahiro Yamada5a5ef782020-02-25 02:25:46 +090017struct blk_desc;
18struct image_header;
19
Simon Glassa77e1b82015-05-13 07:02:24 -060020/* Value in r0 indicates we booted from U-Boot */
21#define UBOOT_NOT_LOADED_FROM_SPL 0x13578642
Dan Murphyb7b5b0c2014-01-16 11:23:29 -060022
Tom Rini28591df2012-08-13 12:03:19 -070023/* Boot type */
24#define MMCSD_MODE_UNDEFINED 0
25#define MMCSD_MODE_RAW 1
Guillaume GARDET602a16c2014-10-15 17:53:11 +020026#define MMCSD_MODE_FS 2
Tom Rinicc612692014-02-05 10:24:18 -050027#define MMCSD_MODE_EMMCBOOT 3
Tom Rini28591df2012-08-13 12:03:19 -070028
Simon Glass4e0a52d2018-11-15 18:43:51 -070029/*
30 * u_boot_first_phase() - check if this is the first U-Boot phase
31 *
32 * U-Boot has up to three phases: TPL, SPL and U-Boot proper. Depending on the
33 * build flags we can determine whether the current build is for the first
34 * phase of U-Boot or not. If there is no SPL, then this is U-Boot proper. If
35 * there is SPL but no TPL, the the first phase is SPL. If there is TPL, then
36 * it is the first phase.
37 *
38 * @returns true if this is the first phase of U-Boot
39 *
40 */
41static inline bool u_boot_first_phase(void)
42{
43 if (IS_ENABLED(CONFIG_TPL)) {
44 if (IS_ENABLED(CONFIG_TPL_BUILD))
45 return true;
46 } else if (IS_ENABLED(CONFIG_SPL)) {
47 if (IS_ENABLED(CONFIG_SPL_BUILD))
48 return true;
49 } else {
50 return true;
51 }
52
53 return false;
54}
55
Simon Glassb7fb5132019-09-25 08:11:20 -060056enum u_boot_phase {
Simon Glass3c573b52019-09-25 08:56:30 -060057 PHASE_TPL, /* Running in TPL */
58 PHASE_SPL, /* Running in SPL */
59 PHASE_BOARD_F, /* Running in U-Boot before relocation */
60 PHASE_BOARD_R, /* Running in U-Boot after relocation */
Simon Glassb7fb5132019-09-25 08:11:20 -060061};
62
63/**
64 * spl_phase() - Find out the phase of U-Boot
65 *
66 * This can be used to avoid #ifdef logic and use if() instead.
67 *
68 * For example, to include code only in TPL, you might do:
69 *
70 * #ifdef CONFIG_TPL_BUILD
71 * ...
72 * #endif
73 *
74 * but with this you can use:
75 *
76 * if (spl_phase() == PHASE_TPL) {
77 * ...
78 * }
79 *
80 * To include code only in SPL, you might do:
81 *
82 * #if defined(CONFIG_SPL_BUILD) && !defined(CONFIG_TPL_BUILD)
83 * ...
84 * #endif
85 *
86 * but with this you can use:
87 *
88 * if (spl_phase() == PHASE_SPL) {
89 * ...
90 * }
91 *
92 * To include code only in U-Boot proper, you might do:
93 *
94 * #ifndef CONFIG_SPL_BUILD
95 * ...
96 * #endif
97 *
98 * but with this you can use:
99 *
Simon Glass3c573b52019-09-25 08:56:30 -0600100 * if (spl_phase() == PHASE_BOARD_F) {
Simon Glassb7fb5132019-09-25 08:11:20 -0600101 * ...
102 * }
103 *
104 * @return U-Boot phase
105 */
106static inline enum u_boot_phase spl_phase(void)
107{
108#ifdef CONFIG_TPL_BUILD
109 return PHASE_TPL;
110#elif CONFIG_SPL_BUILD
111 return PHASE_SPL;
112#else
Simon Glass3c573b52019-09-25 08:56:30 -0600113 DECLARE_GLOBAL_DATA_PTR;
114
115 if (!(gd->flags & GD_FLG_RELOC))
116 return PHASE_BOARD_F;
117 else
118 return PHASE_BOARD_R;
Simon Glassb7fb5132019-09-25 08:11:20 -0600119#endif
120}
121
Simon Glassdbd3f112018-11-15 18:43:56 -0700122/* A string name for SPL or TPL */
123#ifdef CONFIG_SPL_BUILD
124# ifdef CONFIG_TPL_BUILD
Heiko Schocherce251232018-12-05 11:29:54 +0100125# define SPL_TPL_NAME "TPL"
Simon Glassdbd3f112018-11-15 18:43:56 -0700126# else
Heiko Schocherce251232018-12-05 11:29:54 +0100127# define SPL_TPL_NAME "SPL"
Simon Glassdbd3f112018-11-15 18:43:56 -0700128# endif
129# define SPL_TPL_PROMPT SPL_TPL_NAME ": "
130#else
131# define SPL_TPL_NAME ""
132# define SPL_TPL_PROMPT ""
133#endif
134
Tom Rini28591df2012-08-13 12:03:19 -0700135struct spl_image_info {
136 const char *name;
137 u8 os;
Philipp Tomsichf13e9e02017-09-13 21:29:31 +0200138 uintptr_t load_addr;
139 uintptr_t entry_point;
Marek Vasut187b9e32019-05-07 21:17:02 +0200140#if CONFIG_IS_ENABLED(LOAD_FIT) || CONFIG_IS_ENABLED(LOAD_FIT_FULL)
Philipp Tomsichbe5ac1a2017-09-13 21:29:30 +0200141 void *fdt_addr;
142#endif
Philipp Tomsich58beb6e2018-05-24 17:15:50 +0200143 u32 boot_device;
Tom Rini28591df2012-08-13 12:03:19 -0700144 u32 size;
Stefan Roese00b57b32012-08-27 12:50:58 +0200145 u32 flags;
Vikas Manocha62b021c2017-04-07 15:38:13 -0700146 void *arg;
Simon Goldschmidt17140472019-02-10 21:34:37 +0100147#ifdef CONFIG_SPL_LEGACY_IMAGE_CRC_CHECK
148 ulong dcrc_data;
149 ulong dcrc_length;
150 ulong dcrc;
151#endif
Tom Rini28591df2012-08-13 12:03:19 -0700152};
153
Simon Glassa6131a22016-02-22 22:55:56 -0700154/*
155 * Information required to load data from a device
156 *
157 * @dev: Pointer to the device, e.g. struct mmc *
158 * @priv: Private data for the device
159 * @bl_len: Block length for reading in bytes
Lokesh Vutlaf62cef12016-05-24 10:34:38 +0530160 * @filename: Name of the fit image file.
Simon Glassa6131a22016-02-22 22:55:56 -0700161 * @read: Function to call to read from the device
162 */
163struct spl_load_info {
164 void *dev;
165 void *priv;
166 int bl_len;
Lokesh Vutlaf62cef12016-05-24 10:34:38 +0530167 const char *filename;
Simon Glassa6131a22016-02-22 22:55:56 -0700168 ulong (*read)(struct spl_load_info *load, ulong sector, ulong count,
169 void *buf);
170};
171
Simon Glass867a3982017-11-13 18:55:03 -0700172/*
173 * We need to know the position of U-Boot in memory so we can jump to it. We
174 * allow any U-Boot binary to be used (u-boot.bin, u-boot-nodtb.bin,
175 * u-boot.img), hence the '_any'. These is no checking here that the correct
Simon Glass596f31c2019-12-08 17:40:12 -0700176 * image is found. For example if u-boot.img is used we don't check that
Simon Glass867a3982017-11-13 18:55:03 -0700177 * spl_parse_image_header() can parse a valid header.
Simon Glass596f31c2019-12-08 17:40:12 -0700178 *
179 * Similarly for SPL, so that TPL can jump to SPL.
Simon Glass867a3982017-11-13 18:55:03 -0700180 */
Simon Glass9dcc8612018-08-01 15:22:42 -0600181binman_sym_extern(ulong, u_boot_any, image_pos);
Simon Glass596f31c2019-12-08 17:40:12 -0700182binman_sym_extern(ulong, u_boot_any, size);
183binman_sym_extern(ulong, spl, image_pos);
184binman_sym_extern(ulong, spl, size);
185
186/**
187 * spl_get_image_pos() - get the image position of the next phase
188 *
189 * This returns the image position to use to load the next phase of U-Boot
190 */
191ulong spl_get_image_pos(void);
192
193/**
194 * spl_get_image_size() - get the size of the next phase
195 *
196 * This returns the size to use to load the next phase of U-Boot
197 */
198ulong spl_get_image_size(void);
Simon Glass867a3982017-11-13 18:55:03 -0700199
Lokesh Vutlaf62cef12016-05-24 10:34:38 +0530200/**
Andreas Dannenberg8d9f7f12019-06-04 17:55:46 -0500201 * spl_load_simple_fit_skip_processing() - Hook to allow skipping the FIT
202 * image processing during spl_load_simple_fit().
203 *
204 * Return true to skip FIT processing, false to preserve the full code flow
205 * of spl_load_simple_fit().
206 */
207bool spl_load_simple_fit_skip_processing(void);
208
209/**
Lokesh Vutlaf62cef12016-05-24 10:34:38 +0530210 * spl_load_simple_fit() - Loads a fit image from a device.
Simon Glass43a734f2016-09-24 18:20:16 -0600211 * @spl_image: Image description to set up
Lokesh Vutlaf62cef12016-05-24 10:34:38 +0530212 * @info: Structure containing the information required to load data.
213 * @sector: Sector number where FIT image is located in the device
214 * @fdt: Pointer to the copied FIT header.
215 *
216 * Reads the FIT image @sector in the device. Loads u-boot image to
217 * specified load address and copies the dtb to end of u-boot image.
218 * Returns 0 on success.
219 */
Simon Glass43a734f2016-09-24 18:20:16 -0600220int spl_load_simple_fit(struct spl_image_info *spl_image,
221 struct spl_load_info *info, ulong sector, void *fdt);
Simon Glassa6131a22016-02-22 22:55:56 -0700222
Stefan Roese00b57b32012-08-27 12:50:58 +0200223#define SPL_COPY_PAYLOAD_ONLY 1
Ye Li9d5b0f42018-11-17 09:10:25 +0000224#define SPL_FIT_FOUND 2
Stefan Roese00b57b32012-08-27 12:50:58 +0200225
Peng Fand8670762019-08-22 07:42:38 +0000226/**
Stefan Roese84ae9d82020-04-21 09:28:43 +0200227 * spl_load_legacy_img() - Loads a legacy image from a device.
228 * @spl_image: Image description to set up
229 * @load: Structure containing the information required to load data.
230 * @header: Pointer to image header (including appended image)
231 *
232 * Reads an legacy image from the device. Loads u-boot image to
233 * specified load address.
234 * Returns 0 on success.
235 */
236int spl_load_legacy_img(struct spl_image_info *spl_image,
237 struct spl_load_info *load, ulong header);
238
239/**
Peng Fand8670762019-08-22 07:42:38 +0000240 * spl_load_imx_container() - Loads a imx container image from a device.
241 * @spl_image: Image description to set up
242 * @info: Structure containing the information required to load data.
243 * @sector: Sector number where container image is located in the device
244 *
245 * Reads the container image @sector in the device. Loads u-boot image to
246 * specified load address.
247 */
248int spl_load_imx_container(struct spl_image_info *spl_image,
249 struct spl_load_info *info, ulong sector);
250
Tom Rini28591df2012-08-13 12:03:19 -0700251/* SPL common functions */
252void preloader_console_init(void);
253u32 spl_boot_device(void);
Harald Seiler0bf7ab12020-04-15 11:33:30 +0200254
255/**
256 * spl_mmc_boot_mode() - Lookup function for the mode of an MMC boot source.
257 * @boot_device: ID of the device which the MMC driver wants to read
258 * from. Common values are e.g. BOOT_DEVICE_MMC1,
259 * BOOT_DEVICE_MMC2, BOOT_DEVICE_MMC2_2.
260 *
261 * This function should return one of MMCSD_MODE_FS, MMCSD_MODE_EMMCBOOT, or
262 * MMCSD_MODE_RAW for each MMC boot source which is defined for the target. The
263 * boot_device parameter tells which device the MMC driver is interested in.
264 *
265 * If not overridden, it is weakly defined in common/spl/spl_mmc.c.
266 *
267 * Note: It is important to use the boot_device parameter instead of e.g.
268 * spl_boot_device() as U-Boot is not always loaded from the same device as SPL.
269 */
270u32 spl_mmc_boot_mode(const u32 boot_device);
Harald Seilerbf16c302020-04-15 11:33:31 +0200271
272/**
273 * spl_mmc_boot_partition() - MMC partition to load U-Boot from.
274 * @boot_device: ID of the device which the MMC driver wants to load
275 * U-Boot from.
276 *
277 * This function should return the partition number which the SPL
278 * should load U-Boot from (on the given boot_device) when
279 * CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_USE_PARTITION is set.
280 *
281 * If not overridden, it is weakly defined in common/spl/spl_mmc.c.
282 */
283int spl_mmc_boot_partition(const u32 boot_device);
York Suna34ca5f2017-09-28 08:42:10 -0700284void spl_set_bd(void);
Simon Glass11a1a272016-09-24 18:19:52 -0600285
286/**
287 * spl_set_header_raw_uboot() - Set up a standard SPL image structure
288 *
289 * This sets up the given spl_image which the standard values obtained from
290 * config options: CONFIG_SYS_MONITOR_LEN, CONFIG_SYS_UBOOT_START,
291 * CONFIG_SYS_TEXT_BASE.
292 *
Simon Glass6b2e4db2016-09-24 18:19:53 -0600293 * @spl_image: Image description to set up
Simon Glass11a1a272016-09-24 18:19:52 -0600294 */
295void spl_set_header_raw_uboot(struct spl_image_info *spl_image);
296
Simon Glass6b2e4db2016-09-24 18:19:53 -0600297/**
298 * spl_parse_image_header() - parse the image header and set up info
299 *
300 * This parses the legacy image header information at @header and sets up
301 * @spl_image according to what is found. If no image header is found, then
302 * a raw image or bootz is assumed. If CONFIG_SPL_PANIC_ON_RAW_IMAGE is
Andrew F. Davisb4be3c32017-02-16 11:18:38 -0600303 * enabled, then this causes a panic. If CONFIG_SPL_RAW_IMAGE_SUPPORT is not
Simon Glass6b2e4db2016-09-24 18:19:53 -0600304 * enabled then U-Boot gives up. Otherwise U-Boot sets up the image using
305 * spl_set_header_raw_uboot(), or possibly the bootz header.
306 *
307 * @spl_image: Image description to set up
308 * @header image header to parse
309 * @return 0 if a header was correctly parsed, -ve on error
310 */
311int spl_parse_image_header(struct spl_image_info *spl_image,
312 const struct image_header *header);
313
Tom Rini28591df2012-08-13 12:03:19 -0700314void spl_board_prepare_for_linux(void);
Michal Simek7a8465b2016-05-10 07:54:20 +0200315void spl_board_prepare_for_boot(void);
Ladislav Michl2a8ea482016-07-12 20:28:13 +0200316int spl_board_ubi_load_image(u32 boot_device);
Alifer Moraes2649d0c2020-01-14 15:55:01 -0300317int spl_board_boot_device(u32 boot_device);
Simon Glassb805c352016-09-24 18:19:54 -0600318
319/**
320 * jump_to_image_linux() - Jump to a Linux kernel from SPL
321 *
322 * This jumps into a Linux kernel using the information in @spl_image.
323 *
324 * @spl_image: Image description to set up
Simon Glassb805c352016-09-24 18:19:54 -0600325 */
Vikas Manocha62b021c2017-04-07 15:38:13 -0700326void __noreturn jump_to_image_linux(struct spl_image_info *spl_image);
Simon Glass3e6b1c32016-09-24 18:19:55 -0600327
328/**
329 * spl_start_uboot() - Check if SPL should start the kernel or U-Boot
330 *
331 * This is called by the various SPL loaders to determine whether the board
332 * wants to load the kernel or U-Boot. This function should be provided by
333 * the board.
334 *
335 * @return 0 if SPL should start the kernel, 1 if U-Boot must be started
336 */
Tom Rini28591df2012-08-13 12:03:19 -0700337int spl_start_uboot(void);
Simon Glass3e6b1c32016-09-24 18:19:55 -0600338
Simon Glassf481ab12016-09-24 18:19:56 -0600339/**
340 * spl_display_print() - Display a board-specific message in SPL
341 *
342 * If CONFIG_SPL_DISPLAY_PRINT is enabled, U-Boot will call this function
343 * immediately after displaying the SPL console banner ("U-Boot SPL ...").
344 * This function should be provided by the board.
345 */
Tom Rini28591df2012-08-13 12:03:19 -0700346void spl_display_print(void);
347
Simon Glassc0b6c9b2016-09-24 18:19:57 -0600348/**
349 * struct spl_boot_device - Describes a boot device used by SPL
350 *
351 * @boot_device: A number indicating the BOOT_DEVICE type. There are various
352 * BOOT_DEVICE... #defines and enums in U-Boot and they are not consistently
353 * numbered.
354 * @boot_device_name: Named boot device, or NULL if none.
355 *
356 * Note: Additional fields can be added here, bearing in mind that SPL is
357 * size-sensitive and common fields will be present on all boards. This
358 * struct can also be used to return additional information about the load
359 * process if that becomes useful.
360 */
361struct spl_boot_device {
362 uint boot_device;
363 const char *boot_device_name;
364};
365
Simon Glassd1cf3732016-09-24 18:19:58 -0600366/**
367 * Holds information about a way of loading an SPL image
368 *
Simon Glass4fc1f252016-11-30 15:30:50 -0700369 * @name: User-friendly name for this method (e.g. "MMC")
Simon Glassd1cf3732016-09-24 18:19:58 -0600370 * @boot_device: Boot device that this loader supports
371 * @load_image: Function to call to load image
372 */
373struct spl_image_loader {
Simon Glass4fc1f252016-11-30 15:30:50 -0700374#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
375 const char *name;
376#endif
Simon Glassd1cf3732016-09-24 18:19:58 -0600377 uint boot_device;
378 /**
379 * load_image() - Load an SPL image
380 *
Simon Glassee306792016-09-24 18:20:13 -0600381 * @spl_image: place to put image information
Simon Glassd1cf3732016-09-24 18:19:58 -0600382 * @bootdev: describes the boot device to load from
383 */
Simon Glassee306792016-09-24 18:20:13 -0600384 int (*load_image)(struct spl_image_info *spl_image,
385 struct spl_boot_device *bootdev);
Simon Glassd1cf3732016-09-24 18:19:58 -0600386};
387
388/* Declare an SPL image loader */
389#define SPL_LOAD_IMAGE(__name) \
390 ll_entry_declare(struct spl_image_loader, __name, spl_image_loader)
391
392/*
Simon Glassbf4fd552016-11-30 15:30:49 -0700393 * _priority is the priority of this method, 0 meaning it will be the top
Simon Glassd1cf3732016-09-24 18:19:58 -0600394 * choice for this device, 9 meaning it is the bottom choice.
Simon Glassbf4fd552016-11-30 15:30:49 -0700395 * _boot_device is the BOOT_DEVICE_... value
396 * _method is the load_image function to call
Simon Glassd1cf3732016-09-24 18:19:58 -0600397 */
Simon Glass4fc1f252016-11-30 15:30:50 -0700398#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
399#define SPL_LOAD_IMAGE_METHOD(_name, _priority, _boot_device, _method) \
Simon Glassec1503c2019-10-20 21:31:45 -0600400 SPL_LOAD_IMAGE(_boot_device ## _priority ## _method) = { \
Simon Glass4fc1f252016-11-30 15:30:50 -0700401 .name = _name, \
Simon Glassbf4fd552016-11-30 15:30:49 -0700402 .boot_device = _boot_device, \
403 .load_image = _method, \
Simon Glassd1cf3732016-09-24 18:19:58 -0600404 }
Simon Glass4fc1f252016-11-30 15:30:50 -0700405#else
406#define SPL_LOAD_IMAGE_METHOD(_name, _priority, _boot_device, _method) \
Simon Glassec1503c2019-10-20 21:31:45 -0600407 SPL_LOAD_IMAGE(_boot_device ## _priority ## _method) = { \
Simon Glass4fc1f252016-11-30 15:30:50 -0700408 .boot_device = _boot_device, \
409 .load_image = _method, \
410 }
411#endif
Simon Glassd1cf3732016-09-24 18:19:58 -0600412
Dan Murphyb7b5b0c2014-01-16 11:23:29 -0600413/* SPL FAT image functions */
Simon Glass3eb382a2016-09-24 18:20:15 -0600414int spl_load_image_fat(struct spl_image_info *spl_image,
415 struct blk_desc *block_dev, int partition,
Simon Glasse3394752016-02-29 15:25:34 -0700416 const char *filename);
Simon Glass3eb382a2016-09-24 18:20:15 -0600417int spl_load_image_fat_os(struct spl_image_info *spl_image,
418 struct blk_desc *block_dev, int partition);
Dan Murphyb7b5b0c2014-01-16 11:23:29 -0600419
Jeroen Hofstee454c0712014-10-08 22:58:07 +0200420void __noreturn jump_to_image_no_args(struct spl_image_info *spl_image);
421
Guillaume GARDET1eb410c2014-10-15 17:53:12 +0200422/* SPL EXT image functions */
Simon Glass0649e912016-09-24 18:20:14 -0600423int spl_load_image_ext(struct spl_image_info *spl_image,
424 struct blk_desc *block_dev, int partition,
Simon Glasse3394752016-02-29 15:25:34 -0700425 const char *filename);
Simon Glass0649e912016-09-24 18:20:14 -0600426int spl_load_image_ext_os(struct spl_image_info *spl_image,
427 struct blk_desc *block_dev, int partition);
Guillaume GARDET1eb410c2014-10-15 17:53:12 +0200428
Simon Glassfa2a4db2015-06-23 15:39:10 -0600429/**
Eddie Cai32258992017-03-15 08:43:28 -0600430 * spl_early_init() - Set up device tree and driver model in SPL if enabled
Simon Glassfa2a4db2015-06-23 15:39:10 -0600431 *
432 * Call this function in board_init_f() if you want to use device tree and
Eddie Cai32258992017-03-15 08:43:28 -0600433 * driver model early, before board_init_r() is called.
434 *
435 * If this is not called, then driver model will be inactive in SPL's
436 * board_init_f(), and no device tree will be available.
437 */
438int spl_early_init(void);
439
440/**
441 * spl_init() - Set up device tree and driver model in SPL if enabled
442 *
443 * You can optionally call spl_early_init(), then optionally call spl_init().
444 * This function will be called from board_init_r() if not called earlier.
445 *
446 * Both spl_early_init() and spl_init() perform a similar function except that
447 * the latter will not set up the malloc() area if
448 * CONFIG_SPL_STACK_R_MALLOC_SIMPLE_LEN is enabled, since it is assumed to
449 * already be done by a calll to spl_relocate_stack_gd() before board_init_r()
450 * is reached.
451 *
452 * This function will be called from board_init_r() if not called earlier.
Simon Glassfa2a4db2015-06-23 15:39:10 -0600453 *
454 * If this is not called, then driver model will be inactive in SPL's
455 * board_init_f(), and no device tree will be available.
456 */
457int spl_init(void);
458
Tom Rini28591df2012-08-13 12:03:19 -0700459#ifdef CONFIG_SPL_BOARD_INIT
460void spl_board_init(void);
461#endif
Simon Glassa77e1b82015-05-13 07:02:24 -0600462
463/**
464 * spl_was_boot_source() - check if U-Boot booted from SPL
465 *
466 * This will normally be true, but if U-Boot jumps to second U-Boot, it will
467 * be false. This should be implemented by board-specific code.
468 *
469 * @return true if U-Boot booted from SPL, else false
470 */
471bool spl_was_boot_source(void);
472
B, Ravid207b7e2016-07-28 17:39:16 +0530473/**
474 * spl_dfu_cmd- run dfu command with chosen mmc device interface
475 * @param usb_index - usb controller number
476 * @param mmc_dev - mmc device nubmer
477 *
478 * @return 0 on success, otherwise error code
479 */
480int spl_dfu_cmd(int usbctrl, char *dfu_alt_info, char *interface, char *devstr);
Simon Glass8dd1c9e2016-09-24 18:19:51 -0600481
Marek Vasut8d5c4c32016-12-01 02:06:35 +0100482int spl_mmc_load_image(struct spl_image_info *spl_image,
483 struct spl_boot_device *bootdev);
484
Philipp Tomsichf13e9e02017-09-13 21:29:31 +0200485/**
Andreas Dannenberg8d9f7f12019-06-04 17:55:46 -0500486 * spl_mmc_load() - Load an image file from MMC/SD media
487 *
488 * @param spl_image Image data filled in by loading process
489 * @param bootdev Describes which device to load from
490 * @param filename Name of file to load (in FS mode)
491 * @param raw_part Partition to load from (in RAW mode)
492 * @param raw_sect Sector to load from (in RAW mode)
493 *
494 * @return 0 on success, otherwise error code
495 */
496int spl_mmc_load(struct spl_image_info *spl_image,
497 struct spl_boot_device *bootdev,
498 const char *filename,
499 int raw_part,
500 unsigned long raw_sect);
501
Andreas Dannenberg58892082019-08-15 15:55:27 -0500502int spl_ymodem_load_image(struct spl_image_info *spl_image,
503 struct spl_boot_device *bootdev);
504
Andreas Dannenberg8d9f7f12019-06-04 17:55:46 -0500505/**
Philipp Tomsichf13e9e02017-09-13 21:29:31 +0200506 * spl_invoke_atf - boot using an ARM trusted firmware image
507 */
508void spl_invoke_atf(struct spl_image_info *spl_image);
Philipp Tomsich83ad7022017-06-22 23:38:36 +0200509
510/**
Michal Simekd1598e22019-12-19 18:13:31 +0100511 * bl2_plat_get_bl31_params() - prepare params for bl31.
512 * @bl32_entry address of BL32 executable (secure)
513 * @bl33_entry address of BL33 executable (non secure)
514 * @fdt_addr address of Flat Device Tree
515 *
516 * This function assigns a pointer to the memory that the platform has kept
517 * aside to pass platform specific and trusted firmware related information
518 * to BL31. This memory is allocated by allocating memory to
519 * bl2_to_bl31_params_mem structure which is a superset of all the
520 * structure whose information is passed to BL31
521 * NOTE: This function should be called only once and should be done
522 * before generating params to BL31
523 *
524 * @return bl31 params structure pointer
525 */
526struct bl31_params *bl2_plat_get_bl31_params(uintptr_t bl32_entry,
527 uintptr_t bl33_entry,
528 uintptr_t fdt_addr);
529
530/**
Kever Yanga28d42c2018-08-23 17:17:59 +0800531 * spl_optee_entry - entry function for optee
532 *
533 * args defind in op-tee project
534 * https://github.com/OP-TEE/optee_os/
535 * core/arch/arm/kernel/generic_entry_a32.S
536 * @arg0: pagestore
537 * @arg1: (ARMv7 standard bootarg #1)
538 * @arg2: device tree address, (ARMv7 standard bootarg #2)
539 * @arg3: non-secure entry address (ARMv7 bootarg #0)
540 */
541void spl_optee_entry(void *arg0, void *arg1, void *arg2, void *arg3);
542
543/**
Lukas Auer515b9342019-08-21 21:14:44 +0200544 * spl_invoke_opensbi - boot using a RISC-V OpenSBI image
545 */
546void spl_invoke_opensbi(struct spl_image_info *spl_image);
547
548/**
Philipp Tomsich83ad7022017-06-22 23:38:36 +0200549 * board_return_to_bootrom - allow for boards to continue with the boot ROM
550 *
551 * If a board (e.g. the Rockchip RK3368 boards) provide some
552 * supporting functionality for SPL in their boot ROM and the SPL
553 * stage wants to return to the ROM code to continue booting, boards
554 * can implement 'board_return_to_bootrom'.
555 */
Peng Fanaa050c52019-08-07 06:40:53 +0000556int board_return_to_bootrom(struct spl_image_info *spl_image,
557 struct spl_boot_device *bootdev);
Philipp Tomsich58beb6e2018-05-24 17:15:50 +0200558
559/**
Peng Fanc86bacd2018-11-17 09:10:31 +0000560 * board_spl_fit_post_load - allow process images after loading finished
561 *
562 */
563void board_spl_fit_post_load(ulong load_addr, size_t length);
564
565/**
566 * board_spl_fit_size_align - specific size align before processing payload
567 *
568 */
569ulong board_spl_fit_size_align(ulong size);
570
571/**
Philipp Tomsich58beb6e2018-05-24 17:15:50 +0200572 * spl_perform_fixups() - arch/board-specific callback before processing
573 * the boot-payload
574 */
575void spl_perform_fixups(struct spl_image_info *spl_image);
Marek Vasut1dda46f2018-08-14 11:27:02 +0200576
577/*
578 * spl_get_load_buffer() - get buffer for loading partial image data
579 *
580 * Returns memory area which can be populated by partial image data,
581 * ie. uImage or fitImage header.
582 */
583struct image_header *spl_get_load_buffer(ssize_t offset, size_t size);
584
Peng Fan617fc292020-05-05 20:28:41 +0800585void spl_save_restore_data(void);
Tom Rini28591df2012-08-13 12:03:19 -0700586#endif