1 /* SPDX-License-Identifier: GPL-2.0+ */
3 * (C) Copyright 2008 Semihalf
5 * (C) Copyright 2000-2005
6 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
7 ********************************************************************
8 * NOTE: This header file defines an interface to U-Boot. Including
9 * this (unmodified) header file in another file is considered normal
10 * use of U-Boot, and does *not* fall under the heading of "derived
12 ********************************************************************
19 #include <asm/byteorder.h>
22 /* Define this to avoid #ifdefs later on */
27 #include <sys/types.h>
28 #include <linux/kconfig.h>
30 #define IMAGE_INDENT_STRING ""
35 #include <asm/u-boot.h>
37 #include <linker_lists.h>
39 #define IMAGE_INDENT_STRING " "
41 #endif /* USE_HOSTCC */
44 #include <linux/libfdt.h>
45 #include <fdt_support.h>
46 #include <u-boot/hash-checksum.h>
48 extern ulong image_load_addr
; /* Default Load Address */
49 extern ulong image_save_addr
; /* Default Save Address */
50 extern ulong image_save_size
; /* Default Save Size */
51 extern ulong image_load_offset
; /* Default Load Address Offset */
53 /* An invalid size, meaning that the image size is not known */
54 #define IMAGE_SIZE_INVAL (-1UL)
67 * Operating System Codes
69 * The following are exposed to uImage header.
70 * New IDs *MUST* be appended at the end of the list and *NEVER*
71 * inserted for backward compatibility.
74 IH_OS_INVALID
= 0, /* Invalid OS */
75 IH_OS_OPENBSD
, /* OpenBSD */
76 IH_OS_NETBSD
, /* NetBSD */
77 IH_OS_FREEBSD
, /* FreeBSD */
78 IH_OS_4_4BSD
, /* 4.4BSD */
79 IH_OS_LINUX
, /* Linux */
80 IH_OS_SVR4
, /* SVR4 */
81 IH_OS_ESIX
, /* Esix */
82 IH_OS_SOLARIS
, /* Solaris */
83 IH_OS_IRIX
, /* Irix */
85 IH_OS_DELL
, /* Dell */
87 IH_OS_LYNXOS
, /* LynxOS */
88 IH_OS_VXWORKS
, /* VxWorks */
89 IH_OS_PSOS
, /* pSOS */
91 IH_OS_U_BOOT
, /* Firmware */
92 IH_OS_RTEMS
, /* RTEMS */
93 IH_OS_ARTOS
, /* ARTOS */
94 IH_OS_UNITY
, /* Unity OS */
95 IH_OS_INTEGRITY
, /* INTEGRITY */
97 IH_OS_PLAN9
, /* Plan 9 */
98 IH_OS_OPENRTOS
, /* OpenRTOS */
99 IH_OS_ARM_TRUSTED_FIRMWARE
, /* ARM Trusted Firmware */
100 IH_OS_TEE
, /* Trusted Execution Environment */
101 IH_OS_OPENSBI
, /* RISC-V OpenSBI */
102 IH_OS_EFI
, /* EFI Firmware (e.g. GRUB2) */
108 * CPU Architecture Codes (supported by Linux)
110 * The following are exposed to uImage header.
111 * New IDs *MUST* be appended at the end of the list and *NEVER*
112 * inserted for backward compatibility.
115 IH_ARCH_INVALID
= 0, /* Invalid CPU */
116 IH_ARCH_ALPHA
, /* Alpha */
117 IH_ARCH_ARM
, /* ARM */
118 IH_ARCH_I386
, /* Intel x86 */
119 IH_ARCH_IA64
, /* IA64 */
120 IH_ARCH_MIPS
, /* MIPS */
121 IH_ARCH_MIPS64
, /* MIPS 64 Bit */
122 IH_ARCH_PPC
, /* PowerPC */
123 IH_ARCH_S390
, /* IBM S390 */
124 IH_ARCH_SH
, /* SuperH */
125 IH_ARCH_SPARC
, /* Sparc */
126 IH_ARCH_SPARC64
, /* Sparc 64 Bit */
127 IH_ARCH_M68K
, /* M68K */
128 IH_ARCH_NIOS
, /* Nios-32 */
129 IH_ARCH_MICROBLAZE
, /* MicroBlaze */
130 IH_ARCH_NIOS2
, /* Nios-II */
131 IH_ARCH_BLACKFIN
, /* Blackfin */
132 IH_ARCH_AVR32
, /* AVR32 */
133 IH_ARCH_ST200
, /* STMicroelectronics ST200 */
134 IH_ARCH_SANDBOX
, /* Sandbox architecture (test only) */
135 IH_ARCH_NDS32
, /* ANDES Technology - NDS32 */
136 IH_ARCH_OPENRISC
, /* OpenRISC 1000 */
137 IH_ARCH_ARM64
, /* ARM64 */
138 IH_ARCH_ARC
, /* Synopsys DesignWare ARC */
139 IH_ARCH_X86_64
, /* AMD x86_64, Intel and Via */
140 IH_ARCH_XTENSA
, /* Xtensa */
141 IH_ARCH_RISCV
, /* RISC-V */
149 * "Standalone Programs" are directly runnable in the environment
150 * provided by U-Boot; it is expected that (if they behave
151 * well) you can continue to work in U-Boot after return from
152 * the Standalone Program.
153 * "OS Kernel Images" are usually images of some Embedded OS which
154 * will take over control completely. Usually these programs
155 * will install their own set of exception handlers, device
156 * drivers, set up the MMU, etc. - this means, that you cannot
157 * expect to re-enter U-Boot except by resetting the CPU.
158 * "RAMDisk Images" are more or less just data blocks, and their
159 * parameters (address, size) are passed to an OS kernel that is
161 * "Multi-File Images" contain several images, typically an OS
162 * (Linux) kernel image and one or more data images like
163 * RAMDisks. This construct is useful for instance when you want
164 * to boot over the network using BOOTP etc., where the boot
165 * server provides just a single image file, but you want to get
166 * for instance an OS kernel and a RAMDisk image.
168 * "Multi-File Images" start with a list of image sizes, each
169 * image size (in bytes) specified by an "uint32_t" in network
170 * byte order. This list is terminated by an "(uint32_t)0".
171 * Immediately after the terminating 0 follow the images, one by
172 * one, all aligned on "uint32_t" boundaries (size rounded up to
173 * a multiple of 4 bytes - except for the last file).
175 * "Firmware Images" are binary images containing firmware (like
176 * U-Boot or FPGA images) which usually will be programmed to
179 * "Script files" are command sequences that will be executed by
180 * U-Boot's command interpreter; this feature is especially
181 * useful when you configure U-Boot to use a real shell (hush)
182 * as command interpreter (=> Shell Scripts).
184 * The following are exposed to uImage header.
185 * New IDs *MUST* be appended at the end of the list and *NEVER*
186 * inserted for backward compatibility.
189 IH_TYPE_INVALID
= 0, /* Invalid Image */
190 IH_TYPE_STANDALONE
, /* Standalone Program */
191 IH_TYPE_KERNEL
, /* OS Kernel Image */
192 IH_TYPE_RAMDISK
, /* RAMDisk Image */
193 IH_TYPE_MULTI
, /* Multi-File Image */
194 IH_TYPE_FIRMWARE
, /* Firmware Image */
195 IH_TYPE_SCRIPT
, /* Script file */
196 IH_TYPE_FILESYSTEM
, /* Filesystem Image (any type) */
197 IH_TYPE_FLATDT
, /* Binary Flat Device Tree Blob */
198 IH_TYPE_KWBIMAGE
, /* Kirkwood Boot Image */
199 IH_TYPE_IMXIMAGE
, /* Freescale IMXBoot Image */
200 IH_TYPE_UBLIMAGE
, /* Davinci UBL Image */
201 IH_TYPE_OMAPIMAGE
, /* TI OMAP Config Header Image */
202 IH_TYPE_AISIMAGE
, /* TI Davinci AIS Image */
203 /* OS Kernel Image, can run from any load address */
204 IH_TYPE_KERNEL_NOLOAD
,
205 IH_TYPE_PBLIMAGE
, /* Freescale PBL Boot Image */
206 IH_TYPE_MXSIMAGE
, /* Freescale MXSBoot Image */
207 IH_TYPE_GPIMAGE
, /* TI Keystone GPHeader Image */
208 IH_TYPE_ATMELIMAGE
, /* ATMEL ROM bootable Image */
209 IH_TYPE_SOCFPGAIMAGE
, /* Altera SOCFPGA CV/AV Preloader */
210 IH_TYPE_X86_SETUP
, /* x86 setup.bin Image */
211 IH_TYPE_LPC32XXIMAGE
, /* x86 setup.bin Image */
212 IH_TYPE_LOADABLE
, /* A list of typeless images */
213 IH_TYPE_RKIMAGE
, /* Rockchip Boot Image */
214 IH_TYPE_RKSD
, /* Rockchip SD card */
215 IH_TYPE_RKSPI
, /* Rockchip SPI image */
216 IH_TYPE_ZYNQIMAGE
, /* Xilinx Zynq Boot Image */
217 IH_TYPE_ZYNQMPIMAGE
, /* Xilinx ZynqMP Boot Image */
218 IH_TYPE_ZYNQMPBIF
, /* Xilinx ZynqMP Boot Image (bif) */
219 IH_TYPE_FPGA
, /* FPGA Image */
220 IH_TYPE_VYBRIDIMAGE
, /* VYBRID .vyb Image */
221 IH_TYPE_TEE
, /* Trusted Execution Environment OS Image */
222 IH_TYPE_FIRMWARE_IVT
, /* Firmware Image with HABv4 IVT */
223 IH_TYPE_PMMC
, /* TI Power Management Micro-Controller Firmware */
224 IH_TYPE_STM32IMAGE
, /* STMicroelectronics STM32 Image */
225 IH_TYPE_SOCFPGAIMAGE_V1
, /* Altera SOCFPGA A10 Preloader */
226 IH_TYPE_MTKIMAGE
, /* MediaTek BootROM loadable Image */
227 IH_TYPE_IMX8MIMAGE
, /* Freescale IMX8MBoot Image */
228 IH_TYPE_IMX8IMAGE
, /* Freescale IMX8Boot Image */
229 IH_TYPE_COPRO
, /* Coprocessor Image for remoteproc*/
230 IH_TYPE_SUNXI_EGON
, /* Allwinner eGON Boot Image */
231 IH_TYPE_SUNXI_TOC0
, /* Allwinner TOC0 Boot Image */
232 IH_TYPE_FDT_LEGACY
, /* Binary Flat Device Tree Blob in a Legacy Image */
233 IH_TYPE_RENESAS_SPKG
, /* Renesas SPKG image */
234 IH_TYPE_STARFIVE_SPL
, /* StarFive SPL image */
236 IH_TYPE_COUNT
, /* Number of image types */
242 * The following are exposed to uImage header.
243 * New IDs *MUST* be appended at the end of the list and *NEVER*
244 * inserted for backward compatibility.
247 IH_COMP_NONE
= 0, /* No Compression Used */
248 IH_COMP_GZIP
, /* gzip Compression Used */
249 IH_COMP_BZIP2
, /* bzip2 Compression Used */
250 IH_COMP_LZMA
, /* lzma Compression Used */
251 IH_COMP_LZO
, /* lzo Compression Used */
252 IH_COMP_LZ4
, /* lz4 Compression Used */
253 IH_COMP_ZSTD
, /* zstd Compression Used */
259 * Phases - images intended for particular U-Boot phases (SPL, etc.)
261 * @IH_PHASE_NONE: No phase information, can be loaded by any phase
262 * @IH_PHASE_U_BOOT: Only for U-Boot proper
263 * @IH_PHASE_SPL: Only for SPL
273 #define IMAGE_PHASE_SHIFT 8
274 #define IMAGE_PHASE_MASK (0xff << IMAGE_PHASE_SHIFT)
275 #define IMAGE_TYPE_MASK 0xff
278 * image_ph() - build a composite value combining and type
280 * @phase: Image phase value
281 * @type: Image type value
282 * Returns: Composite value containing both
284 static inline int image_ph(enum image_phase_t phase
, enum image_type_t type
)
286 return type
| (phase
<< IMAGE_PHASE_SHIFT
);
290 * image_ph_phase() - obtain the phase from a composite phase/type value
292 * @image_ph_type: Composite value to convert
293 * Returns: Phase value taken from the composite value
295 static inline int image_ph_phase(int image_ph_type
)
297 return (image_ph_type
& IMAGE_PHASE_MASK
) >> IMAGE_PHASE_SHIFT
;
301 * image_ph_type() - obtain the type from a composite phase/type value
303 * @image_ph_type: Composite value to convert
304 * Returns: Type value taken from the composite value
306 static inline int image_ph_type(int image_ph_type
)
308 return image_ph_type
& IMAGE_TYPE_MASK
;
311 #define LZ4F_MAGIC 0x184D2204 /* LZ4 Magic Number */
312 #define IH_MAGIC 0x27051956 /* Image Magic Number */
313 #define IH_NMLEN 32 /* Image Name Length */
315 /* Reused from common.h */
316 #define ROUND(a, b) (((a) + (b) - 1) & ~((b) - 1))
319 * Legacy format image header,
320 * all data in network byte order (aka natural aka bigendian).
322 struct legacy_img_hdr
{
323 uint32_t ih_magic
; /* Image Header Magic Number */
324 uint32_t ih_hcrc
; /* Image Header CRC Checksum */
325 uint32_t ih_time
; /* Image Creation Timestamp */
326 uint32_t ih_size
; /* Image Data Size */
327 uint32_t ih_load
; /* Data Load Address */
328 uint32_t ih_ep
; /* Entry Point Address */
329 uint32_t ih_dcrc
; /* Image Data CRC Checksum */
330 uint8_t ih_os
; /* Operating System */
331 uint8_t ih_arch
; /* CPU architecture */
332 uint8_t ih_type
; /* Image Type */
333 uint8_t ih_comp
; /* Compression Type */
334 uint8_t ih_name
[IH_NMLEN
]; /* Image Name */
338 ulong start
, end
; /* start/end of blob */
339 ulong image_start
, image_len
; /* start of image within blob, len of image */
340 ulong load
; /* load addr for the image */
341 uint8_t comp
, type
, os
; /* compression, type of image, os type */
342 uint8_t arch
; /* CPU architecture */
346 * Legacy and FIT format headers used by do_bootm() and do_bootm_<os>()
349 struct bootm_headers
{
351 * Legacy os image header, if it is a multi component image
352 * then boot_get_ramdisk() and get_fdt() will attempt to get
353 * data from second and third component accordingly.
355 struct legacy_img_hdr
*legacy_hdr_os
; /* image header pointer */
356 struct legacy_img_hdr legacy_hdr_os_copy
; /* header copy */
357 ulong legacy_hdr_valid
;
360 * The fit_ members are only used with FIT, but it involves a lot of
361 * #ifdefs to avoid compiling that code. Since FIT is the standard
362 * format, even for SPL, this extra data size seems worth it.
364 const char *fit_uname_cfg
; /* configuration node unit name */
366 void *fit_hdr_os
; /* os FIT image header */
367 const char *fit_uname_os
; /* os subimage node unit name */
368 int fit_noffset_os
; /* os subimage node offset */
370 void *fit_hdr_rd
; /* init ramdisk FIT image header */
371 const char *fit_uname_rd
; /* init ramdisk subimage node unit name */
372 int fit_noffset_rd
; /* init ramdisk subimage node offset */
374 void *fit_hdr_fdt
; /* FDT blob FIT image header */
375 const char *fit_uname_fdt
; /* FDT blob subimage node unit name */
376 int fit_noffset_fdt
;/* FDT blob subimage node offset */
378 void *fit_hdr_setup
; /* x86 setup FIT image header */
379 const char *fit_uname_setup
; /* x86 setup subimage node name */
380 int fit_noffset_setup
;/* x86 setup subimage node offset */
383 struct image_info os
; /* os image info */
384 ulong ep
; /* entry point of OS */
386 ulong rd_start
, rd_end
;/* ramdisk start/end */
388 char *ft_addr
; /* flat dev tree address */
389 ulong ft_len
; /* length of flat device tree */
398 int verify
; /* env_get("verify")[0] != 'n' */
400 #define BOOTM_STATE_START 0x00000001
401 #define BOOTM_STATE_FINDOS 0x00000002
402 #define BOOTM_STATE_FINDOTHER 0x00000004
403 #define BOOTM_STATE_LOADOS 0x00000008
404 #define BOOTM_STATE_RAMDISK 0x00000010
405 #define BOOTM_STATE_FDT 0x00000020
406 #define BOOTM_STATE_OS_CMDLINE 0x00000040
407 #define BOOTM_STATE_OS_BD_T 0x00000080
408 #define BOOTM_STATE_OS_PREP 0x00000100
409 #define BOOTM_STATE_OS_FAKE_GO 0x00000200 /* 'Almost' run the OS */
410 #define BOOTM_STATE_OS_GO 0x00000400
411 #define BOOTM_STATE_PRE_LOAD 0x00000800
412 #define BOOTM_STATE_MEASURE 0x00001000
415 #if defined(CONFIG_LMB) && !defined(USE_HOSTCC)
416 struct lmb lmb
; /* for memory mgmt */
421 #define images_lmb(_images) (&(_images)->lmb)
423 #define images_lmb(_images) NULL
426 extern struct bootm_headers images
;
429 * Some systems (for example LWMON) have very short watchdog periods;
430 * we must make sure to split long operations like memmove() or
431 * checksum calculations into reasonable chunks.
434 #define CHUNKSZ (64 * 1024)
437 #ifndef CHUNKSZ_CRC32
438 #define CHUNKSZ_CRC32 (64 * 1024)
442 #define CHUNKSZ_MD5 (64 * 1024)
446 #define CHUNKSZ_SHA1 (64 * 1024)
449 #define uimage_to_cpu(x) be32_to_cpu(x)
450 #define cpu_to_uimage(x) cpu_to_be32(x)
453 * Translation table for entries of a specific type; used by
454 * get_table_entry_id() and get_table_entry_name().
456 typedef struct table_entry
{
458 char *sname
; /* short (input) name to find table entry */
459 char *lname
; /* long (output) name to print for messages */
463 * Compression type and magic number mapping table.
465 struct comp_magic_map
{
468 unsigned char magic
[2];
472 * get_table_entry_id() scans the translation table trying to find an
473 * entry that matches the given short name. If a matching entry is
474 * found, it's id is returned to the caller.
476 int get_table_entry_id(const table_entry_t
*table
,
477 const char *table_name
, const char *name
);
479 * get_table_entry_name() scans the translation table trying to find
480 * an entry that matches the given id. If a matching entry is found,
481 * its long name is returned to the caller.
483 char *get_table_entry_name(const table_entry_t
*table
, char *msg
, int id
);
485 const char *genimg_get_os_name(uint8_t os
);
488 * genimg_get_os_short_name() - get the short name for an OS
490 * @param os OS (IH_OS_...)
491 * Return: OS short name, or "unknown" if unknown
493 const char *genimg_get_os_short_name(uint8_t comp
);
495 const char *genimg_get_arch_name(uint8_t arch
);
498 * genimg_get_phase_name() - Get the friendly name for a phase
500 * @phase: Phase value to look up
501 * Returns: Friendly name for the phase (e.g. "U-Boot phase")
503 const char *genimg_get_phase_name(enum image_phase_t phase
);
506 * genimg_get_phase_id() - Convert a phase name to an ID
508 * @name: Name to convert (e.g. "u-boot")
509 * Returns: ID for that phase (e.g. IH_PHASE_U_BOOT)
511 int genimg_get_phase_id(const char *name
);
514 * genimg_get_arch_short_name() - get the short name for an architecture
516 * @param arch Architecture type (IH_ARCH_...)
517 * Return: architecture short name, or "unknown" if unknown
519 const char *genimg_get_arch_short_name(uint8_t arch
);
521 const char *genimg_get_type_name(uint8_t type
);
524 * genimg_get_type_short_name() - get the short name for an image type
526 * @param type Image type (IH_TYPE_...)
527 * Return: image short name, or "unknown" if unknown
529 const char *genimg_get_type_short_name(uint8_t type
);
531 const char *genimg_get_comp_name(uint8_t comp
);
534 * genimg_get_comp_short_name() - get the short name for a compression method
536 * @param comp compression method (IH_COMP_...)
537 * Return: compression method short name, or "unknown" if unknown
539 const char *genimg_get_comp_short_name(uint8_t comp
);
542 * genimg_get_cat_name() - Get the name of an item in a category
544 * @category: Category of item
546 * Return: name of item, or "Unknown ..." if unknown
548 const char *genimg_get_cat_name(enum ih_category category
, uint id
);
551 * genimg_get_cat_short_name() - Get the short name of an item in a category
553 * @category: Category of item
555 * Return: short name of item, or "Unknown ..." if unknown
557 const char *genimg_get_cat_short_name(enum ih_category category
, uint id
);
560 * genimg_get_cat_count() - Get the number of items in a category
562 * @category: Category to check
563 * Return: the number of items in the category (IH_xxx_COUNT)
565 int genimg_get_cat_count(enum ih_category category
);
568 * genimg_get_cat_desc() - Get the description of a category
570 * @category: Category to check
571 * Return: the description of a category, e.g. "architecture". This
572 * effectively converts the enum to a string.
574 const char *genimg_get_cat_desc(enum ih_category category
);
577 * genimg_cat_has_id() - Check whether a category has an item
579 * @category: Category to check
581 * Return: true or false as to whether a category has an item
583 bool genimg_cat_has_id(enum ih_category category
, uint id
);
585 int genimg_get_os_id(const char *name
);
586 int genimg_get_arch_id(const char *name
);
587 int genimg_get_type_id(const char *name
);
588 int genimg_get_comp_id(const char *name
);
589 void genimg_print_size(uint32_t size
);
591 #if defined(CONFIG_TIMESTAMP) || defined(CONFIG_CMD_DATE) || defined(USE_HOSTCC)
592 #define IMAGE_ENABLE_TIMESTAMP 1
594 #define IMAGE_ENABLE_TIMESTAMP 0
596 void genimg_print_time(time_t timestamp
);
598 /* What to do with a image load address ('load = <> 'in the FIT) */
600 FIT_LOAD_IGNORED
, /* Ignore load address */
601 FIT_LOAD_OPTIONAL
, /* Can be provided, but optional */
602 FIT_LOAD_OPTIONAL_NON_ZERO
, /* Optional, a value of 0 is ignored */
603 FIT_LOAD_REQUIRED
, /* Must be provided */
606 int boot_get_setup(struct bootm_headers
*images
, uint8_t arch
, ulong
*setup_start
,
609 /* Image format types, returned by _get_format() routine */
610 #define IMAGE_FORMAT_INVALID 0x00
611 #define IMAGE_FORMAT_LEGACY 0x01 /* legacy image_header based format */
612 #define IMAGE_FORMAT_FIT 0x02 /* new, libfdt based format */
613 #define IMAGE_FORMAT_ANDROID 0x03 /* Android boot image */
616 * genimg_get_kernel_addr_fit() - Parse FIT specifier
618 * Get the real kernel start address from a string which is normally the first
619 * argv of bootm/bootz
621 * These cases are dealt with, based on the value of @img_addr:
622 * NULL: Returns image_load_addr, does not set last two args
623 * "<addr>": Returns address
626 * "[<addr>]#<conf>": Returns address (or image_load_addr),
627 * sets fit_uname_config to config name
628 * "[<addr>]:<subimage>": Returns address (or image_load_addr) and sets
629 * fit_uname_kernel to the subimage name
631 * @img_addr: a string might contain real image address (or NULL)
632 * @fit_uname_config: Returns configuration unit name
633 * @fit_uname_kernel: Returns subimage name
635 * Returns: kernel start address
637 ulong
genimg_get_kernel_addr_fit(const char *const img_addr
,
638 const char **fit_uname_config
,
639 const char **fit_uname_kernel
);
641 ulong
genimg_get_kernel_addr(char * const img_addr
);
642 int genimg_get_format(const void *img_addr
);
643 int genimg_has_config(struct bootm_headers
*images
);
646 * boot_get_fpga() - Locate the FPGA image
648 * @images: Information about images being loaded
649 * Return 0 if OK, non-zero on failure
651 int boot_get_fpga(struct bootm_headers
*images
);
654 * boot_get_ramdisk() - Locate the ramdisk
656 * @select: address or name of ramdisk to use, or NULL for default
657 * @images: pointer to the bootm images structure
658 * @arch: expected ramdisk architecture
659 * @rd_start: pointer to a ulong variable, will hold ramdisk start address
660 * @rd_end: pointer to a ulong variable, will hold ramdisk end
662 * boot_get_ramdisk() is responsible for finding a valid ramdisk image.
663 * Currently supported are the following ramdisk sources:
664 * - multicomponent kernel/ramdisk image,
665 * - commandline provided address of decicated ramdisk image.
668 * 0, if ramdisk image was found and valid, or skiped
669 * rd_start and rd_end are set to ramdisk start/end addresses if
670 * ramdisk image is found and valid
672 * 1, if ramdisk image is found but corrupted, or invalid
673 * rd_start and rd_end are set to 0 if no ramdisk exists
675 int boot_get_ramdisk(char const *select
, struct bootm_headers
*images
,
676 uint arch
, ulong
*rd_start
, ulong
*rd_end
);
679 * boot_get_loadable() - load a list of binaries to memory
681 * @images: pointer to the bootm images structure
683 * Takes the given FIT configuration, then looks for a field named
684 * "loadables", a list of elements in the FIT given as strings, e.g.:
685 * loadables = "linux_kernel", "fdt-2";
687 * Each string is parsed, loading the corresponding element from the FIT into
688 * memory. Once placed, no additional actions are taken.
691 * 0, if only valid images or no images are found
692 * error code, if an error occurs during fit_image_load
694 int boot_get_loadable(struct bootm_headers
*images
);
696 int boot_get_setup_fit(struct bootm_headers
*images
, uint8_t arch
,
697 ulong
*setup_start
, ulong
*setup_len
);
700 * boot_get_fdt_fit() - load a DTB from a FIT file (applying overlays)
702 * This deals with all aspects of loading an DTB from a FIT.
703 * The correct base image based on configuration will be selected, and
704 * then any overlays specified will be applied (as present in fit_uname_configp).
706 * @param images Boot images structure
707 * @param addr Address of FIT in memory
708 * @param fit_unamep On entry this is the requested image name
709 * (e.g. "kernel") or NULL to use the default. On exit
710 * points to the selected image name
711 * @param fit_uname_configp On entry this is the requested configuration
712 * name (e.g. "conf-1") or NULL to use the default. On
713 * exit points to the selected configuration name.
714 * @param arch Expected architecture (IH_ARCH_...)
715 * @param datap Returns address of loaded image
716 * @param lenp Returns length of loaded image
718 * Return: node offset of base image, or -ve error code on error
720 int boot_get_fdt_fit(struct bootm_headers
*images
, ulong addr
,
721 const char **fit_unamep
, const char **fit_uname_configp
,
722 int arch
, ulong
*datap
, ulong
*lenp
);
725 * fit_image_load() - load an image from a FIT
727 * This deals with all aspects of loading an image from a FIT, including
728 * selecting the right image based on configuration, verifying it, printing
729 * out progress messages, checking the type/arch/os and optionally copying it
730 * to the right load address.
732 * The property to look up is defined by image_type.
734 * @param images Boot images structure
735 * @param addr Address of FIT in memory
736 * @param fit_unamep On entry this is the requested image name
737 * (e.g. "kernel") or NULL to use the default. On exit
738 * points to the selected image name
739 * @param fit_uname_configp On entry this is the requested configuration
740 * name (e.g. "conf-1") or NULL to use the default. On
741 * exit points to the selected configuration name.
742 * @param arch Expected architecture (IH_ARCH_...)
743 * @param image_ph_type Required image type (IH_TYPE_...). If this is
744 * IH_TYPE_KERNEL then we allow IH_TYPE_KERNEL_NOLOAD
745 * also. If a phase is required, this is included also,
746 * see image_phase_and_type()
747 * @param bootstage_id ID of starting bootstage to use for progress updates.
748 * This will be added to the BOOTSTAGE_SUB values when
749 * calling bootstage_mark()
750 * @param load_op Decribes what to do with the load address
751 * @param datap Returns address of loaded image
752 * @param lenp Returns length of loaded image
753 * Return: node offset of image, or -ve error code on error:
754 * -ENOEXEC - unsupported architecture
755 * -ENOENT - could not find image / subimage
756 * -EACCES - hash, signature or decryptions failure
757 * -EBADF - invalid OS or image type, or cannot get image load-address
758 * -EXDEV - memory overwritten / overlap
759 * -NOEXEC - image decompression error, or invalid FDT
761 int fit_image_load(struct bootm_headers
*images
, ulong addr
,
762 const char **fit_unamep
, const char **fit_uname_configp
,
763 int arch
, int image_ph_type
, int bootstage_id
,
764 enum fit_load_op load_op
, ulong
*datap
, ulong
*lenp
);
767 * image_locate_script() - Locate the raw script in an image
769 * @buf: Address of image
770 * @size: Size of image in bytes
771 * @fit_uname: Node name of FIT image to read
772 * @confname: Node name of FIT config to read
773 * @datap: Returns pointer to raw script on success
774 * @lenp: Returns size of raw script on success
775 * @return 0 if OK, non-zero on error
777 int image_locate_script(void *buf
, int size
, const char *fit_uname
,
778 const char *confname
, char **datap
, uint
*lenp
);
781 * fit_get_node_from_config() - Look up an image a FIT by type
783 * This looks in the selected conf- node (images->fit_uname_cfg) for a
784 * particular image type (e.g. "kernel") and then finds the image that is
787 * For example, for something like:
800 * the function will return the node offset of the kernel@1 node, assuming
801 * that conf-1 is the chosen configuration.
803 * @param images Boot images structure
804 * @param prop_name Property name to look up (FIT_..._PROP)
805 * @param addr Address of FIT in memory
807 int fit_get_node_from_config(struct bootm_headers
*images
,
808 const char *prop_name
, ulong addr
);
811 * boot_get_fdt() - locate FDT devicetree to use for booting
813 * @buf: Pointer to image
814 * @select: FDT to select (this is normally argv[2] of the bootm command)
815 * @arch: architecture (IH_ARCH_...)
816 * @images: pointer to the bootm images structure
817 * @of_flat_tree: pointer to a char* variable, will hold fdt start address
818 * @of_size: pointer to a ulong variable, will hold fdt length
820 * boot_get_fdt() is responsible for finding a valid flat device tree image.
821 * Currently supported are the following FDT sources:
822 * - multicomponent kernel/ramdisk/FDT image,
823 * - commandline provided address of decicated FDT image.
826 * 0, if fdt image was found and valid, or skipped
827 * of_flat_tree and of_size are set to fdt start address and length if
828 * fdt image is found and valid
830 * 1, if fdt image is found but corrupted
831 * of_flat_tree and of_size are set to 0 if no fdt exists
833 int boot_get_fdt(void *buf
, const char *select
, uint arch
,
834 struct bootm_headers
*images
, char **of_flat_tree
,
837 void boot_fdt_add_mem_rsv_regions(struct lmb
*lmb
, void *fdt_blob
);
838 int boot_relocate_fdt(struct lmb
*lmb
, char **of_flat_tree
, ulong
*of_size
);
840 int boot_ramdisk_high(struct lmb
*lmb
, ulong rd_data
, ulong rd_len
,
841 ulong
*initrd_start
, ulong
*initrd_end
);
842 int boot_get_cmdline(struct lmb
*lmb
, ulong
*cmd_start
, ulong
*cmd_end
);
843 int boot_get_kbd(struct lmb
*lmb
, struct bd_info
**kbd
);
845 /*******************************************************************/
846 /* Legacy format specific code (prefixed with image_) */
847 /*******************************************************************/
848 static inline uint32_t image_get_header_size(void)
850 return sizeof(struct legacy_img_hdr
);
853 #define image_get_hdr_l(f) \
854 static inline uint32_t image_get_##f(const struct legacy_img_hdr *hdr) \
856 return uimage_to_cpu(hdr->ih_##f); \
858 image_get_hdr_l(magic
) /* image_get_magic */
859 image_get_hdr_l(hcrc
) /* image_get_hcrc */
860 image_get_hdr_l(time
) /* image_get_time */
861 image_get_hdr_l(size
) /* image_get_size */
862 image_get_hdr_l(load
) /* image_get_load */
863 image_get_hdr_l(ep
) /* image_get_ep */
864 image_get_hdr_l(dcrc
) /* image_get_dcrc */
866 #define image_get_hdr_b(f) \
867 static inline uint8_t image_get_##f(const struct legacy_img_hdr *hdr) \
869 return hdr->ih_##f; \
871 image_get_hdr_b(os
) /* image_get_os */
872 image_get_hdr_b(arch
) /* image_get_arch */
873 image_get_hdr_b(type
) /* image_get_type */
874 image_get_hdr_b(comp
) /* image_get_comp */
876 static inline char *image_get_name(const struct legacy_img_hdr
*hdr
)
878 return (char *)hdr
->ih_name
;
881 static inline uint32_t image_get_data_size(const struct legacy_img_hdr
*hdr
)
883 return image_get_size(hdr
);
887 * image_get_data - get image payload start address
890 * image_get_data() returns address of the image payload. For single
891 * component images it is image data start. For multi component
892 * images it points to the null terminated table of sub-images sizes.
895 * image payload data start address
897 static inline ulong
image_get_data(const struct legacy_img_hdr
*hdr
)
899 return ((ulong
)hdr
+ image_get_header_size());
902 static inline uint32_t image_get_image_size(const struct legacy_img_hdr
*hdr
)
904 return (image_get_size(hdr
) + image_get_header_size());
907 static inline ulong
image_get_image_end(const struct legacy_img_hdr
*hdr
)
909 return ((ulong
)hdr
+ image_get_image_size(hdr
));
912 #define image_set_hdr_l(f) \
913 static inline void image_set_##f(struct legacy_img_hdr *hdr, uint32_t val) \
915 hdr->ih_##f = cpu_to_uimage(val); \
917 image_set_hdr_l(magic
) /* image_set_magic */
918 image_set_hdr_l(hcrc
) /* image_set_hcrc */
919 image_set_hdr_l(time
) /* image_set_time */
920 image_set_hdr_l(size
) /* image_set_size */
921 image_set_hdr_l(load
) /* image_set_load */
922 image_set_hdr_l(ep
) /* image_set_ep */
923 image_set_hdr_l(dcrc
) /* image_set_dcrc */
925 #define image_set_hdr_b(f) \
926 static inline void image_set_##f(struct legacy_img_hdr *hdr, uint8_t val) \
930 image_set_hdr_b(os
) /* image_set_os */
931 image_set_hdr_b(arch
) /* image_set_arch */
932 image_set_hdr_b(type
) /* image_set_type */
933 image_set_hdr_b(comp
) /* image_set_comp */
935 static inline void image_set_name(struct legacy_img_hdr
*hdr
, const char *name
)
938 * This is equivalent to: strncpy(image_get_name(hdr), name, IH_NMLEN);
940 * Use the tortured code below to avoid a warning with gcc 12. We do not
941 * want to include a nul terminator if the name is of length IH_NMLEN
943 memcpy(image_get_name(hdr
), name
, strnlen(name
, IH_NMLEN
));
946 int image_check_hcrc(const struct legacy_img_hdr
*hdr
);
947 int image_check_dcrc(const struct legacy_img_hdr
*hdr
);
949 ulong
env_get_bootm_low(void);
950 phys_size_t
env_get_bootm_size(void);
951 phys_size_t
env_get_bootm_mapsize(void);
953 void memmove_wd(void *to
, void *from
, size_t len
, ulong chunksz
);
955 static inline int image_check_magic(const struct legacy_img_hdr
*hdr
)
957 return (image_get_magic(hdr
) == IH_MAGIC
);
960 static inline int image_check_type(const struct legacy_img_hdr
*hdr
, uint8_t type
)
962 return (image_get_type(hdr
) == type
);
965 static inline int image_check_arch(const struct legacy_img_hdr
*hdr
, uint8_t arch
)
967 /* Let's assume that sandbox can load any architecture */
968 if (!tools_build() && IS_ENABLED(CONFIG_SANDBOX
))
970 return (image_get_arch(hdr
) == arch
) ||
971 (image_get_arch(hdr
) == IH_ARCH_ARM
&& arch
== IH_ARCH_ARM64
);
974 static inline int image_check_os(const struct legacy_img_hdr
*hdr
, uint8_t os
)
976 return (image_get_os(hdr
) == os
);
979 ulong
image_multi_count(const struct legacy_img_hdr
*hdr
);
980 void image_multi_getimg(const struct legacy_img_hdr
*hdr
, ulong idx
,
981 ulong
*data
, ulong
*len
);
983 void image_print_contents(const void *hdr
);
986 static inline int image_check_target_arch(const struct legacy_img_hdr
*hdr
)
988 #ifndef IH_ARCH_DEFAULT
989 # error "please define IH_ARCH_DEFAULT in your arch asm/u-boot.h"
991 return image_check_arch(hdr
, IH_ARCH_DEFAULT
);
993 #endif /* USE_HOSTCC */
996 * image_decomp_type() - Find out compression type of an image
998 * @buf: Address in U-Boot memory where image is loaded.
999 * @len: Length of the compressed image.
1000 * Return: compression type or IH_COMP_NONE if not compressed.
1002 * Note: Only following compression types are supported now.
1003 * lzo, lzma, gzip, bzip2
1005 int image_decomp_type(const unsigned char *buf
, ulong len
);
1008 * image_decomp() - decompress an image
1010 * @comp: Compression algorithm that is used (IH_COMP_...)
1011 * @load: Destination load address in U-Boot memory
1012 * @image_start Image start address (where we are decompressing from)
1013 * @type: OS type (IH_OS_...)
1014 * @load_buf: Place to decompress to
1015 * @image_buf: Address to decompress from
1016 * @image_len: Number of bytes in @image_buf to decompress
1017 * @unc_len: Available space for decompression
1018 * Return: 0 if OK, -ve on error (BOOTM_ERR_...)
1020 int image_decomp(int comp
, ulong load
, ulong image_start
, int type
,
1021 void *load_buf
, void *image_buf
, ulong image_len
,
1022 uint unc_len
, ulong
*load_end
);
1025 * Set up properties in the FDT
1027 * This sets up properties in the FDT that is to be passed to linux.
1029 * @images: Images information
1030 * @blob: FDT to update
1031 * @lmb: Points to logical memory block structure
1032 * Return: 0 if ok, <0 on failure
1034 int image_setup_libfdt(struct bootm_headers
*images
, void *blob
,
1038 * Set up the FDT to use for booting a kernel
1040 * This performs ramdisk setup, sets up the FDT if required, and adds
1041 * paramters to the FDT if libfdt is available.
1043 * @param images Images information
1044 * Return: 0 if ok, <0 on failure
1046 int image_setup_linux(struct bootm_headers
*images
);
1049 * bootz_setup() - Extract stat and size of a Linux xImage
1051 * @image: Address of image
1052 * @start: Returns start address of image
1053 * @end : Returns end address of image
1054 * Return: 0 if OK, 1 if the image was not recognised
1056 int bootz_setup(ulong image
, ulong
*start
, ulong
*end
);
1059 * Return the correct start address and size of a Linux aarch64 Image.
1061 * @image: Address of image
1062 * @start: Returns start address of image
1063 * @size : Returns size image
1064 * @force_reloc: Ignore image->ep field, always place image to RAM start
1065 * Return: 0 if OK, 1 if the image was not recognised
1067 int booti_setup(ulong image
, ulong
*relocated_addr
, ulong
*size
,
1070 /*******************************************************************/
1071 /* New uImage format specific code (prefixed with fit_) */
1072 /*******************************************************************/
1074 #define FIT_IMAGES_PATH "/images"
1075 #define FIT_CONFS_PATH "/configurations"
1077 /* hash/signature/key node */
1078 #define FIT_HASH_NODENAME "hash"
1079 #define FIT_ALGO_PROP "algo"
1080 #define FIT_VALUE_PROP "value"
1081 #define FIT_IGNORE_PROP "uboot-ignore"
1082 #define FIT_SIG_NODENAME "signature"
1083 #define FIT_KEY_REQUIRED "required"
1084 #define FIT_KEY_HINT "key-name-hint"
1087 #define FIT_CIPHER_NODENAME "cipher"
1088 #define FIT_ALGO_PROP "algo"
1091 #define FIT_DATA_PROP "data"
1092 #define FIT_DATA_POSITION_PROP "data-position"
1093 #define FIT_DATA_OFFSET_PROP "data-offset"
1094 #define FIT_DATA_SIZE_PROP "data-size"
1095 #define FIT_TIMESTAMP_PROP "timestamp"
1096 #define FIT_DESC_PROP "description"
1097 #define FIT_ARCH_PROP "arch"
1098 #define FIT_TYPE_PROP "type"
1099 #define FIT_OS_PROP "os"
1100 #define FIT_COMP_PROP "compression"
1101 #define FIT_ENTRY_PROP "entry"
1102 #define FIT_LOAD_PROP "load"
1104 /* configuration node */
1105 #define FIT_KERNEL_PROP "kernel"
1106 #define FIT_RAMDISK_PROP "ramdisk"
1107 #define FIT_FDT_PROP "fdt"
1108 #define FIT_LOADABLE_PROP "loadables"
1109 #define FIT_DEFAULT_PROP "default"
1110 #define FIT_SETUP_PROP "setup"
1111 #define FIT_FPGA_PROP "fpga"
1112 #define FIT_FIRMWARE_PROP "firmware"
1113 #define FIT_STANDALONE_PROP "standalone"
1114 #define FIT_SCRIPT_PROP "script"
1115 #define FIT_PHASE_PROP "phase"
1117 #define FIT_MAX_HASH_LEN HASH_MAX_DIGEST_SIZE
1119 /* cmdline argument format parsing */
1120 int fit_parse_conf(const char *spec
, ulong addr_curr
,
1121 ulong
*addr
, const char **conf_name
);
1122 int fit_parse_subimage(const char *spec
, ulong addr_curr
,
1123 ulong
*addr
, const char **image_name
);
1125 int fit_get_subimage_count(const void *fit
, int images_noffset
);
1126 void fit_print_contents(const void *fit
);
1127 void fit_image_print(const void *fit
, int noffset
, const char *p
);
1130 * fit_get_end - get FIT image size
1131 * @fit: pointer to the FIT format image header
1134 * size of the FIT image (blob) in memory
1136 static inline ulong
fit_get_size(const void *fit
)
1138 return fdt_totalsize(fit
);
1142 * fit_get_end - get FIT image end
1143 * @fit: pointer to the FIT format image header
1146 * end address of the FIT image (blob) in memory
1148 ulong
fit_get_end(const void *fit
);
1151 * fit_get_name - get FIT node name
1152 * @fit: pointer to the FIT format image header
1156 * pointer to node name, on success
1158 static inline const char *fit_get_name(const void *fit_hdr
,
1159 int noffset
, int *len
)
1161 return fdt_get_name(fit_hdr
, noffset
, len
);
1164 int fit_get_desc(const void *fit
, int noffset
, char **desc
);
1165 int fit_get_timestamp(const void *fit
, int noffset
, time_t *timestamp
);
1167 int fit_image_get_node(const void *fit
, const char *image_uname
);
1168 int fit_image_get_os(const void *fit
, int noffset
, uint8_t *os
);
1169 int fit_image_get_arch(const void *fit
, int noffset
, uint8_t *arch
);
1170 int fit_image_get_type(const void *fit
, int noffset
, uint8_t *type
);
1171 int fit_image_get_comp(const void *fit
, int noffset
, uint8_t *comp
);
1172 int fit_image_get_load(const void *fit
, int noffset
, ulong
*load
);
1173 int fit_image_get_entry(const void *fit
, int noffset
, ulong
*entry
);
1174 int fit_image_get_data(const void *fit
, int noffset
,
1175 const void **data
, size_t *size
);
1176 int fit_image_get_data_offset(const void *fit
, int noffset
, int *data_offset
);
1177 int fit_image_get_data_position(const void *fit
, int noffset
,
1178 int *data_position
);
1179 int fit_image_get_data_size(const void *fit
, int noffset
, int *data_size
);
1180 int fit_image_get_data_size_unciphered(const void *fit
, int noffset
,
1182 int fit_image_get_data_and_size(const void *fit
, int noffset
,
1183 const void **data
, size_t *size
);
1186 * fit_get_data_node() - Get verified image data for an image
1187 * @fit: Pointer to the FIT format image header
1188 * @image_uname: The name of the image node
1189 * @data: A pointer which will be filled with the location of the image data
1190 * @size: A pointer which will be filled with the size of the image data
1192 * This function looks up the location and size of an image specified by its
1193 * name. For example, if you had a FIT like::
1201 * Then you could look up the data location and size of the my-firmware image
1202 * by calling this function with @image_uname set to "my-firmware". This
1203 * function also verifies the image data (if enabled) before returning. The
1204 * image description is printed out on success. @data and @size will not be
1205 * modified on faulure.
1209 * * -EINVAL if the image could not be verified
1210 * * -ENOENT if there was a problem getting the data/size
1211 * * Another negative error if there was a problem looking up the image node.
1213 int fit_get_data_node(const void *fit
, const char *image_uname
,
1214 const void **data
, size_t *size
);
1217 * fit_get_data_conf_prop() - Get verified image data for a property in /conf
1218 * @fit: Pointer to the FIT format image header
1219 * @prop_name: The name of the property in /conf referencing the image
1220 * @data: A pointer which will be filled with the location of the image data
1221 * @size: A pointer which will be filled with the size of the image data
1223 * This function looks up the location and size of an image specified by a
1224 * property in /conf. For example, if you had a FIT like::
1233 * default = "conf-1";
1235 * some-firmware = "my-firmware";
1239 * Then you could look up the data location and size of the my-firmware image
1240 * by calling this function with @prop_name set to "some-firmware". This
1241 * function also verifies the image data (if enabled) before returning. The
1242 * image description is printed out on success. @data and @size will not be
1243 * modified on faulure.
1247 * * -EINVAL if the image could not be verified
1248 * * -ENOENT if there was a problem getting the data/size
1249 * * Another negative error if there was a problem looking up the configuration
1252 int fit_get_data_conf_prop(const void *fit
, const char *prop_name
,
1253 const void **data
, size_t *size
);
1255 int fit_image_hash_get_algo(const void *fit
, int noffset
, const char **algo
);
1256 int fit_image_hash_get_value(const void *fit
, int noffset
, uint8_t **value
,
1259 int fit_set_timestamp(void *fit
, int noffset
, time_t timestamp
);
1262 * fit_pre_load_data() - add public key to fdt blob
1264 * Adds public key to the node pre load.
1266 * @keydir: Directory containing keys
1267 * @keydest: FDT blob to write public key
1268 * @fit: Pointer to the FIT format image header
1274 int fit_pre_load_data(const char *keydir
, void *keydest
, void *fit
);
1276 int fit_cipher_data(const char *keydir
, void *keydest
, void *fit
,
1277 const char *comment
, int require_keys
,
1278 const char *engine_id
, const char *cmdname
);
1280 #define NODE_MAX_NAME_LEN 80
1283 * struct image_summary - Provides information about signing info added
1285 * @sig_offset: Offset of the node in the blob devicetree where the signature
1287 * @sig_path: Path to @sig_offset
1288 * @keydest_offset: Offset of the node in the keydest devicetree where the
1289 * public key was written (-1 if none)
1290 * @keydest_path: Path to @keydest_offset
1292 struct image_summary
{
1294 char sig_path
[NODE_MAX_NAME_LEN
];
1296 char keydest_path
[NODE_MAX_NAME_LEN
];
1300 * fit_add_verification_data() - add verification data to FIT image nodes
1302 * @keydir: Directory containing keys
1303 * @kwydest: FDT blob to write public key information to (NULL if none)
1304 * @fit: Pointer to the FIT format image header
1305 * @comment: Comment to add to signature nodes
1306 * @require_keys: Mark all keys as 'required'
1307 * @engine_id: Engine to use for signing
1308 * @cmdname: Command name used when reporting errors
1309 * @algo_name: Algorithm name, or NULL if to be read from FIT
1310 * @summary: Returns information about what data was written
1312 * Adds hash values for all component images in the FIT blob.
1313 * Hashes are calculated for all component images which have hash subnodes
1314 * with algorithm property set to one of the supported hash algorithms.
1316 * Also add signatures if signature nodes are present.
1320 * libfdt error code, on failure
1322 int fit_add_verification_data(const char *keydir
, const char *keyfile
,
1323 void *keydest
, void *fit
, const char *comment
,
1324 int require_keys
, const char *engine_id
,
1325 const char *cmdname
, const char *algo_name
,
1326 struct image_summary
*summary
);
1329 * fit_image_verify_with_data() - Verify an image with given data
1331 * @fit: Pointer to the FIT format image header
1332 * @image_offset: Offset in @fit of image to verify
1333 * @key_blob: FDT containing public keys
1334 * @data: Image data to verify
1335 * @size: Size of image data
1337 int fit_image_verify_with_data(const void *fit
, int image_noffset
,
1338 const void *key_blob
, const void *data
,
1341 int fit_image_verify(const void *fit
, int noffset
);
1342 #if CONFIG_IS_ENABLED(FIT_SIGNATURE)
1343 int fit_config_verify(const void *fit
, int conf_noffset
);
1345 static inline int fit_config_verify(const void *fit
, int conf_noffset
)
1350 int fit_all_image_verify(const void *fit
);
1351 int fit_config_decrypt(const void *fit
, int conf_noffset
);
1352 int fit_image_check_os(const void *fit
, int noffset
, uint8_t os
);
1353 int fit_image_check_arch(const void *fit
, int noffset
, uint8_t arch
);
1354 int fit_image_check_type(const void *fit
, int noffset
, uint8_t type
);
1355 int fit_image_check_comp(const void *fit
, int noffset
, uint8_t comp
);
1358 * fit_check_format() - Check that the FIT is valid
1360 * This performs various checks on the FIT to make sure it is suitable for
1361 * use, looking for mandatory properties, nodes, etc.
1363 * If FIT_FULL_CHECK is enabled, it also runs it through libfdt to make
1364 * sure that there are no strange tags or broken nodes in the FIT.
1366 * @fit: pointer to the FIT format image header
1367 * Return: 0 if OK, -ENOEXEC if not an FDT file, -EINVAL if the full FDT check
1368 * failed (e.g. due to bad structure), -ENOMSG if the description is
1369 * missing, -EBADMSG if the timestamp is missing, -ENOENT if the /images
1372 int fit_check_format(const void *fit
, ulong size
);
1375 * fit_conf_find_compat() - find most compatible configuration
1376 * @fit: pointer to the FIT format image header
1377 * @fdt: pointer to the device tree to compare against
1379 * Attempts to find the configuration whose fdt is the most compatible with the
1380 * passed in device tree
1389 * |-o configurations
1397 * |-compatible = "foo,bar", "bim,bam"
1400 * |-compatible = "foo,bar",
1403 * |-compatible = "bim,bam", "baz,biz"
1405 * Configuration 1 would be picked because the first string in U-Boot's
1406 * compatible list, "foo,bar", matches a compatible string in the root of fdt1.
1407 * "bim,bam" in fdt2 matches the second string which isn't as good as fdt1.
1409 * As an optimization, the compatible property from the FDT's root node can be
1410 * copied into the configuration node in the FIT image. This is required to
1411 * match configurations with compressed FDTs.
1413 * Returns: offset to the configuration to use if one was found, -1 otherwise
1415 int fit_conf_find_compat(const void *fit
, const void *fdt
);
1418 * fit_conf_get_node - get node offset for configuration of a given unit name
1419 * @fit: pointer to the FIT format image header
1420 * @conf_uname: configuration node unit name (NULL to use default)
1422 * fit_conf_get_node() finds a configuration (within the '/configurations'
1423 * parent node) of a provided unit name. If configuration is found its node
1424 * offset is returned to the caller.
1426 * When NULL is provided in second argument fit_conf_get_node() will search
1427 * for a default configuration node instead. Default configuration node unit
1428 * name is retrieved from FIT_DEFAULT_PROP property of the '/configurations'
1432 * configuration node offset when found (>=0)
1433 * negative number on failure (FDT_ERR_* code)
1435 int fit_conf_get_node(const void *fit
, const char *conf_uname
);
1437 int fit_conf_get_prop_node_count(const void *fit
, int noffset
,
1438 const char *prop_name
);
1439 int fit_conf_get_prop_node_index(const void *fit
, int noffset
,
1440 const char *prop_name
, int index
);
1443 * fit_conf_get_prop_node() - Get node refered to by a configuration
1444 * @fit: FIT to check
1445 * @noffset: Offset of conf@xxx node to check
1446 * @prop_name: Property to read from the conf node
1447 * @phase: Image phase to use, IH_PHASE_NONE for any
1449 * The conf- nodes contain references to other nodes, using properties
1450 * like 'kernel = "kernel"'. Given such a property name (e.g. "kernel"),
1451 * return the offset of the node referred to (e.g. offset of node
1454 int fit_conf_get_prop_node(const void *fit
, int noffset
, const char *prop_name
,
1455 enum image_phase_t phase
);
1457 int fit_check_ramdisk(const void *fit
, int os_noffset
,
1458 uint8_t arch
, int verify
);
1460 int calculate_hash(const void *data
, int data_len
, const char *algo
,
1461 uint8_t *value
, int *value_len
);
1464 * At present we only support signing on the host, and verification on the
1467 #if defined(USE_HOSTCC)
1468 # if CONFIG_IS_ENABLED(FIT_SIGNATURE)
1469 # define IMAGE_ENABLE_SIGN 1
1470 # define FIT_IMAGE_ENABLE_VERIFY 1
1471 # include <openssl/evp.h>
1473 # define IMAGE_ENABLE_SIGN 0
1474 # define FIT_IMAGE_ENABLE_VERIFY 0
1477 # define IMAGE_ENABLE_SIGN 0
1478 # define FIT_IMAGE_ENABLE_VERIFY CONFIG_IS_ENABLED(FIT_SIGNATURE)
1482 void *image_get_host_blob(void);
1483 void image_set_host_blob(void *host_blob
);
1484 # define gd_fdt_blob() image_get_host_blob()
1486 # define gd_fdt_blob() (gd->fdt_blob)
1490 * Information passed to the signing routines
1492 * Either 'keydir', 'keyname', or 'keyfile' can be NULL. However, either
1493 * 'keyfile', or both 'keydir' and 'keyname' should have valid values. If
1494 * neither are valid, some operations might fail with EINVAL.
1496 struct image_sign_info
{
1497 const char *keydir
; /* Directory conaining keys */
1498 const char *keyname
; /* Name of key to use */
1499 const char *keyfile
; /* Filename of private or public key */
1500 const void *fit
; /* Pointer to FIT blob */
1501 int node_offset
; /* Offset of signature node */
1502 const char *name
; /* Algorithm name */
1503 struct checksum_algo
*checksum
; /* Checksum algorithm information */
1504 struct padding_algo
*padding
; /* Padding algorithm information */
1505 struct crypto_algo
*crypto
; /* Crypto algorithm information */
1506 const void *fdt_blob
; /* FDT containing public keys */
1507 int required_keynode
; /* Node offset of key to use: -1=any */
1508 const char *require_keys
; /* Value for 'required' property */
1509 const char *engine_id
; /* Engine to use for signing */
1511 * Note: the following two fields are always valid even w/o
1512 * RSA_VERIFY_WITH_PKEY in order to make sure this structure is
1513 * the same on target and host. Otherwise, vboot test may fail.
1515 const void *key
; /* Pointer to public key in DER */
1516 int keylen
; /* Length of public key */
1519 /* A part of an image, used for hashing */
1520 struct image_region
{
1525 struct checksum_algo
{
1527 const int checksum_len
;
1529 const uint8_t *der_prefix
;
1530 #if IMAGE_ENABLE_SIGN
1531 const EVP_MD
*(*calculate_sign
)(void);
1533 int (*calculate
)(const char *name
,
1534 const struct image_region
*region
,
1535 int region_count
, uint8_t *checksum
);
1538 struct crypto_algo
{
1539 const char *name
; /* Name of algorithm */
1543 * sign() - calculate and return signature for given input data
1545 * @info: Specifies key and FIT information
1546 * @data: Pointer to the input data
1547 * @data_len: Data length
1548 * @sigp: Set to an allocated buffer holding the signature
1549 * @sig_len: Set to length of the calculated hash
1551 * This computes input data signature according to selected algorithm.
1552 * Resulting signature value is placed in an allocated buffer, the
1553 * pointer is returned as *sigp. The length of the calculated
1554 * signature is returned via the sig_len pointer argument. The caller
1555 * should free *sigp.
1557 * @return: 0, on success, -ve on error
1559 int (*sign
)(struct image_sign_info
*info
,
1560 const struct image_region region
[],
1561 int region_count
, uint8_t **sigp
, uint
*sig_len
);
1564 * add_verify_data() - Add verification information to FDT
1566 * Add public key information to the FDT node, suitable for
1567 * verification at run-time. The information added depends on the
1568 * algorithm being used.
1570 * @info: Specifies key and FIT information
1571 * @keydest: Destination FDT blob for public key data
1572 * @return: node offset within the FDT blob where the data was written,
1575 int (*add_verify_data
)(struct image_sign_info
*info
, void *keydest
);
1578 * verify() - Verify a signature against some data
1580 * @info: Specifies key and FIT information
1581 * @data: Pointer to the input data
1582 * @data_len: Data length
1584 * @sig_len: Number of bytes in signature
1585 * @return 0 if verified, -ve on error
1587 int (*verify
)(struct image_sign_info
*info
,
1588 const struct image_region region
[], int region_count
,
1589 uint8_t *sig
, uint sig_len
);
1592 /* Declare a new U-Boot crypto algorithm handler */
1593 #define U_BOOT_CRYPTO_ALGO(__name) \
1594 ll_entry_declare(struct crypto_algo, __name, cryptos)
1596 struct padding_algo
{
1598 int (*verify
)(struct image_sign_info
*info
,
1599 const uint8_t *pad
, int pad_len
,
1600 const uint8_t *hash
, int hash_len
);
1603 /* Declare a new U-Boot padding algorithm handler */
1604 #define U_BOOT_PADDING_ALGO(__name) \
1605 ll_entry_declare(struct padding_algo, __name, paddings)
1608 * image_get_checksum_algo() - Look up a checksum algorithm
1610 * @param full_name Name of algorithm in the form "checksum,crypto"
1611 * Return: pointer to algorithm information, or NULL if not found
1613 struct checksum_algo
*image_get_checksum_algo(const char *full_name
);
1616 * image_get_crypto_algo() - Look up a cryptosystem algorithm
1618 * @param full_name Name of algorithm in the form "checksum,crypto"
1619 * Return: pointer to algorithm information, or NULL if not found
1621 struct crypto_algo
*image_get_crypto_algo(const char *full_name
);
1624 * image_get_padding_algo() - Look up a padding algorithm
1626 * @param name Name of padding algorithm
1627 * Return: pointer to algorithm information, or NULL if not found
1629 struct padding_algo
*image_get_padding_algo(const char *name
);
1631 #define IMAGE_PRE_LOAD_SIG_MAGIC 0x55425348
1632 #define IMAGE_PRE_LOAD_SIG_OFFSET_MAGIC 0
1633 #define IMAGE_PRE_LOAD_SIG_OFFSET_IMG_LEN 4
1634 #define IMAGE_PRE_LOAD_SIG_OFFSET_SIG 8
1636 #define IMAGE_PRE_LOAD_PATH "/image/pre-load/sig"
1637 #define IMAGE_PRE_LOAD_PROP_ALGO_NAME "algo-name"
1638 #define IMAGE_PRE_LOAD_PROP_PADDING_NAME "padding-name"
1639 #define IMAGE_PRE_LOAD_PROP_SIG_SIZE "signature-size"
1640 #define IMAGE_PRE_LOAD_PROP_PUBLIC_KEY "public-key"
1641 #define IMAGE_PRE_LOAD_PROP_MANDATORY "mandatory"
1644 * Information in the device-tree about the signature in the header
1646 struct image_sig_info
{
1647 char *algo_name
; /* Name of the algo (eg: sha256,rsa2048) */
1648 char *padding_name
; /* Name of the padding */
1649 uint8_t *key
; /* Public signature key */
1650 int key_len
; /* Length of the public key */
1651 uint32_t sig_size
; /* size of the signature (in the header) */
1652 int mandatory
; /* Set if the signature is mandatory */
1654 struct image_sign_info sig_info
; /* Signature info */
1658 * Header of the signature header
1660 struct sig_header_s
{
1663 uint32_t header_size
;
1664 uint32_t image_size
;
1665 uint32_t offset_img_sig
;
1669 uint8_t sha256_img_sig
[SHA256_SUM_LEN
];
1672 #define SIG_HEADER_LEN (sizeof(struct sig_header_s))
1675 * image_pre_load() - Manage pre load header
1677 * Manage the pre-load header before launching the image.
1678 * It checks the signature of the image. It also set the
1679 * variable image_load_offset to skip this header before
1680 * launching the image.
1682 * @param addr Address of the image
1683 * @return: 0 on success, -ve on error
1685 int image_pre_load(ulong addr
);
1688 * fit_image_verify_required_sigs() - Verify signatures marked as 'required'
1690 * @fit: FIT to check
1691 * @image_noffset: Offset of image node to check
1692 * @data: Image data to check
1693 * @size: Size of image data
1694 * @key_blob: FDT containing public keys
1695 * @no_sigsp: Returns 1 if no signatures were required, and
1696 * therefore nothing was checked. The caller may wish
1697 * to fall back to other mechanisms, or refuse to
1699 * Return: 0 if all verified ok, <0 on error
1701 int fit_image_verify_required_sigs(const void *fit
, int image_noffset
,
1702 const char *data
, size_t size
, const void *key_blob
,
1706 * fit_image_check_sig() - Check a single image signature node
1708 * @fit: FIT to check
1709 * @noffset: Offset of signature node to check
1710 * @data: Image data to check
1711 * @size: Size of image data
1712 * @keyblob: Key blob to check (typically the control FDT)
1713 * @required_keynode: Offset in the keyblob of the required key node,
1714 * if any. If this is given, then the image wil not
1715 * pass verification unless that key is used. If this is
1716 * -1 then any signature will do.
1717 * @err_msgp: In the event of an error, this will be pointed to a
1718 * help error string to display to the user.
1719 * Return: 0 if all verified ok, <0 on error
1721 int fit_image_check_sig(const void *fit
, int noffset
, const void *data
,
1722 size_t size
, const void *key_blob
, int required_keynode
,
1725 int fit_image_decrypt_data(const void *fit
,
1726 int image_noffset
, int cipher_noffset
,
1727 const void *data
, size_t size
,
1728 void **data_unciphered
, size_t *size_unciphered
);
1731 * fit_region_make_list() - Make a list of regions to hash
1733 * Given a list of FIT regions (offset, size) provided by libfdt, create
1734 * a list of regions (void *, size) for use by the signature creationg
1735 * and verification code.
1737 * @fit: FIT image to process
1738 * @fdt_regions: Regions as returned by libfdt
1739 * @count: Number of regions returned by libfdt
1740 * @region: Place to put list of regions (NULL to allocate it)
1741 * Return: pointer to list of regions, or NULL if out of memory
1743 struct image_region
*fit_region_make_list(const void *fit
,
1744 struct fdt_region
*fdt_regions
, int count
,
1745 struct image_region
*region
);
1747 static inline int fit_image_check_target_arch(const void *fdt
, int node
)
1750 return fit_image_check_arch(fdt
, node
, IH_ARCH_DEFAULT
);
1757 * At present we only support ciphering on the host, and unciphering on the
1760 #if defined(USE_HOSTCC)
1761 # if defined(CONFIG_FIT_CIPHER)
1762 # define IMAGE_ENABLE_ENCRYPT 1
1763 # define IMAGE_ENABLE_DECRYPT 1
1764 # include <openssl/evp.h>
1766 # define IMAGE_ENABLE_ENCRYPT 0
1767 # define IMAGE_ENABLE_DECRYPT 0
1770 # define IMAGE_ENABLE_ENCRYPT 0
1771 # define IMAGE_ENABLE_DECRYPT CONFIG_IS_ENABLED(FIT_CIPHER)
1774 /* Information passed to the ciphering routines */
1775 struct image_cipher_info
{
1776 const char *keydir
; /* Directory containing keys */
1777 const char *keyname
; /* Name of key to use */
1778 const char *ivname
; /* Name of IV to use */
1779 const void *fit
; /* Pointer to FIT blob */
1780 int node_noffset
; /* Offset of the cipher node */
1781 const char *name
; /* Algorithm name */
1782 struct cipher_algo
*cipher
; /* Cipher algorithm information */
1783 const void *fdt_blob
; /* FDT containing key and IV */
1784 const void *key
; /* Value of the key */
1785 const void *iv
; /* Value of the IV */
1786 size_t size_unciphered
; /* Size of the unciphered data */
1789 struct cipher_algo
{
1790 const char *name
; /* Name of algorithm */
1791 int key_len
; /* Length of the key */
1792 int iv_len
; /* Length of the IV */
1794 #if IMAGE_ENABLE_ENCRYPT
1795 const EVP_CIPHER
* (*calculate_type
)(void);
1798 int (*encrypt
)(struct image_cipher_info
*info
,
1799 const unsigned char *data
, int data_len
,
1800 unsigned char **cipher
, int *cipher_len
);
1802 int (*add_cipher_data
)(struct image_cipher_info
*info
,
1803 void *keydest
, void *fit
, int node_noffset
);
1805 int (*decrypt
)(struct image_cipher_info
*info
,
1806 const void *cipher
, size_t cipher_len
,
1807 void **data
, size_t *data_len
);
1810 int fit_image_cipher_get_algo(const void *fit
, int noffset
, char **algo
);
1812 struct cipher_algo
*image_get_cipher_algo(const char *full_name
);
1813 struct andr_image_data
;
1816 * android_image_get_data() - Parse Android boot images
1818 * This is used to parse boot and vendor-boot header into
1819 * andr_image_data generic structure.
1821 * @boot_hdr: Pointer to boot image header
1822 * @vendor_boot_hdr: Pointer to vendor boot image header
1823 * @data: Pointer to generic boot format structure
1824 * Return: true if succeeded, false otherwise
1826 bool android_image_get_data(const void *boot_hdr
, const void *vendor_boot_hdr
,
1827 struct andr_image_data
*data
);
1829 struct andr_boot_img_hdr_v0
;
1832 * android_image_get_kernel() - Processes kernel part of Android boot images
1834 * This function returns the os image's start address and length. Also,
1835 * it appends the kernel command line to the bootargs env variable.
1837 * @hdr: Pointer to image header, which is at the start
1839 * @vendor_boot_img : Pointer to vendor boot image header
1840 * @verify: Checksum verification flag. Currently unimplemented.
1841 * @os_data: Pointer to a ulong variable, will hold os data start
1843 * @os_len: Pointer to a ulong variable, will hold os data length.
1844 * Return: Zero, os start address and length on success,
1845 * otherwise on failure.
1847 int android_image_get_kernel(const void *hdr
,
1848 const void *vendor_boot_img
, int verify
,
1849 ulong
*os_data
, ulong
*os_len
);
1852 * android_image_get_ramdisk() - Extracts the ramdisk load address and its size
1854 * This extracts the load address of the ramdisk and its size
1856 * @hdr: Pointer to image header
1857 * @vendor_boot_img : Pointer to vendor boot image header
1858 * @rd_data: Pointer to a ulong variable, will hold ramdisk address
1859 * @rd_len: Pointer to a ulong variable, will hold ramdisk length
1860 * Return: 0 if succeeded, -1 if ramdisk size is 0
1862 int android_image_get_ramdisk(const void *hdr
, const void *vendor_boot_img
,
1863 ulong
*rd_data
, ulong
*rd_len
);
1866 * android_image_get_second() - Extracts the secondary bootloader address
1869 * This extracts the address of the secondary bootloader and its size
1871 * @hdr: Pointer to image header
1872 * @second_data: Pointer to a ulong variable, will hold secondary bootloader address
1873 * @second_len : Pointer to a ulong variable, will hold secondary bootloader length
1874 * Return: 0 if succeeded, -1 if secondary bootloader size is 0
1876 int android_image_get_second(const void *hdr
, ulong
*second_data
, ulong
*second_len
);
1877 bool android_image_get_dtbo(ulong hdr_addr
, ulong
*addr
, u32
*size
);
1880 * android_image_get_dtb_by_index() - Get address and size of blob in DTB area.
1881 * @hdr_addr: Boot image header address
1882 * @vendor_boot_img: Pointer to vendor boot image header, which is at the start of the image.
1883 * @index: Index of desired DTB in DTB area (starting from 0)
1884 * @addr: If not NULL, will contain address to specified DTB
1885 * @size: If not NULL, will contain size of specified DTB
1887 * Get the address and size of DTB blob by its index in DTB area of Android
1888 * Boot Image in RAM.
1890 * Return: true on success or false on error.
1892 bool android_image_get_dtb_by_index(ulong hdr_addr
, ulong vendor_boot_img
,
1893 u32 index
, ulong
*addr
, u32
*size
);
1896 * android_image_get_end() - Get the end of Android boot image
1898 * This returns the end address of Android boot image address
1900 * @hdr: Pointer to image header
1901 * @vendor_boot_img : Pointer to vendor boot image header
1902 * Return: The end address of Android boot image
1904 ulong
android_image_get_end(const struct andr_boot_img_hdr_v0
*hdr
,
1905 const void *vendor_boot_img
);
1908 * android_image_get_kload() - Get the kernel load address
1910 * This returns the kernel load address. The load address is extracted
1911 * from the boot image header or the "kernel_addr_r" environment variable
1913 * @hdr: Pointer to image header
1914 * @vendor_boot_img : Pointer to vendor boot image header
1915 * Return: The kernel load address
1917 ulong
android_image_get_kload(const void *hdr
,
1918 const void *vendor_boot_img
);
1921 * android_image_get_kcomp() - Get kernel compression type
1923 * This gets the kernel compression type from the boot image header
1925 * @hdr: Pointer to image header
1926 * @vendor_boot_img : Pointer to vendor boot image header
1927 * Return: Kernel compression type
1929 ulong
android_image_get_kcomp(const void *hdr
,
1930 const void *vendor_boot_img
);
1933 * android_print_contents() - Prints out the contents of the Android format image
1935 * This formats a multi line Android image contents description.
1936 * The routine prints out Android image properties
1938 * @hdr: Pointer to the Android format image header
1939 * Return: no returned results
1941 void android_print_contents(const struct andr_boot_img_hdr_v0
*hdr
);
1942 bool android_image_print_dtb_contents(ulong hdr_addr
);
1945 * is_android_boot_image_header() - Check the magic of boot image
1947 * This checks the header of Android boot image and verifies the
1948 * magic is "ANDROID!"
1950 * @hdr: Pointer to boot image
1951 * Return: non-zero if the magic is correct, zero otherwise
1953 bool is_android_boot_image_header(const void *hdr
);
1956 * is_android_vendor_boot_image_header() - Check the magic of vendor boot image
1958 * This checks the header of Android vendor boot image and verifies the magic
1961 * @vendor_boot_img: Pointer to boot image
1962 * Return: non-zero if the magic is correct, zero otherwise
1964 bool is_android_vendor_boot_image_header(const void *vendor_boot_img
);
1967 * get_abootimg_addr() - Get Android boot image address
1969 * Return: Android boot image address
1971 ulong
get_abootimg_addr(void);
1974 * get_avendor_bootimg_addr() - Get Android vendor boot image address
1976 * Return: Android vendor boot image address
1978 ulong
get_avendor_bootimg_addr(void);
1981 * board_fit_config_name_match() - Check for a matching board name
1983 * This is used when SPL loads a FIT containing multiple device tree files
1984 * and wants to work out which one to use. The description of each one is
1985 * passed to this function. The description comes from the 'description' field
1986 * in each (FDT) image node.
1988 * @name: Device tree description
1989 * Return: 0 if this device tree should be used, non-zero to try the next
1991 int board_fit_config_name_match(const char *name
);
1994 * board_fit_image_post_process() - Do any post-process on FIT binary data
1996 * This is used to do any sort of image manipulation, verification, decryption
1997 * etc. in a platform or board specific way. Obviously, anything done here would
1998 * need to be comprehended in how the images were prepared before being injected
1999 * into the FIT creation (i.e. the binary blobs would have been pre-processed
2000 * before being added to the FIT image).
2002 * @fit: pointer to fit image
2003 * @node: offset of image node
2004 * @image: pointer to the image start pointer
2005 * @size: pointer to the image size
2006 * Return: no return value (failure should be handled internally)
2008 void board_fit_image_post_process(const void *fit
, int node
, void **p_image
,
2011 #define FDT_ERROR ((ulong)(-1))
2013 ulong
fdt_getprop_u32(const void *fdt
, int node
, const char *prop
);
2016 * fit_find_config_node() - Find the node for the best DTB in a FIT image
2018 * A FIT image contains one or more DTBs. This function parses the
2019 * configurations described in the FIT images and returns the node of
2020 * the first matching DTB. To check if a DTB matches a board, this function
2021 * calls board_fit_config_name_match(). If no matching DTB is found, it returns
2022 * the node described by the default configuration if it exists.
2024 * @fdt: pointer to flat device tree
2025 * Return: the node if found, -ve otherwise
2027 int fit_find_config_node(const void *fdt
);
2030 * Mapping of image types to function handlers to be invoked on the associated
2033 * @type: Type of image, I.E. IH_TYPE_*
2034 * @handler: Function to call on loaded image
2036 struct fit_loadable_tbl
{
2039 * handler() - Process a loaded image
2041 * @data: Pointer to start of loaded image data
2042 * @size: Size of loaded image data
2044 void (*handler
)(ulong data
, size_t size
);
2048 * Define a FIT loadable image type handler
2050 * _type is a valid uimage_type ID as defined in the "Image Type" enum above
2051 * _handler is the handler function to call after this image type is loaded
2053 #define U_BOOT_FIT_LOADABLE_HANDLER(_type, _handler) \
2054 ll_entry_declare(struct fit_loadable_tbl, _function, fit_loadable) = { \
2056 .handler = _handler, \
2060 * fit_update - update storage with FIT image
2061 * @fit: Pointer to FIT image
2063 * Update firmware on storage using FIT image as input.
2064 * The storage area to be update will be identified by the name
2065 * in FIT and matching it to "dfu_alt_info" variable.
2067 * Return: 0 on success, non-zero otherwise
2069 int fit_update(const void *fit
);
2071 #endif /* __IMAGE_H__ */