• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /* SPDX-License-Identifier: GPL-2.0+ */
2 /*
3  * (C) Copyright 2008 Semihalf
4  *
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
11  * work".
12  ********************************************************************
13  */
14 
15 #ifndef __IMAGE_H__
16 #define __IMAGE_H__
17 
18 #include "compiler.h"
19 #include <asm/byteorder.h>
20 #include <stdbool.h>
21 
22 /* Define this to avoid #ifdefs later on */
23 struct lmb;
24 struct fdt_region;
25 
26 #ifdef USE_HOSTCC
27 #include <sys/types.h>
28 
29 /* new uImage format support enabled on host */
30 #define IMAGE_ENABLE_FIT	1
31 #define IMAGE_ENABLE_OF_LIBFDT	1
32 #define CONFIG_FIT_VERBOSE	1 /* enable fit_format_{error,warning}() */
33 #define CONFIG_FIT_ENABLE_SHA256_SUPPORT
34 #define CONFIG_SHA1
35 #define CONFIG_SHA256
36 
37 #define IMAGE_ENABLE_IGNORE	0
38 #define IMAGE_INDENT_STRING	""
39 
40 #else
41 
42 #include <lmb.h>
43 #include <asm/u-boot.h>
44 #include <command.h>
45 
46 /* Take notice of the 'ignore' property for hashes */
47 #define IMAGE_ENABLE_IGNORE	1
48 #define IMAGE_INDENT_STRING	"   "
49 
50 #define IMAGE_ENABLE_FIT	CONFIG_IS_ENABLED(FIT)
51 #define IMAGE_ENABLE_OF_LIBFDT	CONFIG_IS_ENABLED(OF_LIBFDT)
52 
53 #endif /* USE_HOSTCC */
54 
55 #if IMAGE_ENABLE_FIT
56 #include <hash.h>
57 #include <linux/libfdt.h>
58 #include <fdt_support.h>
59 # ifdef CONFIG_SPL_BUILD
60 #  ifdef CONFIG_SPL_CRC32_SUPPORT
61 #   define IMAGE_ENABLE_CRC32	1
62 #  endif
63 #  ifdef CONFIG_SPL_MD5_SUPPORT
64 #   define IMAGE_ENABLE_MD5	1
65 #  endif
66 #  ifdef CONFIG_SPL_SHA1_SUPPORT
67 #   define IMAGE_ENABLE_SHA1	1
68 #  endif
69 # else
70 #  define CONFIG_CRC32		/* FIT images need CRC32 support */
71 #  define IMAGE_ENABLE_CRC32	1
72 #  define IMAGE_ENABLE_MD5	1
73 #  define IMAGE_ENABLE_SHA1	1
74 # endif
75 
76 #ifndef IMAGE_ENABLE_CRC32
77 #define IMAGE_ENABLE_CRC32	0
78 #endif
79 
80 #ifndef IMAGE_ENABLE_MD5
81 #define IMAGE_ENABLE_MD5	0
82 #endif
83 
84 #ifndef IMAGE_ENABLE_SHA1
85 #define IMAGE_ENABLE_SHA1	0
86 #endif
87 
88 #if defined(CONFIG_FIT_ENABLE_SHA256_SUPPORT) || \
89 	defined(CONFIG_SPL_SHA256_SUPPORT)
90 #define IMAGE_ENABLE_SHA256	1
91 #else
92 #define IMAGE_ENABLE_SHA256	0
93 #endif
94 
95 #endif /* IMAGE_ENABLE_FIT */
96 
97 #ifdef CONFIG_SYS_BOOT_GET_CMDLINE
98 # define IMAGE_BOOT_GET_CMDLINE		1
99 #else
100 # define IMAGE_BOOT_GET_CMDLINE		0
101 #endif
102 
103 #ifdef CONFIG_OF_BOARD_SETUP
104 # define IMAGE_OF_BOARD_SETUP		1
105 #else
106 # define IMAGE_OF_BOARD_SETUP		0
107 #endif
108 
109 #ifdef CONFIG_OF_SYSTEM_SETUP
110 # define IMAGE_OF_SYSTEM_SETUP	1
111 #else
112 # define IMAGE_OF_SYSTEM_SETUP	0
113 #endif
114 
115 enum ih_category {
116 	IH_ARCH,
117 	IH_COMP,
118 	IH_OS,
119 	IH_TYPE,
120 
121 	IH_COUNT,
122 };
123 
124 /*
125  * Operating System Codes
126  *
127  * The following are exposed to uImage header.
128  * Do not change values for backward compatibility.
129  */
130 enum {
131 	IH_OS_INVALID		= 0,	/* Invalid OS	*/
132 	IH_OS_OPENBSD,			/* OpenBSD	*/
133 	IH_OS_NETBSD,			/* NetBSD	*/
134 	IH_OS_FREEBSD,			/* FreeBSD	*/
135 	IH_OS_4_4BSD,			/* 4.4BSD	*/
136 	IH_OS_LINUX,			/* Linux	*/
137 	IH_OS_SVR4,			/* SVR4		*/
138 	IH_OS_ESIX,			/* Esix		*/
139 	IH_OS_SOLARIS,			/* Solaris	*/
140 	IH_OS_IRIX,			/* Irix		*/
141 	IH_OS_SCO,			/* SCO		*/
142 	IH_OS_DELL,			/* Dell		*/
143 	IH_OS_NCR,			/* NCR		*/
144 	IH_OS_LYNXOS,			/* LynxOS	*/
145 	IH_OS_VXWORKS,			/* VxWorks	*/
146 	IH_OS_PSOS,			/* pSOS		*/
147 	IH_OS_QNX,			/* QNX		*/
148 	IH_OS_U_BOOT,			/* Firmware	*/
149 	IH_OS_RTEMS,			/* RTEMS	*/
150 	IH_OS_ARTOS,			/* ARTOS	*/
151 	IH_OS_UNITY,			/* Unity OS	*/
152 	IH_OS_INTEGRITY,		/* INTEGRITY	*/
153 	IH_OS_OSE,			/* OSE		*/
154 	IH_OS_PLAN9,			/* Plan 9	*/
155 	IH_OS_OPENRTOS,		/* OpenRTOS	*/
156 	IH_OS_ARM_TRUSTED_FIRMWARE,     /* ARM Trusted Firmware */
157 	IH_OS_TEE,			/* Trusted Execution Environment */
158 
159 	IH_OS_COUNT,
160 };
161 
162 /*
163  * CPU Architecture Codes (supported by Linux)
164  *
165  * The following are exposed to uImage header.
166  * Do not change values for backward compatibility.
167  */
168 enum {
169 	IH_ARCH_INVALID		= 0,	/* Invalid CPU	*/
170 	IH_ARCH_ALPHA,			/* Alpha	*/
171 	IH_ARCH_ARM,			/* ARM		*/
172 	IH_ARCH_I386,			/* Intel x86	*/
173 	IH_ARCH_IA64,			/* IA64		*/
174 	IH_ARCH_MIPS,			/* MIPS		*/
175 	IH_ARCH_MIPS64,			/* MIPS	 64 Bit */
176 	IH_ARCH_PPC,			/* PowerPC	*/
177 	IH_ARCH_S390,			/* IBM S390	*/
178 	IH_ARCH_SH,			/* SuperH	*/
179 	IH_ARCH_SPARC,			/* Sparc	*/
180 	IH_ARCH_SPARC64,		/* Sparc 64 Bit */
181 	IH_ARCH_M68K,			/* M68K		*/
182 	IH_ARCH_NIOS,			/* Nios-32	*/
183 	IH_ARCH_MICROBLAZE,		/* MicroBlaze   */
184 	IH_ARCH_NIOS2,			/* Nios-II	*/
185 	IH_ARCH_BLACKFIN,		/* Blackfin	*/
186 	IH_ARCH_AVR32,			/* AVR32	*/
187 	IH_ARCH_ST200,			/* STMicroelectronics ST200  */
188 	IH_ARCH_SANDBOX,		/* Sandbox architecture (test only) */
189 	IH_ARCH_NDS32,			/* ANDES Technology - NDS32  */
190 	IH_ARCH_OPENRISC,		/* OpenRISC 1000  */
191 	IH_ARCH_ARM64,			/* ARM64	*/
192 	IH_ARCH_ARC,			/* Synopsys DesignWare ARC */
193 	IH_ARCH_X86_64,			/* AMD x86_64, Intel and Via */
194 	IH_ARCH_XTENSA,			/* Xtensa	*/
195 	IH_ARCH_RISCV,			/* RISC-V */
196 
197 	IH_ARCH_COUNT,
198 };
199 
200 /*
201  * Image Types
202  *
203  * "Standalone Programs" are directly runnable in the environment
204  *	provided by U-Boot; it is expected that (if they behave
205  *	well) you can continue to work in U-Boot after return from
206  *	the Standalone Program.
207  * "OS Kernel Images" are usually images of some Embedded OS which
208  *	will take over control completely. Usually these programs
209  *	will install their own set of exception handlers, device
210  *	drivers, set up the MMU, etc. - this means, that you cannot
211  *	expect to re-enter U-Boot except by resetting the CPU.
212  * "RAMDisk Images" are more or less just data blocks, and their
213  *	parameters (address, size) are passed to an OS kernel that is
214  *	being started.
215  * "Multi-File Images" contain several images, typically an OS
216  *	(Linux) kernel image and one or more data images like
217  *	RAMDisks. This construct is useful for instance when you want
218  *	to boot over the network using BOOTP etc., where the boot
219  *	server provides just a single image file, but you want to get
220  *	for instance an OS kernel and a RAMDisk image.
221  *
222  *	"Multi-File Images" start with a list of image sizes, each
223  *	image size (in bytes) specified by an "uint32_t" in network
224  *	byte order. This list is terminated by an "(uint32_t)0".
225  *	Immediately after the terminating 0 follow the images, one by
226  *	one, all aligned on "uint32_t" boundaries (size rounded up to
227  *	a multiple of 4 bytes - except for the last file).
228  *
229  * "Firmware Images" are binary images containing firmware (like
230  *	U-Boot or FPGA images) which usually will be programmed to
231  *	flash memory.
232  *
233  * "Script files" are command sequences that will be executed by
234  *	U-Boot's command interpreter; this feature is especially
235  *	useful when you configure U-Boot to use a real shell (hush)
236  *	as command interpreter (=> Shell Scripts).
237  *
238  * The following are exposed to uImage header.
239  * Do not change values for backward compatibility.
240  */
241 
242 enum {
243 	IH_TYPE_INVALID		= 0,	/* Invalid Image		*/
244 	IH_TYPE_STANDALONE,		/* Standalone Program		*/
245 	IH_TYPE_KERNEL,			/* OS Kernel Image		*/
246 	IH_TYPE_RAMDISK,		/* RAMDisk Image		*/
247 	IH_TYPE_MULTI,			/* Multi-File Image		*/
248 	IH_TYPE_FIRMWARE,		/* Firmware Image		*/
249 	IH_TYPE_SCRIPT,			/* Script file			*/
250 	IH_TYPE_FILESYSTEM,		/* Filesystem Image (any type)	*/
251 	IH_TYPE_FLATDT,			/* Binary Flat Device Tree Blob	*/
252 	IH_TYPE_KWBIMAGE,		/* Kirkwood Boot Image		*/
253 	IH_TYPE_IMXIMAGE,		/* Freescale IMXBoot Image	*/
254 	IH_TYPE_UBLIMAGE,		/* Davinci UBL Image		*/
255 	IH_TYPE_OMAPIMAGE,		/* TI OMAP Config Header Image	*/
256 	IH_TYPE_AISIMAGE,		/* TI Davinci AIS Image		*/
257 	/* OS Kernel Image, can run from any load address */
258 	IH_TYPE_KERNEL_NOLOAD,
259 	IH_TYPE_PBLIMAGE,		/* Freescale PBL Boot Image	*/
260 	IH_TYPE_MXSIMAGE,		/* Freescale MXSBoot Image	*/
261 	IH_TYPE_GPIMAGE,		/* TI Keystone GPHeader Image	*/
262 	IH_TYPE_ATMELIMAGE,		/* ATMEL ROM bootable Image	*/
263 	IH_TYPE_SOCFPGAIMAGE,		/* Altera SOCFPGA CV/AV Preloader */
264 	IH_TYPE_X86_SETUP,		/* x86 setup.bin Image		*/
265 	IH_TYPE_LPC32XXIMAGE,		/* x86 setup.bin Image		*/
266 	IH_TYPE_LOADABLE,		/* A list of typeless images	*/
267 	IH_TYPE_RKIMAGE,		/* Rockchip Boot Image		*/
268 	IH_TYPE_RKSD,			/* Rockchip SD card		*/
269 	IH_TYPE_RKSPI,			/* Rockchip SPI image		*/
270 	IH_TYPE_ZYNQIMAGE,		/* Xilinx Zynq Boot Image */
271 	IH_TYPE_ZYNQMPIMAGE,		/* Xilinx ZynqMP Boot Image */
272 	IH_TYPE_ZYNQMPBIF,		/* Xilinx ZynqMP Boot Image (bif) */
273 	IH_TYPE_FPGA,			/* FPGA Image */
274 	IH_TYPE_VYBRIDIMAGE,	/* VYBRID .vyb Image */
275 	IH_TYPE_TEE,            /* Trusted Execution Environment OS Image */
276 	IH_TYPE_FIRMWARE_IVT,		/* Firmware Image with HABv4 IVT */
277 	IH_TYPE_PMMC,            /* TI Power Management Micro-Controller Firmware */
278 	IH_TYPE_STM32IMAGE,		/* STMicroelectronics STM32 Image */
279 	IH_TYPE_SOCFPGAIMAGE_V1,	/* Altera SOCFPGA A10 Preloader	*/
280 
281 	IH_TYPE_COUNT,			/* Number of image types */
282 };
283 
284 /*
285  * Compression Types
286  *
287  * The following are exposed to uImage header.
288  * Do not change values for backward compatibility.
289  */
290 enum {
291 	IH_COMP_NONE		= 0,	/*  No	 Compression Used	*/
292 	IH_COMP_GZIP,			/* gzip	 Compression Used	*/
293 	IH_COMP_BZIP2,			/* bzip2 Compression Used	*/
294 	IH_COMP_LZMA,			/* lzma  Compression Used	*/
295 	IH_COMP_LZO,			/* lzo   Compression Used	*/
296 	IH_COMP_LZ4,			/* lz4   Compression Used	*/
297 
298 	IH_COMP_COUNT,
299 };
300 
301 #define IH_MAGIC	0x27051956	/* Image Magic Number		*/
302 #define IH_NMLEN		32	/* Image Name Length		*/
303 
304 /* Reused from common.h */
305 #define ROUND(a, b)		(((a) + (b) - 1) & ~((b) - 1))
306 
307 /*
308  * Legacy format image header,
309  * all data in network byte order (aka natural aka bigendian).
310  */
311 typedef struct image_header {
312 	__be32		ih_magic;	/* Image Header Magic Number	*/
313 	__be32		ih_hcrc;	/* Image Header CRC Checksum	*/
314 	__be32		ih_time;	/* Image Creation Timestamp	*/
315 	__be32		ih_size;	/* Image Data Size		*/
316 	__be32		ih_load;	/* Data	 Load  Address		*/
317 	__be32		ih_ep;		/* Entry Point Address		*/
318 	__be32		ih_dcrc;	/* Image Data CRC Checksum	*/
319 	uint8_t		ih_os;		/* Operating System		*/
320 	uint8_t		ih_arch;	/* CPU architecture		*/
321 	uint8_t		ih_type;	/* Image Type			*/
322 	uint8_t		ih_comp;	/* Compression Type		*/
323 	uint8_t		ih_name[IH_NMLEN];	/* Image Name		*/
324 } image_header_t;
325 
326 typedef struct image_info {
327 	ulong		start, end;		/* start/end of blob */
328 	ulong		image_start, image_len; /* start of image within blob, len of image */
329 	ulong		load;			/* load addr for the image */
330 	uint8_t		comp, type, os;		/* compression, type of image, os type */
331 	uint8_t		arch;			/* CPU architecture */
332 } image_info_t;
333 
334 /*
335  * Legacy and FIT format headers used by do_bootm() and do_bootm_<os>()
336  * routines.
337  */
338 typedef struct bootm_headers {
339 	/*
340 	 * Legacy os image header, if it is a multi component image
341 	 * then boot_get_ramdisk() and get_fdt() will attempt to get
342 	 * data from second and third component accordingly.
343 	 */
344 	image_header_t	*legacy_hdr_os;		/* image header pointer */
345 	image_header_t	legacy_hdr_os_copy;	/* header copy */
346 	ulong		legacy_hdr_valid;
347 
348 #if IMAGE_ENABLE_FIT
349 	const char	*fit_uname_cfg;	/* configuration node unit name */
350 
351 	void		*fit_hdr_os;	/* os FIT image header */
352 	const char	*fit_uname_os;	/* os subimage node unit name */
353 	int		fit_noffset_os;	/* os subimage node offset */
354 
355 	void		*fit_hdr_rd;	/* init ramdisk FIT image header */
356 	const char	*fit_uname_rd;	/* init ramdisk subimage node unit name */
357 	int		fit_noffset_rd;	/* init ramdisk subimage node offset */
358 
359 	void		*fit_hdr_fdt;	/* FDT blob FIT image header */
360 	const char	*fit_uname_fdt;	/* FDT blob subimage node unit name */
361 	int		fit_noffset_fdt;/* FDT blob subimage node offset */
362 
363 	void		*fit_hdr_setup;	/* x86 setup FIT image header */
364 	const char	*fit_uname_setup; /* x86 setup subimage node name */
365 	int		fit_noffset_setup;/* x86 setup subimage node offset */
366 #endif
367 
368 #ifndef USE_HOSTCC
369 	image_info_t	os;		/* os image info */
370 	ulong		ep;		/* entry point of OS */
371 
372 	ulong		rd_start, rd_end;/* ramdisk start/end */
373 
374 	char		*ft_addr;	/* flat dev tree address */
375 	ulong		ft_len;		/* length of flat device tree */
376 
377 	ulong		initrd_start;
378 	ulong		initrd_end;
379 	ulong		cmdline_start;
380 	ulong		cmdline_end;
381 	bd_t		*kbd;
382 #endif
383 
384 	int		verify;		/* env_get("verify")[0] != 'n' */
385 
386 #define	BOOTM_STATE_START	(0x00000001)
387 #define	BOOTM_STATE_FINDOS	(0x00000002)
388 #define	BOOTM_STATE_FINDOTHER	(0x00000004)
389 #define	BOOTM_STATE_LOADOS	(0x00000008)
390 #define	BOOTM_STATE_RAMDISK	(0x00000010)
391 #define	BOOTM_STATE_FDT		(0x00000020)
392 #define	BOOTM_STATE_OS_CMDLINE	(0x00000040)
393 #define	BOOTM_STATE_OS_BD_T	(0x00000080)
394 #define	BOOTM_STATE_OS_PREP	(0x00000100)
395 #define	BOOTM_STATE_OS_FAKE_GO	(0x00000200)	/* 'Almost' run the OS */
396 #define	BOOTM_STATE_OS_GO	(0x00000400)
397 	int		state;
398 
399 #ifdef CONFIG_LMB
400 	struct lmb	lmb;		/* for memory mgmt */
401 #endif
402 } bootm_headers_t;
403 
404 extern bootm_headers_t images;
405 
406 /*
407  * Some systems (for example LWMON) have very short watchdog periods;
408  * we must make sure to split long operations like memmove() or
409  * checksum calculations into reasonable chunks.
410  */
411 #ifndef CHUNKSZ
412 #define CHUNKSZ (64 * 1024)
413 #endif
414 
415 #ifndef CHUNKSZ_CRC32
416 #define CHUNKSZ_CRC32 (64 * 1024)
417 #endif
418 
419 #ifndef CHUNKSZ_MD5
420 #define CHUNKSZ_MD5 (64 * 1024)
421 #endif
422 
423 #ifndef CHUNKSZ_SHA1
424 #define CHUNKSZ_SHA1 (64 * 1024)
425 #endif
426 
427 #define uimage_to_cpu(x)		be32_to_cpu(x)
428 #define cpu_to_uimage(x)		cpu_to_be32(x)
429 
430 /*
431  * Translation table for entries of a specific type; used by
432  * get_table_entry_id() and get_table_entry_name().
433  */
434 typedef struct table_entry {
435 	int	id;
436 	char	*sname;		/* short (input) name to find table entry */
437 	char	*lname;		/* long (output) name to print for messages */
438 } table_entry_t;
439 
440 /*
441  * get_table_entry_id() scans the translation table trying to find an
442  * entry that matches the given short name. If a matching entry is
443  * found, it's id is returned to the caller.
444  */
445 int get_table_entry_id(const table_entry_t *table,
446 		const char *table_name, const char *name);
447 /*
448  * get_table_entry_name() scans the translation table trying to find
449  * an entry that matches the given id. If a matching entry is found,
450  * its long name is returned to the caller.
451  */
452 char *get_table_entry_name(const table_entry_t *table, char *msg, int id);
453 
454 const char *genimg_get_os_name(uint8_t os);
455 
456 /**
457  * genimg_get_os_short_name() - get the short name for an OS
458  *
459  * @param os	OS (IH_OS_...)
460  * @return OS short name, or "unknown" if unknown
461  */
462 const char *genimg_get_os_short_name(uint8_t comp);
463 
464 const char *genimg_get_arch_name(uint8_t arch);
465 
466 /**
467  * genimg_get_arch_short_name() - get the short name for an architecture
468  *
469  * @param arch	Architecture type (IH_ARCH_...)
470  * @return architecture short name, or "unknown" if unknown
471  */
472 const char *genimg_get_arch_short_name(uint8_t arch);
473 
474 const char *genimg_get_type_name(uint8_t type);
475 
476 /**
477  * genimg_get_type_short_name() - get the short name for an image type
478  *
479  * @param type	Image type (IH_TYPE_...)
480  * @return image short name, or "unknown" if unknown
481  */
482 const char *genimg_get_type_short_name(uint8_t type);
483 
484 const char *genimg_get_comp_name(uint8_t comp);
485 
486 /**
487  * genimg_get_comp_short_name() - get the short name for a compression method
488  *
489  * @param comp	compression method (IH_COMP_...)
490  * @return compression method short name, or "unknown" if unknown
491  */
492 const char *genimg_get_comp_short_name(uint8_t comp);
493 
494 /**
495  * genimg_get_cat_name() - Get the name of an item in a category
496  *
497  * @category:	Category of item
498  * @id:		Item ID
499  * @return name of item, or "Unknown ..." if unknown
500  */
501 const char *genimg_get_cat_name(enum ih_category category, uint id);
502 
503 /**
504  * genimg_get_cat_short_name() - Get the short name of an item in a category
505  *
506  * @category:	Category of item
507  * @id:		Item ID
508  * @return short name of item, or "Unknown ..." if unknown
509  */
510 const char *genimg_get_cat_short_name(enum ih_category category, uint id);
511 
512 /**
513  * genimg_get_cat_count() - Get the number of items in a category
514  *
515  * @category:	Category to check
516  * @return the number of items in the category (IH_xxx_COUNT)
517  */
518 int genimg_get_cat_count(enum ih_category category);
519 
520 /**
521  * genimg_get_cat_desc() - Get the description of a category
522  *
523  * @return the description of a category, e.g. "architecture". This
524  * effectively converts the enum to a string.
525  */
526 const char *genimg_get_cat_desc(enum ih_category category);
527 
528 int genimg_get_os_id(const char *name);
529 int genimg_get_arch_id(const char *name);
530 int genimg_get_type_id(const char *name);
531 int genimg_get_comp_id(const char *name);
532 void genimg_print_size(uint32_t size);
533 
534 #if defined(CONFIG_TIMESTAMP) || defined(CONFIG_CMD_DATE) || \
535 	defined(USE_HOSTCC)
536 #define IMAGE_ENABLE_TIMESTAMP 1
537 #else
538 #define IMAGE_ENABLE_TIMESTAMP 0
539 #endif
540 void genimg_print_time(time_t timestamp);
541 
542 /* What to do with a image load address ('load = <> 'in the FIT) */
543 enum fit_load_op {
544 	FIT_LOAD_IGNORED,	/* Ignore load address */
545 	FIT_LOAD_OPTIONAL,	/* Can be provided, but optional */
546 	FIT_LOAD_OPTIONAL_NON_ZERO,	/* Optional, a value of 0 is ignored */
547 	FIT_LOAD_REQUIRED,	/* Must be provided */
548 };
549 
550 int boot_get_setup(bootm_headers_t *images, uint8_t arch, ulong *setup_start,
551 		   ulong *setup_len);
552 
553 #ifndef USE_HOSTCC
554 /* Image format types, returned by _get_format() routine */
555 #define IMAGE_FORMAT_INVALID	0x00
556 #if defined(CONFIG_IMAGE_FORMAT_LEGACY)
557 #define IMAGE_FORMAT_LEGACY	0x01	/* legacy image_header based format */
558 #endif
559 #define IMAGE_FORMAT_FIT	0x02	/* new, libfdt based format */
560 #define IMAGE_FORMAT_ANDROID	0x03	/* Android boot image */
561 
562 ulong genimg_get_kernel_addr_fit(char * const img_addr,
563 			         const char **fit_uname_config,
564 			         const char **fit_uname_kernel);
565 ulong genimg_get_kernel_addr(char * const img_addr);
566 int genimg_get_format(const void *img_addr);
567 int genimg_has_config(bootm_headers_t *images);
568 
569 int boot_get_fpga(int argc, char * const argv[], bootm_headers_t *images,
570 		uint8_t arch, const ulong *ld_start, ulong * const ld_len);
571 int boot_get_ramdisk(int argc, char * const argv[], bootm_headers_t *images,
572 		uint8_t arch, ulong *rd_start, ulong *rd_end);
573 
574 /**
575  * boot_get_loadable - routine to load a list of binaries to memory
576  * @argc: Ignored Argument
577  * @argv: Ignored Argument
578  * @images: pointer to the bootm images structure
579  * @arch: expected architecture for the image
580  * @ld_start: Ignored Argument
581  * @ld_len: Ignored Argument
582  *
583  * boot_get_loadable() will take the given FIT configuration, and look
584  * for a field named "loadables".  Loadables, is a list of elements in
585  * the FIT given as strings.  exe:
586  *   loadables = "linux_kernel", "fdt-2";
587  * this function will attempt to parse each string, and load the
588  * corresponding element from the FIT into memory.  Once placed,
589  * no aditional actions are taken.
590  *
591  * @return:
592  *     0, if only valid images or no images are found
593  *     error code, if an error occurs during fit_image_load
594  */
595 int boot_get_loadable(int argc, char * const argv[], bootm_headers_t *images,
596 		uint8_t arch, const ulong *ld_start, ulong * const ld_len);
597 #endif /* !USE_HOSTCC */
598 
599 int boot_get_setup_fit(bootm_headers_t *images, uint8_t arch,
600 		       ulong *setup_start, ulong *setup_len);
601 
602 /**
603  * boot_get_fdt_fit() - load a DTB from a FIT file (applying overlays)
604  *
605  * This deals with all aspects of loading an DTB from a FIT.
606  * The correct base image based on configuration will be selected, and
607  * then any overlays specified will be applied (as present in fit_uname_configp).
608  *
609  * @param images	Boot images structure
610  * @param addr		Address of FIT in memory
611  * @param fit_unamep	On entry this is the requested image name
612  *			(e.g. "kernel") or NULL to use the default. On exit
613  *			points to the selected image name
614  * @param fit_uname_configp	On entry this is the requested configuration
615  *			name (e.g. "conf-1") or NULL to use the default. On
616  *			exit points to the selected configuration name.
617  * @param arch		Expected architecture (IH_ARCH_...)
618  * @param datap		Returns address of loaded image
619  * @param lenp		Returns length of loaded image
620  *
621  * @return node offset of base image, or -ve error code on error
622  */
623 int boot_get_fdt_fit(bootm_headers_t *images, ulong addr,
624 		   const char **fit_unamep, const char **fit_uname_configp,
625 		   int arch, ulong *datap, ulong *lenp);
626 
627 /**
628  * fit_image_load() - load an image from a FIT
629  *
630  * This deals with all aspects of loading an image from a FIT, including
631  * selecting the right image based on configuration, verifying it, printing
632  * out progress messages, checking the type/arch/os and optionally copying it
633  * to the right load address.
634  *
635  * The property to look up is defined by image_type.
636  *
637  * @param images	Boot images structure
638  * @param addr		Address of FIT in memory
639  * @param fit_unamep	On entry this is the requested image name
640  *			(e.g. "kernel") or NULL to use the default. On exit
641  *			points to the selected image name
642  * @param fit_uname_configp	On entry this is the requested configuration
643  *			name (e.g. "conf-1") or NULL to use the default. On
644  *			exit points to the selected configuration name.
645  * @param arch		Expected architecture (IH_ARCH_...)
646  * @param image_type	Required image type (IH_TYPE_...). If this is
647  *			IH_TYPE_KERNEL then we allow IH_TYPE_KERNEL_NOLOAD
648  *			also.
649  * @param bootstage_id	ID of starting bootstage to use for progress updates.
650  *			This will be added to the BOOTSTAGE_SUB values when
651  *			calling bootstage_mark()
652  * @param load_op	Decribes what to do with the load address
653  * @param datap		Returns address of loaded image
654  * @param lenp		Returns length of loaded image
655  * @return node offset of image, or -ve error code on error
656  */
657 int fit_image_load(bootm_headers_t *images, ulong addr,
658 		   const char **fit_unamep, const char **fit_uname_configp,
659 		   int arch, int image_type, int bootstage_id,
660 		   enum fit_load_op load_op, ulong *datap, ulong *lenp);
661 
662 #ifndef USE_HOSTCC
663 /**
664  * fit_get_node_from_config() - Look up an image a FIT by type
665  *
666  * This looks in the selected conf- node (images->fit_uname_cfg) for a
667  * particular image type (e.g. "kernel") and then finds the image that is
668  * referred to.
669  *
670  * For example, for something like:
671  *
672  * images {
673  *	kernel {
674  *		...
675  *	};
676  * };
677  * configurations {
678  *	conf-1 {
679  *		kernel = "kernel";
680  *	};
681  * };
682  *
683  * the function will return the node offset of the kernel@1 node, assuming
684  * that conf-1 is the chosen configuration.
685  *
686  * @param images	Boot images structure
687  * @param prop_name	Property name to look up (FIT_..._PROP)
688  * @param addr		Address of FIT in memory
689  */
690 int fit_get_node_from_config(bootm_headers_t *images, const char *prop_name,
691 			ulong addr);
692 
693 int boot_get_fdt(int flag, int argc, char * const argv[], uint8_t arch,
694 		 bootm_headers_t *images,
695 		 char **of_flat_tree, ulong *of_size);
696 void boot_fdt_add_mem_rsv_regions(struct lmb *lmb, void *fdt_blob);
697 int boot_relocate_fdt(struct lmb *lmb, char **of_flat_tree, ulong *of_size);
698 
699 int boot_ramdisk_high(struct lmb *lmb, ulong rd_data, ulong rd_len,
700 		  ulong *initrd_start, ulong *initrd_end);
701 int boot_get_cmdline(struct lmb *lmb, ulong *cmd_start, ulong *cmd_end);
702 #ifdef CONFIG_SYS_BOOT_GET_KBD
703 int boot_get_kbd(struct lmb *lmb, bd_t **kbd);
704 #endif /* CONFIG_SYS_BOOT_GET_KBD */
705 #endif /* !USE_HOSTCC */
706 
707 /*******************************************************************/
708 /* Legacy format specific code (prefixed with image_) */
709 /*******************************************************************/
image_get_header_size(void)710 static inline uint32_t image_get_header_size(void)
711 {
712 	return (sizeof(image_header_t));
713 }
714 
715 #define image_get_hdr_l(f) \
716 	static inline uint32_t image_get_##f(const image_header_t *hdr) \
717 	{ \
718 		return uimage_to_cpu(hdr->ih_##f); \
719 	}
720 image_get_hdr_l(magic)		/* image_get_magic */
image_get_hdr_l(hcrc)721 image_get_hdr_l(hcrc)		/* image_get_hcrc */
722 image_get_hdr_l(time)		/* image_get_time */
723 image_get_hdr_l(size)		/* image_get_size */
724 image_get_hdr_l(load)		/* image_get_load */
725 image_get_hdr_l(ep)		/* image_get_ep */
726 image_get_hdr_l(dcrc)		/* image_get_dcrc */
727 
728 #define image_get_hdr_b(f) \
729 	static inline uint8_t image_get_##f(const image_header_t *hdr) \
730 	{ \
731 		return hdr->ih_##f; \
732 	}
733 image_get_hdr_b(os)		/* image_get_os */
734 image_get_hdr_b(arch)		/* image_get_arch */
735 image_get_hdr_b(type)		/* image_get_type */
736 image_get_hdr_b(comp)		/* image_get_comp */
737 
738 static inline char *image_get_name(const image_header_t *hdr)
739 {
740 	return (char *)hdr->ih_name;
741 }
742 
image_get_data_size(const image_header_t * hdr)743 static inline uint32_t image_get_data_size(const image_header_t *hdr)
744 {
745 	return image_get_size(hdr);
746 }
747 
748 /**
749  * image_get_data - get image payload start address
750  * @hdr: image header
751  *
752  * image_get_data() returns address of the image payload. For single
753  * component images it is image data start. For multi component
754  * images it points to the null terminated table of sub-images sizes.
755  *
756  * returns:
757  *     image payload data start address
758  */
image_get_data(const image_header_t * hdr)759 static inline ulong image_get_data(const image_header_t *hdr)
760 {
761 	return ((ulong)hdr + image_get_header_size());
762 }
763 
image_get_image_size(const image_header_t * hdr)764 static inline uint32_t image_get_image_size(const image_header_t *hdr)
765 {
766 	return (image_get_size(hdr) + image_get_header_size());
767 }
image_get_image_end(const image_header_t * hdr)768 static inline ulong image_get_image_end(const image_header_t *hdr)
769 {
770 	return ((ulong)hdr + image_get_image_size(hdr));
771 }
772 
773 #define image_set_hdr_l(f) \
774 	static inline void image_set_##f(image_header_t *hdr, uint32_t val) \
775 	{ \
776 		hdr->ih_##f = cpu_to_uimage(val); \
777 	}
778 image_set_hdr_l(magic)		/* image_set_magic */
image_set_hdr_l(hcrc)779 image_set_hdr_l(hcrc)		/* image_set_hcrc */
780 image_set_hdr_l(time)		/* image_set_time */
781 image_set_hdr_l(size)		/* image_set_size */
782 image_set_hdr_l(load)		/* image_set_load */
783 image_set_hdr_l(ep)		/* image_set_ep */
784 image_set_hdr_l(dcrc)		/* image_set_dcrc */
785 
786 #define image_set_hdr_b(f) \
787 	static inline void image_set_##f(image_header_t *hdr, uint8_t val) \
788 	{ \
789 		hdr->ih_##f = val; \
790 	}
791 image_set_hdr_b(os)		/* image_set_os */
792 image_set_hdr_b(arch)		/* image_set_arch */
793 image_set_hdr_b(type)		/* image_set_type */
794 image_set_hdr_b(comp)		/* image_set_comp */
795 
796 static inline void image_set_name(image_header_t *hdr, const char *name)
797 {
798 	strncpy(image_get_name(hdr), name, IH_NMLEN);
799 }
800 
801 int image_check_hcrc(const image_header_t *hdr);
802 int image_check_dcrc(const image_header_t *hdr);
803 #ifndef USE_HOSTCC
804 ulong env_get_bootm_low(void);
805 phys_size_t env_get_bootm_size(void);
806 phys_size_t env_get_bootm_mapsize(void);
807 #endif
808 void memmove_wd(void *to, void *from, size_t len, ulong chunksz);
809 
image_check_magic(const image_header_t * hdr)810 static inline int image_check_magic(const image_header_t *hdr)
811 {
812 	return (image_get_magic(hdr) == IH_MAGIC);
813 }
image_check_type(const image_header_t * hdr,uint8_t type)814 static inline int image_check_type(const image_header_t *hdr, uint8_t type)
815 {
816 	return (image_get_type(hdr) == type);
817 }
image_check_arch(const image_header_t * hdr,uint8_t arch)818 static inline int image_check_arch(const image_header_t *hdr, uint8_t arch)
819 {
820 	return (image_get_arch(hdr) == arch) ||
821 		(image_get_arch(hdr) == IH_ARCH_ARM && arch == IH_ARCH_ARM64);
822 }
image_check_os(const image_header_t * hdr,uint8_t os)823 static inline int image_check_os(const image_header_t *hdr, uint8_t os)
824 {
825 	return (image_get_os(hdr) == os);
826 }
827 
828 ulong image_multi_count(const image_header_t *hdr);
829 void image_multi_getimg(const image_header_t *hdr, ulong idx,
830 			ulong *data, ulong *len);
831 
832 void image_print_contents(const void *hdr);
833 
834 #ifndef USE_HOSTCC
image_check_target_arch(const image_header_t * hdr)835 static inline int image_check_target_arch(const image_header_t *hdr)
836 {
837 #ifndef IH_ARCH_DEFAULT
838 # error "please define IH_ARCH_DEFAULT in your arch asm/u-boot.h"
839 #endif
840 	return image_check_arch(hdr, IH_ARCH_DEFAULT);
841 }
842 #endif /* USE_HOSTCC */
843 
844 /**
845  * Set up properties in the FDT
846  *
847  * This sets up properties in the FDT that is to be passed to linux.
848  *
849  * @images:	Images information
850  * @blob:	FDT to update
851  * @of_size:	Size of the FDT
852  * @lmb:	Points to logical memory block structure
853  * @return 0 if ok, <0 on failure
854  */
855 int image_setup_libfdt(bootm_headers_t *images, void *blob,
856 		       int of_size, struct lmb *lmb);
857 
858 /**
859  * Set up the FDT to use for booting a kernel
860  *
861  * This performs ramdisk setup, sets up the FDT if required, and adds
862  * paramters to the FDT if libfdt is available.
863  *
864  * @param images	Images information
865  * @return 0 if ok, <0 on failure
866  */
867 int image_setup_linux(bootm_headers_t *images);
868 
869 /**
870  * bootz_setup() - Extract stat and size of a Linux xImage
871  *
872  * @image: Address of image
873  * @start: Returns start address of image
874  * @end : Returns end address of image
875  * @return 0 if OK, 1 if the image was not recognised
876  */
877 int bootz_setup(ulong image, ulong *start, ulong *end);
878 
879 /**
880  * Return the correct start address and size of a Linux aarch64 Image.
881  *
882  * @image: Address of image
883  * @start: Returns start address of image
884  * @size : Returns size image
885  * @force_reloc: Ignore image->ep field, always place image to RAM start
886  * @return 0 if OK, 1 if the image was not recognised
887  */
888 int booti_setup(ulong image, ulong *relocated_addr, ulong *size,
889 		bool force_reloc);
890 
891 /*******************************************************************/
892 /* New uImage format specific code (prefixed with fit_) */
893 /*******************************************************************/
894 
895 #define FIT_IMAGES_PATH		"/images"
896 #define FIT_CONFS_PATH		"/configurations"
897 
898 /* hash/signature node */
899 #define FIT_HASH_NODENAME	"hash"
900 #define FIT_ALGO_PROP		"algo"
901 #define FIT_VALUE_PROP		"value"
902 #define FIT_IGNORE_PROP		"uboot-ignore"
903 #define FIT_SIG_NODENAME	"signature"
904 
905 /* image node */
906 #define FIT_DATA_PROP		"data"
907 #define FIT_DATA_POSITION_PROP	"data-position"
908 #define FIT_DATA_OFFSET_PROP	"data-offset"
909 #define FIT_DATA_SIZE_PROP	"data-size"
910 #define FIT_TIMESTAMP_PROP	"timestamp"
911 #define FIT_DESC_PROP		"description"
912 #define FIT_ARCH_PROP		"arch"
913 #define FIT_TYPE_PROP		"type"
914 #define FIT_OS_PROP		"os"
915 #define FIT_COMP_PROP		"compression"
916 #define FIT_ENTRY_PROP		"entry"
917 #define FIT_LOAD_PROP		"load"
918 
919 /* configuration node */
920 #define FIT_KERNEL_PROP		"kernel"
921 #define FIT_RAMDISK_PROP	"ramdisk"
922 #define FIT_FDT_PROP		"fdt"
923 #define FIT_LOADABLE_PROP	"loadables"
924 #define FIT_DEFAULT_PROP	"default"
925 #define FIT_SETUP_PROP		"setup"
926 #define FIT_FPGA_PROP		"fpga"
927 #define FIT_FIRMWARE_PROP	"firmware"
928 #define FIT_STANDALONE_PROP	"standalone"
929 
930 #define FIT_MAX_HASH_LEN	HASH_MAX_DIGEST_SIZE
931 
932 #if IMAGE_ENABLE_FIT
933 /* cmdline argument format parsing */
934 int fit_parse_conf(const char *spec, ulong addr_curr,
935 		ulong *addr, const char **conf_name);
936 int fit_parse_subimage(const char *spec, ulong addr_curr,
937 		ulong *addr, const char **image_name);
938 
939 int fit_get_subimage_count(const void *fit, int images_noffset);
940 void fit_print_contents(const void *fit);
941 void fit_image_print(const void *fit, int noffset, const char *p);
942 
943 /**
944  * fit_get_end - get FIT image size
945  * @fit: pointer to the FIT format image header
946  *
947  * returns:
948  *     size of the FIT image (blob) in memory
949  */
fit_get_size(const void * fit)950 static inline ulong fit_get_size(const void *fit)
951 {
952 	return fdt_totalsize(fit);
953 }
954 
955 /**
956  * fit_get_end - get FIT image end
957  * @fit: pointer to the FIT format image header
958  *
959  * returns:
960  *     end address of the FIT image (blob) in memory
961  */
962 ulong fit_get_end(const void *fit);
963 
964 /**
965  * fit_get_name - get FIT node name
966  * @fit: pointer to the FIT format image header
967  *
968  * returns:
969  *     NULL, on error
970  *     pointer to node name, on success
971  */
fit_get_name(const void * fit_hdr,int noffset,int * len)972 static inline const char *fit_get_name(const void *fit_hdr,
973 		int noffset, int *len)
974 {
975 	return fdt_get_name(fit_hdr, noffset, len);
976 }
977 
978 int fit_get_desc(const void *fit, int noffset, char **desc);
979 int fit_get_timestamp(const void *fit, int noffset, time_t *timestamp);
980 
981 int fit_image_get_node(const void *fit, const char *image_uname);
982 int fit_image_get_os(const void *fit, int noffset, uint8_t *os);
983 int fit_image_get_arch(const void *fit, int noffset, uint8_t *arch);
984 int fit_image_get_type(const void *fit, int noffset, uint8_t *type);
985 int fit_image_get_comp(const void *fit, int noffset, uint8_t *comp);
986 int fit_image_get_load(const void *fit, int noffset, ulong *load);
987 int fit_image_get_entry(const void *fit, int noffset, ulong *entry);
988 int fit_image_get_data(const void *fit, int noffset,
989 				const void **data, size_t *size);
990 int fit_image_get_data_offset(const void *fit, int noffset, int *data_offset);
991 int fit_image_get_data_position(const void *fit, int noffset,
992 				int *data_position);
993 int fit_image_get_data_size(const void *fit, int noffset, int *data_size);
994 int fit_image_get_data_and_size(const void *fit, int noffset,
995 				const void **data, size_t *size);
996 
997 int fit_image_hash_get_algo(const void *fit, int noffset, char **algo);
998 int fit_image_hash_get_value(const void *fit, int noffset, uint8_t **value,
999 				int *value_len);
1000 
1001 int fit_set_timestamp(void *fit, int noffset, time_t timestamp);
1002 
1003 /**
1004  * fit_add_verification_data() - add verification data to FIT image nodes
1005  *
1006  * @keydir:	Directory containing keys
1007  * @kwydest:	FDT blob to write public key information to
1008  * @fit:	Pointer to the FIT format image header
1009  * @comment:	Comment to add to signature nodes
1010  * @require_keys: Mark all keys as 'required'
1011  * @engine_id:	Engine to use for signing
1012  *
1013  * Adds hash values for all component images in the FIT blob.
1014  * Hashes are calculated for all component images which have hash subnodes
1015  * with algorithm property set to one of the supported hash algorithms.
1016  *
1017  * Also add signatures if signature nodes are present.
1018  *
1019  * returns
1020  *     0, on success
1021  *     libfdt error code, on failure
1022  */
1023 int fit_add_verification_data(const char *keydir, void *keydest, void *fit,
1024 			      const char *comment, int require_keys,
1025 			      const char *engine_id);
1026 
1027 int fit_image_verify_with_data(const void *fit, int image_noffset,
1028 			       const void *data, size_t size);
1029 int fit_image_verify(const void *fit, int noffset);
1030 int fit_config_verify(const void *fit, int conf_noffset);
1031 int fit_all_image_verify(const void *fit);
1032 int fit_image_check_os(const void *fit, int noffset, uint8_t os);
1033 int fit_image_check_arch(const void *fit, int noffset, uint8_t arch);
1034 int fit_image_check_type(const void *fit, int noffset, uint8_t type);
1035 int fit_image_check_comp(const void *fit, int noffset, uint8_t comp);
1036 int fit_check_format(const void *fit);
1037 
1038 int fit_conf_find_compat(const void *fit, const void *fdt);
1039 int fit_conf_get_node(const void *fit, const char *conf_uname);
1040 
1041 /**
1042  * fit_conf_get_prop_node() - Get node refered to by a configuration
1043  * @fit:	FIT to check
1044  * @noffset:	Offset of conf@xxx node to check
1045  * @prop_name:	Property to read from the conf node
1046  *
1047  * The conf- nodes contain references to other nodes, using properties
1048  * like 'kernel = "kernel"'. Given such a property name (e.g. "kernel"),
1049  * return the offset of the node referred to (e.g. offset of node
1050  * "/images/kernel".
1051  */
1052 int fit_conf_get_prop_node(const void *fit, int noffset,
1053 		const char *prop_name);
1054 
1055 int fit_check_ramdisk(const void *fit, int os_noffset,
1056 		uint8_t arch, int verify);
1057 
1058 int calculate_hash(const void *data, int data_len, const char *algo,
1059 			uint8_t *value, int *value_len);
1060 
1061 /*
1062  * At present we only support signing on the host, and verification on the
1063  * device
1064  */
1065 #if defined(CONFIG_FIT_SIGNATURE)
1066 # ifdef USE_HOSTCC
1067 #  define IMAGE_ENABLE_SIGN	1
1068 #  define IMAGE_ENABLE_VERIFY	1
1069 # include  <openssl/evp.h>
1070 #else
1071 #  define IMAGE_ENABLE_SIGN	0
1072 #  define IMAGE_ENABLE_VERIFY	1
1073 # endif
1074 #else
1075 # define IMAGE_ENABLE_SIGN	0
1076 # define IMAGE_ENABLE_VERIFY	0
1077 #endif
1078 
1079 #ifdef USE_HOSTCC
1080 void *image_get_host_blob(void);
1081 void image_set_host_blob(void *host_blob);
1082 # define gd_fdt_blob()		image_get_host_blob()
1083 #else
1084 # define gd_fdt_blob()		(gd->fdt_blob)
1085 #endif
1086 
1087 #ifdef CONFIG_FIT_BEST_MATCH
1088 #define IMAGE_ENABLE_BEST_MATCH	1
1089 #else
1090 #define IMAGE_ENABLE_BEST_MATCH	0
1091 #endif
1092 
1093 /* Information passed to the signing routines */
1094 struct image_sign_info {
1095 	const char *keydir;		/* Directory conaining keys */
1096 	const char *keyname;		/* Name of key to use */
1097 	void *fit;			/* Pointer to FIT blob */
1098 	int node_offset;		/* Offset of signature node */
1099 	const char *name;		/* Algorithm name */
1100 	struct checksum_algo *checksum;	/* Checksum algorithm information */
1101 	struct crypto_algo *crypto;	/* Crypto algorithm information */
1102 	const void *fdt_blob;		/* FDT containing public keys */
1103 	int required_keynode;		/* Node offset of key to use: -1=any */
1104 	const char *require_keys;	/* Value for 'required' property */
1105 	const char *engine_id;		/* Engine to use for signing */
1106 };
1107 #endif /* Allow struct image_region to always be defined for rsa.h */
1108 
1109 /* A part of an image, used for hashing */
1110 struct image_region {
1111 	const void *data;
1112 	int size;
1113 };
1114 
1115 #if IMAGE_ENABLE_FIT
1116 
1117 #if IMAGE_ENABLE_VERIFY
1118 # include <u-boot/rsa-checksum.h>
1119 #endif
1120 struct checksum_algo {
1121 	const char *name;
1122 	const int checksum_len;
1123 	const int der_len;
1124 	const uint8_t *der_prefix;
1125 #if IMAGE_ENABLE_SIGN
1126 	const EVP_MD *(*calculate_sign)(void);
1127 #endif
1128 	int (*calculate)(const char *name,
1129 			 const struct image_region region[],
1130 			 int region_count, uint8_t *checksum);
1131 };
1132 
1133 struct crypto_algo {
1134 	const char *name;		/* Name of algorithm */
1135 	const int key_len;
1136 
1137 	/**
1138 	 * sign() - calculate and return signature for given input data
1139 	 *
1140 	 * @info:	Specifies key and FIT information
1141 	 * @data:	Pointer to the input data
1142 	 * @data_len:	Data length
1143 	 * @sigp:	Set to an allocated buffer holding the signature
1144 	 * @sig_len:	Set to length of the calculated hash
1145 	 *
1146 	 * This computes input data signature according to selected algorithm.
1147 	 * Resulting signature value is placed in an allocated buffer, the
1148 	 * pointer is returned as *sigp. The length of the calculated
1149 	 * signature is returned via the sig_len pointer argument. The caller
1150 	 * should free *sigp.
1151 	 *
1152 	 * @return: 0, on success, -ve on error
1153 	 */
1154 	int (*sign)(struct image_sign_info *info,
1155 		    const struct image_region region[],
1156 		    int region_count, uint8_t **sigp, uint *sig_len);
1157 
1158 	/**
1159 	 * add_verify_data() - Add verification information to FDT
1160 	 *
1161 	 * Add public key information to the FDT node, suitable for
1162 	 * verification at run-time. The information added depends on the
1163 	 * algorithm being used.
1164 	 *
1165 	 * @info:	Specifies key and FIT information
1166 	 * @keydest:	Destination FDT blob for public key data
1167 	 * @return: 0, on success, -ve on error
1168 	 */
1169 	int (*add_verify_data)(struct image_sign_info *info, void *keydest);
1170 
1171 	/**
1172 	 * verify() - Verify a signature against some data
1173 	 *
1174 	 * @info:	Specifies key and FIT information
1175 	 * @data:	Pointer to the input data
1176 	 * @data_len:	Data length
1177 	 * @sig:	Signature
1178 	 * @sig_len:	Number of bytes in signature
1179 	 * @return 0 if verified, -ve on error
1180 	 */
1181 	int (*verify)(struct image_sign_info *info,
1182 		      const struct image_region region[], int region_count,
1183 		      uint8_t *sig, uint sig_len);
1184 };
1185 
1186 /**
1187  * image_get_checksum_algo() - Look up a checksum algorithm
1188  *
1189  * @param full_name	Name of algorithm in the form "checksum,crypto"
1190  * @return pointer to algorithm information, or NULL if not found
1191  */
1192 struct checksum_algo *image_get_checksum_algo(const char *full_name);
1193 
1194 /**
1195  * image_get_crypto_algo() - Look up a cryptosystem algorithm
1196  *
1197  * @param full_name	Name of algorithm in the form "checksum,crypto"
1198  * @return pointer to algorithm information, or NULL if not found
1199  */
1200 struct crypto_algo *image_get_crypto_algo(const char *full_name);
1201 
1202 /**
1203  * fit_image_verify_required_sigs() - Verify signatures marked as 'required'
1204  *
1205  * @fit:		FIT to check
1206  * @image_noffset:	Offset of image node to check
1207  * @data:		Image data to check
1208  * @size:		Size of image data
1209  * @sig_blob:		FDT containing public keys
1210  * @no_sigsp:		Returns 1 if no signatures were required, and
1211  *			therefore nothing was checked. The caller may wish
1212  *			to fall back to other mechanisms, or refuse to
1213  *			boot.
1214  * @return 0 if all verified ok, <0 on error
1215  */
1216 int fit_image_verify_required_sigs(const void *fit, int image_noffset,
1217 		const char *data, size_t size, const void *sig_blob,
1218 		int *no_sigsp);
1219 
1220 /**
1221  * fit_image_check_sig() - Check a single image signature node
1222  *
1223  * @fit:		FIT to check
1224  * @noffset:		Offset of signature node to check
1225  * @data:		Image data to check
1226  * @size:		Size of image data
1227  * @required_keynode:	Offset in the control FDT of the required key node,
1228  *			if any. If this is given, then the image wil not
1229  *			pass verification unless that key is used. If this is
1230  *			-1 then any signature will do.
1231  * @err_msgp:		In the event of an error, this will be pointed to a
1232  *			help error string to display to the user.
1233  * @return 0 if all verified ok, <0 on error
1234  */
1235 int fit_image_check_sig(const void *fit, int noffset, const void *data,
1236 		size_t size, int required_keynode, char **err_msgp);
1237 
1238 /**
1239  * fit_region_make_list() - Make a list of regions to hash
1240  *
1241  * Given a list of FIT regions (offset, size) provided by libfdt, create
1242  * a list of regions (void *, size) for use by the signature creationg
1243  * and verification code.
1244  *
1245  * @fit:		FIT image to process
1246  * @fdt_regions:	Regions as returned by libfdt
1247  * @count:		Number of regions returned by libfdt
1248  * @region:		Place to put list of regions (NULL to allocate it)
1249  * @return pointer to list of regions, or NULL if out of memory
1250  */
1251 struct image_region *fit_region_make_list(const void *fit,
1252 		struct fdt_region *fdt_regions, int count,
1253 		struct image_region *region);
1254 
fit_image_check_target_arch(const void * fdt,int node)1255 static inline int fit_image_check_target_arch(const void *fdt, int node)
1256 {
1257 #ifndef USE_HOSTCC
1258 	return fit_image_check_arch(fdt, node, IH_ARCH_DEFAULT);
1259 #else
1260 	return 0;
1261 #endif
1262 }
1263 
1264 #ifdef CONFIG_FIT_VERBOSE
1265 #define fit_unsupported(msg)	printf("! %s:%d " \
1266 				"FIT images not supported for '%s'\n", \
1267 				__FILE__, __LINE__, (msg))
1268 
1269 #define fit_unsupported_reset(msg)	printf("! %s:%d " \
1270 				"FIT images not supported for '%s' " \
1271 				"- must reset board to recover!\n", \
1272 				__FILE__, __LINE__, (msg))
1273 #else
1274 #define fit_unsupported(msg)
1275 #define fit_unsupported_reset(msg)
1276 #endif /* CONFIG_FIT_VERBOSE */
1277 #endif /* CONFIG_FIT */
1278 
1279 #if defined(CONFIG_ANDROID_BOOT_IMAGE)
1280 struct andr_img_hdr;
1281 int android_image_check_header(const struct andr_img_hdr *hdr);
1282 int android_image_get_kernel(const struct andr_img_hdr *hdr, int verify,
1283 			     ulong *os_data, ulong *os_len);
1284 int android_image_get_ramdisk(const struct andr_img_hdr *hdr,
1285 			      ulong *rd_data, ulong *rd_len);
1286 int android_image_get_second(const struct andr_img_hdr *hdr,
1287 			      ulong *second_data, ulong *second_len);
1288 ulong android_image_get_end(const struct andr_img_hdr *hdr);
1289 ulong android_image_get_kload(const struct andr_img_hdr *hdr);
1290 void android_print_contents(const struct andr_img_hdr *hdr);
1291 
1292 /** android_image_load - Load an Android Image from storage.
1293  *
1294  * Load an Android Image based on the header size in the storage. Return the
1295  * number of bytes read from storage, which could be bigger than the actual
1296  * Android Image as described in the header size. In case of error reading the
1297  * image or if the image size needed to be read from disk is bigger than the
1298  * the passed |max_size| a negative number is returned.
1299  *
1300  * @dev_desc:		The device where to read the image from
1301  * @part_info:		The partition in |dev_desc| where to read the image from
1302  * @load_address:	The address where the image will be loaded
1303  * @max_size:		The maximum loaded size, in bytes
1304  * @return the number of bytes read or a negative number in case of error.
1305  */
1306 long android_image_load(struct blk_desc *dev_desc,
1307 			const disk_partition_t *part_info,
1308 			unsigned long load_address,
1309 			unsigned long max_size);
1310 
1311 #endif /* CONFIG_ANDROID_BOOT_IMAGE */
1312 
1313 /**
1314  * board_fit_config_name_match() - Check for a matching board name
1315  *
1316  * This is used when SPL loads a FIT containing multiple device tree files
1317  * and wants to work out which one to use. The description of each one is
1318  * passed to this function. The description comes from the 'description' field
1319  * in each (FDT) image node.
1320  *
1321  * @name: Device tree description
1322  * @return 0 if this device tree should be used, non-zero to try the next
1323  */
1324 int board_fit_config_name_match(const char *name);
1325 
1326 #if defined(CONFIG_SPL_FIT_IMAGE_POST_PROCESS) || \
1327 	defined(CONFIG_FIT_IMAGE_POST_PROCESS)
1328 /**
1329  * board_fit_image_post_process() - Do any post-process on FIT binary data
1330  *
1331  * This is used to do any sort of image manipulation, verification, decryption
1332  * etc. in a platform or board specific way. Obviously, anything done here would
1333  * need to be comprehended in how the images were prepared before being injected
1334  * into the FIT creation (i.e. the binary blobs would have been pre-processed
1335  * before being added to the FIT image).
1336  *
1337  * @image: pointer to the image start pointer
1338  * @size: pointer to the image size
1339  * @return no return value (failure should be handled internally)
1340  */
1341 void board_fit_image_post_process(void **p_image, size_t *p_size);
1342 #endif /* CONFIG_SPL_FIT_IMAGE_POST_PROCESS */
1343 
1344 #define FDT_ERROR	((ulong)(-1))
1345 
1346 ulong fdt_getprop_u32(const void *fdt, int node, const char *prop);
1347 
1348 /**
1349  * fit_find_config_node() - Find the node for the best DTB in a FIT image
1350  *
1351  * A FIT image contains one or more DTBs. This function parses the
1352  * configurations described in the FIT images and returns the node of
1353  * the first matching DTB. To check if a DTB matches a board, this function
1354  * calls board_fit_config_name_match(). If no matching DTB is found, it returns
1355  * the node described by the default configuration if it exists.
1356  *
1357  * @fdt: pointer to flat device tree
1358  * @return the node if found, -ve otherwise
1359  */
1360 int fit_find_config_node(const void *fdt);
1361 
1362 /**
1363  * Mapping of image types to function handlers to be invoked on the associated
1364  * loaded images
1365  *
1366  * @type: Type of image, I.E. IH_TYPE_*
1367  * @handler: Function to call on loaded image
1368  */
1369 struct fit_loadable_tbl {
1370 	int type;
1371 	/**
1372 	 * handler() - Process a loaded image
1373 	 *
1374 	 * @data: Pointer to start of loaded image data
1375 	 * @size: Size of loaded image data
1376 	 */
1377 	void (*handler)(ulong data, size_t size);
1378 };
1379 
1380 /*
1381  * Define a FIT loadable image type handler
1382  *
1383  * _type is a valid uimage_type ID as defined in the "Image Type" enum above
1384  * _handler is the handler function to call after this image type is loaded
1385  */
1386 #define U_BOOT_FIT_LOADABLE_HANDLER(_type, _handler) \
1387 	ll_entry_declare(struct fit_loadable_tbl, _function, fit_loadable) = { \
1388 		.type = _type, \
1389 		.handler = _handler, \
1390 	}
1391 
1392 #endif	/* __IMAGE_H__ */
1393