1/* SPDX-License-Identifier: GPL-2.0+ */ 2/* 3 * (C) Copyright 2012 4 * Texas Instruments, <www.ti.com> 5 */ 6#ifndef _SPL_H_ 7#define _SPL_H_ 8 9#include <binman_sym.h> 10#include <linker_lists.h> 11 12/* Platform-specific defines */ 13#include <linux/compiler.h> 14#include <asm/global_data.h> 15#include <asm/spl.h> 16#include <handoff.h> 17#include <mmc.h> 18 19struct blk_desc; 20struct image_header; 21 22/* Value in r0 indicates we booted from U-Boot */ 23#define UBOOT_NOT_LOADED_FROM_SPL 0x13578642 24 25/* Boot type */ 26#define MMCSD_MODE_UNDEFINED 0 27#define MMCSD_MODE_RAW 1 28#define MMCSD_MODE_FS 2 29#define MMCSD_MODE_EMMCBOOT 3 30 31struct blk_desc; 32struct image_header; 33struct spl_boot_device; 34 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 */ 47static 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 62enum u_boot_phase { 63 PHASE_NONE, /* Invalid phase, signifying before U-Boot */ 64 PHASE_TPL, /* Running in TPL */ 65 PHASE_VPL, /* Running in VPL */ 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 */ 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 * 108 * if (spl_phase() == PHASE_BOARD_F) { 109 * ... 110 * } 111 * 112 * Return: U-Boot phase 113 */ 114static inline enum u_boot_phase spl_phase(void) 115{ 116#ifdef CONFIG_TPL_BUILD 117 return PHASE_TPL; 118#elif defined(CONFIG_VPL_BUILD) 119 return PHASE_VPL; 120#elif defined(CONFIG_SPL_BUILD) 121 return PHASE_SPL; 122#else 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; 129#endif 130} 131 132/** 133 * spl_prev_phase() - Figure out the previous U-Boot phase 134 * 135 * Return: the previous phase from this one, e.g. if called in SPL this returns 136 * PHASE_TPL, if TPL is enabled 137 */ 138static inline enum u_boot_phase spl_prev_phase(void) 139{ 140#ifdef CONFIG_TPL_BUILD 141 return PHASE_NONE; 142#elif defined(CONFIG_VPL_BUILD) 143 return PHASE_TPL; /* VPL requires TPL */ 144#elif defined(CONFIG_SPL_BUILD) 145 return IS_ENABLED(CONFIG_VPL) ? PHASE_VPL : 146 IS_ENABLED(CONFIG_TPL) ? PHASE_TPL : 147 PHASE_NONE; 148#else 149 return IS_ENABLED(CONFIG_SPL) ? PHASE_SPL : 150 PHASE_NONE; 151#endif 152} 153 154/** 155 * spl_next_phase() - Figure out the next U-Boot phase 156 * 157 * Return: the next phase from this one, e.g. if called in TPL this returns 158 * PHASE_SPL 159 */ 160static inline enum u_boot_phase spl_next_phase(void) 161{ 162#ifdef CONFIG_TPL_BUILD 163 return IS_ENABLED(CONFIG_VPL) ? PHASE_VPL : PHASE_SPL; 164#elif defined(CONFIG_VPL_BUILD) 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 * 174 * Return: phase name 175 */ 176static inline const char *spl_phase_name(enum u_boot_phase phase) 177{ 178 switch (phase) { 179 case PHASE_TPL: 180 return "TPL"; 181 case PHASE_VPL: 182 return "VPL"; 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 193/** 194 * spl_phase_prefix() - Get the prefix of the current phase 195 * 196 * @phase: Phase to look up 197 * Return: phase prefix ("spl", "tpl", etc.) 198 */ 199static inline const char *spl_phase_prefix(enum u_boot_phase phase) 200{ 201 switch (phase) { 202 case PHASE_TPL: 203 return "tpl"; 204 case PHASE_VPL: 205 return "vpl"; 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 216/* A string name for SPL or TPL */ 217#ifdef CONFIG_SPL_BUILD 218# ifdef CONFIG_TPL_BUILD 219# define SPL_TPL_NAME "TPL" 220# elif defined(CONFIG_VPL_BUILD) 221# define SPL_TPL_NAME "VPL" 222# else 223# define SPL_TPL_NAME "SPL" 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 231struct spl_image_info { 232 const char *name; 233 u8 os; 234 uintptr_t load_addr; 235 uintptr_t entry_point; 236#if CONFIG_IS_ENABLED(LOAD_FIT) || CONFIG_IS_ENABLED(LOAD_FIT_FULL) 237 void *fdt_addr; 238#endif 239 u32 boot_device; 240 u32 offset; 241 u32 size; 242 u32 flags; 243 void *arg; 244#ifdef CONFIG_SPL_LEGACY_IMAGE_CRC_CHECK 245 ulong dcrc_data; 246 ulong dcrc_length; 247 ulong dcrc; 248#endif 249}; 250 251/** 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 257 * @filename: Name of the fit image file. 258 * @read: Function to call to read from the device 259 */ 260struct spl_load_info { 261 void *dev; 262 void *priv; 263 int bl_len; 264 const char *filename; 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 */ 274 ulong (*read)(struct spl_load_info *load, ulong sector, ulong count, 275 void *buf); 276}; 277 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 282 * image is found. For example if u-boot.img is used we don't check that 283 * spl_parse_image_header() can parse a valid header. 284 * 285 * Similarly for SPL, so that TPL can jump to SPL. 286 */ 287binman_sym_extern(ulong, u_boot_any, image_pos); 288binman_sym_extern(ulong, u_boot_any, size); 289binman_sym_extern(ulong, u_boot_spl, image_pos); 290binman_sym_extern(ulong, u_boot_spl, size); 291binman_sym_extern(ulong, u_boot_vpl, image_pos); 292binman_sym_extern(ulong, u_boot_vpl, size); 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 */ 299ulong 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 */ 306ulong spl_get_image_size(void); 307 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. 312 * CONFIG_SPL_TEXT_BASE or CONFIG_SYS_TEXT_BASE 313 * 314 * Return: text-base address 315 */ 316ulong spl_get_image_text_base(void); 317 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 */ 325bool spl_load_simple_fit_skip_processing(void); 326 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 */ 333void *spl_load_simple_fit_fix_load(const void *fit); 334 335/** 336 * spl_load_simple_fit() - Loads a fit image from a device. 337 * @spl_image: Image description to set up 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 */ 346int spl_load_simple_fit(struct spl_image_info *spl_image, 347 struct spl_load_info *info, ulong sector, void *fdt); 348 349#define SPL_COPY_PAYLOAD_ONLY 1 350#define SPL_FIT_FOUND 2 351 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. 356 * @header: Pointer to image header (including appended image) 357 * 358 * Reads an legacy image from the device. Loads u-boot image to 359 * specified load address. 360 * Returns 0 on success. 361 */ 362int spl_load_legacy_img(struct spl_image_info *spl_image, 363 struct spl_boot_device *bootdev, 364 struct spl_load_info *load, ulong header); 365 366/** 367 * spl_load_imx_container() - Loads a imx container image from a device. 368 * @spl_image: Image description to set up 369 * @info: Structure containing the information required to load data. 370 * @sector: Sector number where container image is located in the device 371 * 372 * Reads the container image @sector in the device. Loads u-boot image to 373 * specified load address. 374 */ 375int spl_load_imx_container(struct spl_image_info *spl_image, 376 struct spl_load_info *info, ulong sector); 377 378/* SPL common functions */ 379void preloader_console_init(void); 380u32 spl_boot_device(void); 381 382/** 383 * spl_spi_boot_bus() - Lookup function for the SPI boot bus source. 384 * 385 * This function returns the SF bus to load from. 386 * If not overridden, it is weakly defined in common/spl/spl_spi.c. 387 */ 388u32 spl_spi_boot_bus(void); 389 390/** 391 * spl_spi_boot_cs() - Lookup function for the SPI boot CS source. 392 * 393 * This function returns the SF CS to load from. 394 * If not overridden, it is weakly defined in common/spl/spl_spi.c. 395 */ 396u32 spl_spi_boot_cs(void); 397 398/** 399 * spl_mmc_boot_mode() - Lookup function for the mode of an MMC boot source. 400 * @boot_device: ID of the device which the MMC driver wants to read 401 * from. Common values are e.g. BOOT_DEVICE_MMC1, 402 * BOOT_DEVICE_MMC2, BOOT_DEVICE_MMC2_2. 403 * 404 * This function should return one of MMCSD_MODE_FS, MMCSD_MODE_EMMCBOOT, or 405 * MMCSD_MODE_RAW for each MMC boot source which is defined for the target. The 406 * boot_device parameter tells which device the MMC driver is interested in. 407 * 408 * If not overridden, it is weakly defined in common/spl/spl_mmc.c. 409 * 410 * Note: It is important to use the boot_device parameter instead of e.g. 411 * spl_boot_device() as U-Boot is not always loaded from the same device as SPL. 412 */ 413u32 spl_mmc_boot_mode(struct mmc *mmc, const u32 boot_device); 414 415/** 416 * spl_mmc_boot_partition() - MMC partition to load U-Boot from. 417 * @boot_device: ID of the device which the MMC driver wants to load 418 * U-Boot from. 419 * 420 * This function should return the partition number which the SPL 421 * should load U-Boot from (on the given boot_device) when 422 * CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_USE_PARTITION is set. 423 * 424 * If not overridden, it is weakly defined in common/spl/spl_mmc.c. 425 */ 426int spl_mmc_boot_partition(const u32 boot_device); 427 428struct mmc; 429/** 430 * default_spl_mmc_emmc_boot_partition() - eMMC boot partition to load U-Boot from. 431 * mmc: Pointer for the mmc device structure 432 * 433 * This function should return the eMMC boot partition number which 434 * the SPL should load U-Boot from (on the given boot_device). 435 */ 436int default_spl_mmc_emmc_boot_partition(struct mmc *mmc); 437 438/** 439 * spl_mmc_emmc_boot_partition() - eMMC boot partition to load U-Boot from. 440 * mmc: Pointer for the mmc device structure 441 * 442 * This function should return the eMMC boot partition number which 443 * the SPL should load U-Boot from (on the given boot_device). 444 * 445 * If not overridden, it is weakly defined in common/spl/spl_mmc.c 446 * and calls default_spl_mmc_emmc_boot_partition(); 447 */ 448int spl_mmc_emmc_boot_partition(struct mmc *mmc); 449 450void spl_set_bd(void); 451 452/** 453 * spl_set_header_raw_uboot() - Set up a standard SPL image structure 454 * 455 * This sets up the given spl_image which the standard values obtained from 456 * config options: CONFIG_SYS_MONITOR_LEN, CONFIG_SYS_UBOOT_START, 457 * CONFIG_SYS_TEXT_BASE. 458 * 459 * @spl_image: Image description to set up 460 */ 461void spl_set_header_raw_uboot(struct spl_image_info *spl_image); 462 463/** 464 * spl_parse_image_header() - parse the image header and set up info 465 * 466 * This parses the legacy image header information at @header and sets up 467 * @spl_image according to what is found. If no image header is found, then 468 * a raw image or bootz is assumed. If CONFIG_SPL_PANIC_ON_RAW_IMAGE is 469 * enabled, then this causes a panic. If CONFIG_SPL_RAW_IMAGE_SUPPORT is not 470 * enabled then U-Boot gives up. Otherwise U-Boot sets up the image using 471 * spl_set_header_raw_uboot(), or possibly the bootz header. 472 * 473 * @spl_image: Image description to set up 474 * @header image header to parse 475 * Return: 0 if a header was correctly parsed, -ve on error 476 */ 477int spl_parse_image_header(struct spl_image_info *spl_image, 478 const struct spl_boot_device *bootdev, 479 const struct image_header *header); 480 481void spl_board_prepare_for_linux(void); 482 483/** 484 * spl_board_prepare_for_optee() - Prepare board for an OPTEE payload 485 * 486 * Prepares the board for booting an OP-TEE payload. Initialization is platform 487 * specific, and may include configuring the TrustZone memory, and other 488 * initialization steps required by OP-TEE. 489 * Note that @fdt is not used directly by OP-TEE. OP-TEE passes this @fdt to 490 * its normal world target. This target is not guaranteed to be u-boot, so @fdt 491 * changes that would normally be done by u-boot should be done in this step. 492 * 493 * @fdt: Devicetree that will be passed on, or NULL 494 */ 495void spl_board_prepare_for_optee(void *fdt); 496void spl_board_prepare_for_boot(void); 497int spl_board_ubi_load_image(u32 boot_device); 498int spl_board_boot_device(u32 boot_device); 499 500/** 501 * spl_board_loader_name() - Return a name for the loader 502 * 503 * This is a weak function which might be overridden by the board code. With 504 * that a board specific value for the device where the U-Boot will be loaded 505 * from can be set. By default it returns NULL. 506 * 507 * @boot_device: ID of the device which SPL wants to load U-Boot from. 508 */ 509const char *spl_board_loader_name(u32 boot_device); 510 511/** 512 * jump_to_image_linux() - Jump to a Linux kernel from SPL 513 * 514 * This jumps into a Linux kernel using the information in @spl_image. 515 * 516 * @spl_image: Image description to set up 517 */ 518void __noreturn jump_to_image_linux(struct spl_image_info *spl_image); 519 520/** 521 * jump_to_image_linux() - Jump to OP-TEE OS from SPL 522 * 523 * This jumps into OP-TEE OS using the information in @spl_image. 524 * 525 * @spl_image: Image description to set up 526 */ 527void __noreturn jump_to_image_optee(struct spl_image_info *spl_image); 528 529/** 530 * spl_start_uboot() - Check if SPL should start the kernel or U-Boot 531 * 532 * This is called by the various SPL loaders to determine whether the board 533 * wants to load the kernel or U-Boot. This function should be provided by 534 * the board. 535 * 536 * Return: 0 if SPL should start the kernel, 1 if U-Boot must be started 537 */ 538int spl_start_uboot(void); 539 540/** 541 * spl_display_print() - Display a board-specific message in SPL 542 * 543 * If CONFIG_SPL_DISPLAY_PRINT is enabled, U-Boot will call this function 544 * immediately after displaying the SPL console banner ("U-Boot SPL ..."). 545 * This function should be provided by the board. 546 */ 547void spl_display_print(void); 548 549/** 550 * struct spl_boot_device - Describes a boot device used by SPL 551 * 552 * @boot_device: A number indicating the BOOT_DEVICE type. There are various 553 * BOOT_DEVICE... #defines and enums in U-Boot and they are not consistently 554 * numbered. 555 * @boot_device_name: Named boot device, or NULL if none. 556 * 557 * Note: Additional fields can be added here, bearing in mind that SPL is 558 * size-sensitive and common fields will be present on all boards. This 559 * struct can also be used to return additional information about the load 560 * process if that becomes useful. 561 */ 562struct spl_boot_device { 563 uint boot_device; 564 const char *boot_device_name; 565}; 566 567/** 568 * Holds information about a way of loading an SPL image 569 * 570 * @name: User-friendly name for this method (e.g. "MMC") 571 * @boot_device: Boot device that this loader supports 572 * @load_image: Function to call to load image 573 */ 574struct spl_image_loader { 575#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT 576 const char *name; 577#endif 578 uint boot_device; 579 /** 580 * load_image() - Load an SPL image 581 * 582 * @spl_image: place to put image information 583 * @bootdev: describes the boot device to load from 584 */ 585 int (*load_image)(struct spl_image_info *spl_image, 586 struct spl_boot_device *bootdev); 587}; 588 589/* Helper function for accessing the name */ 590static inline const char *spl_loader_name(const struct spl_image_loader *loader) 591{ 592#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT 593 const char *name; 594 name = spl_board_loader_name(loader->boot_device); 595 return name ?: loader->name; 596#else 597 return NULL; 598#endif 599} 600 601/* Declare an SPL image loader */ 602#define SPL_LOAD_IMAGE(__name) \ 603 ll_entry_declare(struct spl_image_loader, __name, spl_image_loader) 604 605/* 606 * _priority is the priority of this method, 0 meaning it will be the top 607 * choice for this device, 9 meaning it is the bottom choice. 608 * _boot_device is the BOOT_DEVICE_... value 609 * _method is the load_image function to call 610 */ 611#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT 612#define SPL_LOAD_IMAGE_METHOD(_name, _priority, _boot_device, _method) \ 613 SPL_LOAD_IMAGE(_boot_device ## _priority ## _method) = { \ 614 .name = _name, \ 615 .boot_device = _boot_device, \ 616 .load_image = _method, \ 617 } 618#else 619#define SPL_LOAD_IMAGE_METHOD(_name, _priority, _boot_device, _method) \ 620 SPL_LOAD_IMAGE(_boot_device ## _priority ## _method) = { \ 621 .boot_device = _boot_device, \ 622 .load_image = _method, \ 623 } 624#endif 625 626/* SPL FAT image functions */ 627int spl_load_image_fat(struct spl_image_info *spl_image, 628 struct spl_boot_device *bootdev, 629 struct blk_desc *block_dev, int partition, 630 const char *filename); 631int spl_load_image_fat_os(struct spl_image_info *spl_image, 632 struct spl_boot_device *bootdev, 633 struct blk_desc *block_dev, int partition); 634 635void __noreturn jump_to_image_no_args(struct spl_image_info *spl_image); 636 637/* SPL EXT image functions */ 638int spl_load_image_ext(struct spl_image_info *spl_image, 639 struct spl_boot_device *bootdev, 640 struct blk_desc *block_dev, int partition, 641 const char *filename); 642int spl_load_image_ext_os(struct spl_image_info *spl_image, 643 struct spl_boot_device *bootdev, 644 struct blk_desc *block_dev, int partition); 645 646/** 647 * spl_early_init() - Set up device tree and driver model in SPL if enabled 648 * 649 * Call this function in board_init_f() if you want to use device tree and 650 * driver model early, before board_init_r() is called. 651 * 652 * If this is not called, then driver model will be inactive in SPL's 653 * board_init_f(), and no device tree will be available. 654 */ 655int spl_early_init(void); 656 657/** 658 * spl_init() - Set up device tree and driver model in SPL if enabled 659 * 660 * You can optionally call spl_early_init(), then optionally call spl_init(). 661 * This function will be called from board_init_r() if not called earlier. 662 * 663 * Both spl_early_init() and spl_init() perform a similar function except that 664 * the latter will not set up the malloc() area if 665 * CONFIG_SPL_STACK_R_MALLOC_SIMPLE_LEN is enabled, since it is assumed to 666 * already be done by a calll to spl_relocate_stack_gd() before board_init_r() 667 * is reached. 668 * 669 * This function will be called from board_init_r() if not called earlier. 670 * 671 * If this is not called, then driver model will be inactive in SPL's 672 * board_init_f(), and no device tree will be available. 673 */ 674int spl_init(void); 675 676#ifdef CONFIG_SPL_BOARD_INIT 677void spl_board_init(void); 678#endif 679 680/** 681 * spl_was_boot_source() - check if U-Boot booted from SPL 682 * 683 * This will normally be true, but if U-Boot jumps to second U-Boot, it will 684 * be false. This should be implemented by board-specific code. 685 * 686 * Return: true if U-Boot booted from SPL, else false 687 */ 688bool spl_was_boot_source(void); 689 690/** 691 * spl_dfu_cmd- run dfu command with chosen mmc device interface 692 * @param usb_index - usb controller number 693 * @param mmc_dev - mmc device nubmer 694 * 695 * Return: 0 on success, otherwise error code 696 */ 697int spl_dfu_cmd(int usbctrl, char *dfu_alt_info, char *interface, char *devstr); 698 699int spl_mmc_load_image(struct spl_image_info *spl_image, 700 struct spl_boot_device *bootdev); 701 702/** 703 * spl_mmc_load() - Load an image file from MMC/SD media 704 * 705 * @param spl_image Image data filled in by loading process 706 * @param bootdev Describes which device to load from 707 * @param filename Name of file to load (in FS mode) 708 * @param raw_part Partition to load from (in RAW mode) 709 * @param raw_sect Sector to load from (in RAW mode) 710 * 711 * Return: 0 on success, otherwise error code 712 */ 713int spl_mmc_load(struct spl_image_info *spl_image, 714 struct spl_boot_device *bootdev, 715 const char *filename, 716 int raw_part, 717 unsigned long raw_sect); 718 719/** 720 * spl_usb_load() - Load an image file from USB mass storage 721 * 722 * @param spl_image Image data filled in by loading process 723 * @param bootdev Describes which device to load from 724 * @param raw_part Fat partition to load from 725 * @param filename Name of file to load 726 * 727 * Return: 0 on success, otherwise error code 728 */ 729int spl_usb_load(struct spl_image_info *spl_image, 730 struct spl_boot_device *bootdev, 731 int partition, const char *filename); 732 733int spl_ymodem_load_image(struct spl_image_info *spl_image, 734 struct spl_boot_device *bootdev); 735 736/** 737 * spl_invoke_atf - boot using an ARM trusted firmware image 738 */ 739void spl_invoke_atf(struct spl_image_info *spl_image); 740 741/** 742 * bl2_plat_get_bl31_params() - return params for bl31. 743 * @bl32_entry: address of BL32 executable (secure) 744 * @bl33_entry: address of BL33 executable (non secure) 745 * @fdt_addr: address of Flat Device Tree 746 * 747 * This is a weak function which might be overridden by the board code. By 748 * default it will just call bl2_plat_get_bl31_params_default(). 749 * 750 * If you just want to manipulate or add some parameters, you can override 751 * this function, call bl2_plat_get_bl31_params_default and operate on the 752 * returned bl31 params. 753 * 754 * Return: bl31 params structure pointer 755 */ 756struct bl31_params *bl2_plat_get_bl31_params(uintptr_t bl32_entry, 757 uintptr_t bl33_entry, 758 uintptr_t fdt_addr); 759 760/** 761 * bl2_plat_get_bl31_params_default() - prepare params for bl31. 762 * @bl32_entry: address of BL32 executable (secure) 763 * @bl33_entry: address of BL33 executable (non secure) 764 * @fdt_addr: address of Flat Device Tree 765 * 766 * This is the default implementation of bl2_plat_get_bl31_params(). It assigns 767 * a pointer to the memory that the platform has kept aside to pass platform 768 * specific and trusted firmware related information to BL31. This memory is 769 * allocated by allocating memory to bl2_to_bl31_params_mem structure which is 770 * a superset of all the structure whose information is passed to BL31 771 * 772 * NOTE: The memory is statically allocated, thus this function should be 773 * called only once. All subsequent calls will overwrite any changes. 774 * 775 * Return: bl31 params structure pointer 776 */ 777struct bl31_params *bl2_plat_get_bl31_params_default(uintptr_t bl32_entry, 778 uintptr_t bl33_entry, 779 uintptr_t fdt_addr); 780 781/** 782 * bl2_plat_get_bl31_params_v2() - return params for bl31 783 * @bl32_entry: address of BL32 executable (secure) 784 * @bl33_entry: address of BL33 executable (non secure) 785 * @fdt_addr: address of Flat Device Tree 786 * 787 * This function does the same as bl2_plat_get_bl31_params() except that is is 788 * used for the new LOAD_IMAGE_V2 option, which uses a slightly different 789 * method to pass the parameters. 790 * 791 * Return: bl31 params structure pointer 792 */ 793struct bl_params *bl2_plat_get_bl31_params_v2(uintptr_t bl32_entry, 794 uintptr_t bl33_entry, 795 uintptr_t fdt_addr); 796 797/** 798 * bl2_plat_get_bl31_params_v2_default() - prepare params for bl31. 799 * @bl32_entry: address of BL32 executable (secure) 800 * @bl33_entry: address of BL33 executable (non secure) 801 * @fdt_addr: address of Flat Device Tree 802 * 803 * This is the default implementation of bl2_plat_get_bl31_params_v2(). It 804 * prepares the linked list of the bl31 params, populates the image types and 805 * set the entry points for bl32 and bl33 (if available). 806 * 807 * NOTE: The memory is statically allocated, thus this function should be 808 * called only once. All subsequent calls will overwrite any changes. 809 * 810 * Return: bl31 params structure pointer 811 */ 812struct bl_params *bl2_plat_get_bl31_params_v2_default(uintptr_t bl32_entry, 813 uintptr_t bl33_entry, 814 uintptr_t fdt_addr); 815/** 816 * spl_optee_entry - entry function for optee 817 * 818 * args defind in op-tee project 819 * https://github.com/OP-TEE/optee_os/ 820 * core/arch/arm/kernel/generic_entry_a32.S 821 * @arg0: pagestore 822 * @arg1: (ARMv7 standard bootarg #1) 823 * @arg2: device tree address, (ARMv7 standard bootarg #2) 824 * @arg3: non-secure entry address (ARMv7 bootarg #0) 825 */ 826void __noreturn spl_optee_entry(void *arg0, void *arg1, void *arg2, void *arg3); 827 828/** 829 * spl_invoke_opensbi - boot using a RISC-V OpenSBI image 830 */ 831void spl_invoke_opensbi(struct spl_image_info *spl_image); 832 833/** 834 * board_return_to_bootrom - allow for boards to continue with the boot ROM 835 * 836 * If a board (e.g. the Rockchip RK3368 boards) provide some 837 * supporting functionality for SPL in their boot ROM and the SPL 838 * stage wants to return to the ROM code to continue booting, boards 839 * can implement 'board_return_to_bootrom'. 840 */ 841int board_return_to_bootrom(struct spl_image_info *spl_image, 842 struct spl_boot_device *bootdev); 843 844/** 845 * board_spl_fit_post_load - allow process images after loading finished 846 * @fit: Pointer to a valid Flattened Image Tree blob 847 */ 848void board_spl_fit_post_load(const void *fit); 849 850/** 851 * board_spl_fit_size_align - specific size align before processing payload 852 * 853 */ 854ulong board_spl_fit_size_align(ulong size); 855 856/** 857 * spl_perform_fixups() - arch/board-specific callback before processing 858 * the boot-payload 859 */ 860void spl_perform_fixups(struct spl_image_info *spl_image); 861 862/* 863 * spl_get_load_buffer() - get buffer for loading partial image data 864 * 865 * Returns memory area which can be populated by partial image data, 866 * ie. uImage or fitImage header. 867 */ 868struct image_header *spl_get_load_buffer(ssize_t offset, size_t size); 869 870void spl_save_restore_data(void); 871#endif 872