image.h 42.5 KB
Newer Older
wdenk's avatar
wdenk committed
1
/*
2 3
 * (C) Copyright 2008 Semihalf
 *
4
 * (C) Copyright 2000-2005
wdenk's avatar
wdenk committed
5 6
 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
 *
7
 * SPDX-License-Identifier:	GPL-2.0+
8 9 10 11 12 13
 ********************************************************************
 * NOTE: This header file defines an interface to U-Boot. Including
 * this (unmodified) header file in another file is considered normal
 * use of U-Boot, and does *not* fall under the heading of "derived
 * work".
 ********************************************************************
wdenk's avatar
wdenk committed
14 15 16 17 18
 */

#ifndef __IMAGE_H__
#define __IMAGE_H__

19
#include "compiler.h"
Kim Phillips's avatar
Kim Phillips committed
20
#include <asm/byteorder.h>
21

22 23 24
/* Define this to avoid #ifdefs later on */
struct lmb;

25
#ifdef USE_HOSTCC
Jörg Krause's avatar
Jörg Krause committed
26
#include <sys/types.h>
27 28

/* new uImage format support enabled on host */
29 30
#define IMAGE_ENABLE_FIT	1
#define IMAGE_ENABLE_OF_LIBFDT	1
31
#define CONFIG_FIT_VERBOSE	1 /* enable fit_format_{error,warning}() */
32
#define CONFIG_FIT_ENABLE_SHA256_SUPPORT
33 34
#define CONFIG_SHA1
#define CONFIG_SHA256
35

36
#define IMAGE_ENABLE_IGNORE	0
37
#define IMAGE_INDENT_STRING	""
38

39 40 41 42
#else

#include <lmb.h>
#include <asm/u-boot.h>
43
#include <command.h>
44

45 46
/* Take notice of the 'ignore' property for hashes */
#define IMAGE_ENABLE_IGNORE	1
47
#define IMAGE_INDENT_STRING	"   "
48

49 50
#define IMAGE_ENABLE_FIT	CONFIG_IS_ENABLED(FIT)
#define IMAGE_ENABLE_OF_LIBFDT	CONFIG_IS_ENABLED(OF_LIBFDT)
51

52
#endif /* USE_HOSTCC */
53

54
#if IMAGE_ENABLE_FIT
55
#include <hash.h>
56 57
#include <libfdt.h>
#include <fdt_support.h>
58
# ifdef CONFIG_SPL_BUILD
59 60 61 62 63 64 65 66 67
#  ifdef CONFIG_SPL_CRC32_SUPPORT
#   define IMAGE_ENABLE_CRC32	1
#  endif
#  ifdef CONFIG_SPL_MD5_SUPPORT
#   define IMAGE_ENABLE_MD5	1
#  endif
#  ifdef CONFIG_SPL_SHA1_SUPPORT
#   define IMAGE_ENABLE_SHA1	1
#  endif
68 69 70 71 72 73
# else
#  define CONFIG_CRC32		/* FIT images need CRC32 support */
#  define IMAGE_ENABLE_CRC32	1
#  define IMAGE_ENABLE_MD5	1
#  define IMAGE_ENABLE_SHA1	1
# endif
74 75 76 77 78 79 80 81 82 83 84 85 86

#ifndef IMAGE_ENABLE_CRC32
#define IMAGE_ENABLE_CRC32	0
#endif

#ifndef IMAGE_ENABLE_MD5
#define IMAGE_ENABLE_MD5	0
#endif

#ifndef IMAGE_ENABLE_SHA1
#define IMAGE_ENABLE_SHA1	0
#endif

87 88 89 90
#if defined(CONFIG_FIT_ENABLE_SHA256_SUPPORT) || \
	defined(CONFIG_SPL_SHA256_SUPPORT)
#define IMAGE_ENABLE_SHA256	1
#else
91 92 93
#define IMAGE_ENABLE_SHA256	0
#endif

94
#endif /* IMAGE_ENABLE_FIT */
95

96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112
#ifdef CONFIG_SYS_BOOT_GET_CMDLINE
# define IMAGE_BOOT_GET_CMDLINE		1
#else
# define IMAGE_BOOT_GET_CMDLINE		0
#endif

#ifdef CONFIG_OF_BOARD_SETUP
# define IMAGE_OF_BOARD_SETUP		1
#else
# define IMAGE_OF_BOARD_SETUP		0
#endif

#ifdef CONFIG_OF_SYSTEM_SETUP
# define IMAGE_OF_SYSTEM_SETUP	1
#else
# define IMAGE_OF_SYSTEM_SETUP	0
#endif
113

114 115 116 117 118 119 120 121 122
enum ih_category {
	IH_ARCH,
	IH_COMP,
	IH_OS,
	IH_TYPE,

	IH_COUNT,
};

wdenk's avatar
wdenk committed
123 124
/*
 * Operating System Codes
125 126 127
 *
 * The following are exposed to uImage header.
 * Do not change values for backward compatibility.
wdenk's avatar
wdenk committed
128
 */
129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154
enum {
	IH_OS_INVALID		= 0,	/* Invalid OS	*/
	IH_OS_OPENBSD,			/* OpenBSD	*/
	IH_OS_NETBSD,			/* NetBSD	*/
	IH_OS_FREEBSD,			/* FreeBSD	*/
	IH_OS_4_4BSD,			/* 4.4BSD	*/
	IH_OS_LINUX,			/* Linux	*/
	IH_OS_SVR4,			/* SVR4		*/
	IH_OS_ESIX,			/* Esix		*/
	IH_OS_SOLARIS,			/* Solaris	*/
	IH_OS_IRIX,			/* Irix		*/
	IH_OS_SCO,			/* SCO		*/
	IH_OS_DELL,			/* Dell		*/
	IH_OS_NCR,			/* NCR		*/
	IH_OS_LYNXOS,			/* LynxOS	*/
	IH_OS_VXWORKS,			/* VxWorks	*/
	IH_OS_PSOS,			/* pSOS		*/
	IH_OS_QNX,			/* QNX		*/
	IH_OS_U_BOOT,			/* Firmware	*/
	IH_OS_RTEMS,			/* RTEMS	*/
	IH_OS_ARTOS,			/* ARTOS	*/
	IH_OS_UNITY,			/* Unity OS	*/
	IH_OS_INTEGRITY,		/* INTEGRITY	*/
	IH_OS_OSE,			/* OSE		*/
	IH_OS_PLAN9,			/* Plan 9	*/
	IH_OS_OPENRTOS,		/* OpenRTOS	*/
155
	IH_OS_ARM_TRUSTED_FIRMWARE,     /* ARM Trusted Firmware */
156 157 158

	IH_OS_COUNT,
};
wdenk's avatar
wdenk committed
159 160 161

/*
 * CPU Architecture Codes (supported by Linux)
162 163 164
 *
 * The following are exposed to uImage header.
 * Do not change values for backward compatibility.
wdenk's avatar
wdenk committed
165
 */
166 167 168 169 170 171 172 173 174 175 176 177 178 179
enum {
	IH_ARCH_INVALID		= 0,	/* Invalid CPU	*/
	IH_ARCH_ALPHA,			/* Alpha	*/
	IH_ARCH_ARM,			/* ARM		*/
	IH_ARCH_I386,			/* Intel x86	*/
	IH_ARCH_IA64,			/* IA64		*/
	IH_ARCH_MIPS,			/* MIPS		*/
	IH_ARCH_MIPS64,			/* MIPS	 64 Bit */
	IH_ARCH_PPC,			/* PowerPC	*/
	IH_ARCH_S390,			/* IBM S390	*/
	IH_ARCH_SH,			/* SuperH	*/
	IH_ARCH_SPARC,			/* Sparc	*/
	IH_ARCH_SPARC64,		/* Sparc 64 Bit */
	IH_ARCH_M68K,			/* M68K		*/
180
	IH_ARCH_NIOS,			/* Nios-32	*/
181 182 183 184 185 186 187 188 189 190 191
	IH_ARCH_MICROBLAZE,		/* MicroBlaze   */
	IH_ARCH_NIOS2,			/* Nios-II	*/
	IH_ARCH_BLACKFIN,		/* Blackfin	*/
	IH_ARCH_AVR32,			/* AVR32	*/
	IH_ARCH_ST200,			/* STMicroelectronics ST200  */
	IH_ARCH_SANDBOX,		/* Sandbox architecture (test only) */
	IH_ARCH_NDS32,			/* ANDES Technology - NDS32  */
	IH_ARCH_OPENRISC,		/* OpenRISC 1000  */
	IH_ARCH_ARM64,			/* ARM64	*/
	IH_ARCH_ARC,			/* Synopsys DesignWare ARC */
	IH_ARCH_X86_64,			/* AMD x86_64, Intel and Via */
192
	IH_ARCH_XTENSA,			/* Xtensa	*/
193 194 195

	IH_ARCH_COUNT,
};
wdenk's avatar
wdenk committed
196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223

/*
 * Image Types
 *
 * "Standalone Programs" are directly runnable in the environment
 *	provided by U-Boot; it is expected that (if they behave
 *	well) you can continue to work in U-Boot after return from
 *	the Standalone Program.
 * "OS Kernel Images" are usually images of some Embedded OS which
 *	will take over control completely. Usually these programs
 *	will install their own set of exception handlers, device
 *	drivers, set up the MMU, etc. - this means, that you cannot
 *	expect to re-enter U-Boot except by resetting the CPU.
 * "RAMDisk Images" are more or less just data blocks, and their
 *	parameters (address, size) are passed to an OS kernel that is
 *	being started.
 * "Multi-File Images" contain several images, typically an OS
 *	(Linux) kernel image and one or more data images like
 *	RAMDisks. This construct is useful for instance when you want
 *	to boot over the network using BOOTP etc., where the boot
 *	server provides just a single image file, but you want to get
 *	for instance an OS kernel and a RAMDisk image.
 *
 *	"Multi-File Images" start with a list of image sizes, each
 *	image size (in bytes) specified by an "uint32_t" in network
 *	byte order. This list is terminated by an "(uint32_t)0".
 *	Immediately after the terminating 0 follow the images, one by
 *	one, all aligned on "uint32_t" boundaries (size rounded up to
224
 *	a multiple of 4 bytes - except for the last file).
wdenk's avatar
wdenk committed
225 226 227 228 229 230 231 232
 *
 * "Firmware Images" are binary images containing firmware (like
 *	U-Boot or FPGA images) which usually will be programmed to
 *	flash memory.
 *
 * "Script files" are command sequences that will be executed by
 *	U-Boot's command interpreter; this feature is especially
 *	useful when you configure U-Boot to use a real shell (hush)
233
 *	as command interpreter (=> Shell Scripts).
234 235 236
 *
 * The following are exposed to uImage header.
 * Do not change values for backward compatibility.
wdenk's avatar
wdenk committed
237 238
 */

239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269
enum {
	IH_TYPE_INVALID		= 0,	/* Invalid Image		*/
	IH_TYPE_STANDALONE,		/* Standalone Program		*/
	IH_TYPE_KERNEL,			/* OS Kernel Image		*/
	IH_TYPE_RAMDISK,		/* RAMDisk Image		*/
	IH_TYPE_MULTI,			/* Multi-File Image		*/
	IH_TYPE_FIRMWARE,		/* Firmware Image		*/
	IH_TYPE_SCRIPT,			/* Script file			*/
	IH_TYPE_FILESYSTEM,		/* Filesystem Image (any type)	*/
	IH_TYPE_FLATDT,			/* Binary Flat Device Tree Blob	*/
	IH_TYPE_KWBIMAGE,		/* Kirkwood Boot Image		*/
	IH_TYPE_IMXIMAGE,		/* Freescale IMXBoot Image	*/
	IH_TYPE_UBLIMAGE,		/* Davinci UBL Image		*/
	IH_TYPE_OMAPIMAGE,		/* TI OMAP Config Header Image	*/
	IH_TYPE_AISIMAGE,		/* TI Davinci AIS Image		*/
	/* OS Kernel Image, can run from any load address */
	IH_TYPE_KERNEL_NOLOAD,
	IH_TYPE_PBLIMAGE,		/* Freescale PBL Boot Image	*/
	IH_TYPE_MXSIMAGE,		/* Freescale MXSBoot Image	*/
	IH_TYPE_GPIMAGE,		/* TI Keystone GPHeader Image	*/
	IH_TYPE_ATMELIMAGE,		/* ATMEL ROM bootable Image	*/
	IH_TYPE_SOCFPGAIMAGE,		/* Altera SOCFPGA Preloader	*/
	IH_TYPE_X86_SETUP,		/* x86 setup.bin Image		*/
	IH_TYPE_LPC32XXIMAGE,		/* x86 setup.bin Image		*/
	IH_TYPE_LOADABLE,		/* A list of typeless images	*/
	IH_TYPE_RKIMAGE,		/* Rockchip Boot Image		*/
	IH_TYPE_RKSD,			/* Rockchip SD card		*/
	IH_TYPE_RKSPI,			/* Rockchip SPI image		*/
	IH_TYPE_ZYNQIMAGE,		/* Xilinx Zynq Boot Image */
	IH_TYPE_ZYNQMPIMAGE,		/* Xilinx ZynqMP Boot Image */
	IH_TYPE_FPGA,			/* FPGA Image */
270
	IH_TYPE_VYBRIDIMAGE,	/* VYBRID .vyb Image */
271
	IH_TYPE_TEE,            /* Trusted Execution Environment OS Image */
272
	IH_TYPE_FIRMWARE_IVT,		/* Firmware Image with HABv4 IVT */
273
	IH_TYPE_PMMC,            /* TI Power Management Micro-Controller Firmware */
274 275 276

	IH_TYPE_COUNT,			/* Number of image types */
};
277

wdenk's avatar
wdenk committed
278 279
/*
 * Compression Types
280 281 282
 *
 * The following are exposed to uImage header.
 * Do not change values for backward compatibility.
wdenk's avatar
wdenk committed
283
 */
284 285 286 287 288 289 290 291 292 293
enum {
	IH_COMP_NONE		= 0,	/*  No	 Compression Used	*/
	IH_COMP_GZIP,			/* gzip	 Compression Used	*/
	IH_COMP_BZIP2,			/* bzip2 Compression Used	*/
	IH_COMP_LZMA,			/* lzma  Compression Used	*/
	IH_COMP_LZO,			/* lzo   Compression Used	*/
	IH_COMP_LZ4,			/* lz4   Compression Used	*/

	IH_COMP_COUNT,
};
wdenk's avatar
wdenk committed
294 295 296 297

#define IH_MAGIC	0x27051956	/* Image Magic Number		*/
#define IH_NMLEN		32	/* Image Name Length		*/

298 299 300
/* Reused from common.h */
#define ROUND(a, b)		(((a) + (b) - 1) & ~((b) - 1))

wdenk's avatar
wdenk committed
301
/*
302 303
 * Legacy format image header,
 * all data in network byte order (aka natural aka bigendian).
wdenk's avatar
wdenk committed
304 305
 */
typedef struct image_header {
Kim Phillips's avatar
Kim Phillips committed
306 307 308 309 310 311 312
	__be32		ih_magic;	/* Image Header Magic Number	*/
	__be32		ih_hcrc;	/* Image Header CRC Checksum	*/
	__be32		ih_time;	/* Image Creation Timestamp	*/
	__be32		ih_size;	/* Image Data Size		*/
	__be32		ih_load;	/* Data	 Load  Address		*/
	__be32		ih_ep;		/* Entry Point Address		*/
	__be32		ih_dcrc;	/* Image Data CRC Checksum	*/
wdenk's avatar
wdenk committed
313 314 315 316 317 318 319
	uint8_t		ih_os;		/* Operating System		*/
	uint8_t		ih_arch;	/* CPU architecture		*/
	uint8_t		ih_type;	/* Image Type			*/
	uint8_t		ih_comp;	/* Compression Type		*/
	uint8_t		ih_name[IH_NMLEN];	/* Image Name		*/
} image_header_t;

320 321 322 323 324
typedef struct image_info {
	ulong		start, end;		/* start/end of blob */
	ulong		image_start, image_len; /* start of image within blob, len of image */
	ulong		load;			/* load addr for the image */
	uint8_t		comp, type, os;		/* compression, type of image, os type */
325
	uint8_t		arch;			/* CPU architecture */
326 327
} image_info_t;

328 329 330 331 332 333 334
/*
 * Legacy and FIT format headers used by do_bootm() and do_bootm_<os>()
 * routines.
 */
typedef struct bootm_headers {
	/*
	 * Legacy os image header, if it is a multi component image
335
	 * then boot_get_ramdisk() and get_fdt() will attempt to get
336 337
	 * data from second and third component accordingly.
	 */
338 339
	image_header_t	*legacy_hdr_os;		/* image header pointer */
	image_header_t	legacy_hdr_os_copy;	/* header copy */
340 341
	ulong		legacy_hdr_valid;

342
#if IMAGE_ENABLE_FIT
343 344
	const char	*fit_uname_cfg;	/* configuration node unit name */

345
	void		*fit_hdr_os;	/* os FIT image header */
346
	const char	*fit_uname_os;	/* os subimage node unit name */
347
	int		fit_noffset_os;	/* os subimage node offset */
348 349

	void		*fit_hdr_rd;	/* init ramdisk FIT image header */
350 351
	const char	*fit_uname_rd;	/* init ramdisk subimage node unit name */
	int		fit_noffset_rd;	/* init ramdisk subimage node offset */
352 353

	void		*fit_hdr_fdt;	/* FDT blob FIT image header */
354 355
	const char	*fit_uname_fdt;	/* FDT blob subimage node unit name */
	int		fit_noffset_fdt;/* FDT blob subimage node offset */
356 357 358 359

	void		*fit_hdr_setup;	/* x86 setup FIT image header */
	const char	*fit_uname_setup; /* x86 setup subimage node name */
	int		fit_noffset_setup;/* x86 setup subimage node offset */
360
#endif
361

Kumar Gala's avatar
Kumar Gala committed
362
#ifndef USE_HOSTCC
363
	image_info_t	os;		/* os image info */
364 365
	ulong		ep;		/* entry point of OS */

366 367
	ulong		rd_start, rd_end;/* ramdisk start/end */

368 369 370
	char		*ft_addr;	/* flat dev tree address */
	ulong		ft_len;		/* length of flat device tree */

Kumar Gala's avatar
Kumar Gala committed
371 372 373 374 375 376 377
	ulong		initrd_start;
	ulong		initrd_end;
	ulong		cmdline_start;
	ulong		cmdline_end;
	bd_t		*kbd;
#endif

378
	int		verify;		/* env_get("verify")[0] != 'n' */
Kumar Gala's avatar
Kumar Gala committed
379 380

#define	BOOTM_STATE_START	(0x00000001)
381 382 383 384 385 386 387 388
#define	BOOTM_STATE_FINDOS	(0x00000002)
#define	BOOTM_STATE_FINDOTHER	(0x00000004)
#define	BOOTM_STATE_LOADOS	(0x00000008)
#define	BOOTM_STATE_RAMDISK	(0x00000010)
#define	BOOTM_STATE_FDT		(0x00000020)
#define	BOOTM_STATE_OS_CMDLINE	(0x00000040)
#define	BOOTM_STATE_OS_BD_T	(0x00000080)
#define	BOOTM_STATE_OS_PREP	(0x00000100)
389 390
#define	BOOTM_STATE_OS_FAKE_GO	(0x00000200)	/* 'Almost' run the OS */
#define	BOOTM_STATE_OS_GO	(0x00000400)
Kumar Gala's avatar
Kumar Gala committed
391 392
	int		state;

393
#ifdef CONFIG_LMB
394 395
	struct lmb	lmb;		/* for memory mgmt */
#endif
396 397
} bootm_headers_t;

Simon Schwarz's avatar
Simon Schwarz committed
398 399
extern bootm_headers_t images;

400 401 402
/*
 * Some systems (for example LWMON) have very short watchdog periods;
 * we must make sure to split long operations like memmove() or
403
 * checksum calculations into reasonable chunks.
404
 */
405
#ifndef CHUNKSZ
406
#define CHUNKSZ (64 * 1024)
407 408 409 410 411 412 413 414 415 416 417 418 419
#endif

#ifndef CHUNKSZ_CRC32
#define CHUNKSZ_CRC32 (64 * 1024)
#endif

#ifndef CHUNKSZ_MD5
#define CHUNKSZ_MD5 (64 * 1024)
#endif

#ifndef CHUNKSZ_SHA1
#define CHUNKSZ_SHA1 (64 * 1024)
#endif
420

421 422
#define uimage_to_cpu(x)		be32_to_cpu(x)
#define cpu_to_uimage(x)		cpu_to_be32(x)
423

424 425 426 427 428 429 430 431 432 433 434 435 436 437 438
/*
 * Translation table for entries of a specific type; used by
 * get_table_entry_id() and get_table_entry_name().
 */
typedef struct table_entry {
	int	id;
	char	*sname;		/* short (input) name to find table entry */
	char	*lname;		/* long (output) name to print for messages */
} table_entry_t;

/*
 * get_table_entry_id() scans the translation table trying to find an
 * entry that matches the given short name. If a matching entry is
 * found, it's id is returned to the caller.
 */
439
int get_table_entry_id(const table_entry_t *table,
440 441 442 443 444 445
		const char *table_name, const char *name);
/*
 * get_table_entry_name() scans the translation table trying to find
 * an entry that matches the given id. If a matching entry is found,
 * its long name is returned to the caller.
 */
446
char *get_table_entry_name(const table_entry_t *table, char *msg, int id);
447

448
const char *genimg_get_os_name(uint8_t os);
449 450 451 452 453 454 455 456 457

/**
 * genimg_get_os_short_name() - get the short name for an OS
 *
 * @param os	OS (IH_OS_...)
 * @return OS short name, or "unknown" if unknown
 */
const char *genimg_get_os_short_name(uint8_t comp);

458
const char *genimg_get_arch_name(uint8_t arch);
459 460 461 462 463 464 465 466 467

/**
 * genimg_get_arch_short_name() - get the short name for an architecture
 *
 * @param arch	Architecture type (IH_ARCH_...)
 * @return architecture short name, or "unknown" if unknown
 */
const char *genimg_get_arch_short_name(uint8_t arch);

468
const char *genimg_get_type_name(uint8_t type);
469 470 471 472 473 474 475 476 477

/**
 * genimg_get_type_short_name() - get the short name for an image type
 *
 * @param type	Image type (IH_TYPE_...)
 * @return image short name, or "unknown" if unknown
 */
const char *genimg_get_type_short_name(uint8_t type);

478
const char *genimg_get_comp_name(uint8_t comp);
479 480 481 482 483 484 485 486 487

/**
 * genimg_get_comp_short_name() - get the short name for a compression method
 *
 * @param comp	compression method (IH_COMP_...)
 * @return compression method short name, or "unknown" if unknown
 */
const char *genimg_get_comp_short_name(uint8_t comp);

488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521
/**
 * genimg_get_cat_name() - Get the name of an item in a category
 *
 * @category:	Category of item
 * @id:		Item ID
 * @return name of item, or "Unknown ..." if unknown
 */
const char *genimg_get_cat_name(enum ih_category category, uint id);

/**
 * genimg_get_cat_short_name() - Get the short name of an item in a category
 *
 * @category:	Category of item
 * @id:		Item ID
 * @return short name of item, or "Unknown ..." if unknown
 */
const char *genimg_get_cat_short_name(enum ih_category category, uint id);

/**
 * genimg_get_cat_count() - Get the number of items in a category
 *
 * @category:	Category to check
 * @return the number of items in the category (IH_xxx_COUNT)
 */
int genimg_get_cat_count(enum ih_category category);

/**
 * genimg_get_cat_desc() - Get the description of a category
 *
 * @return the description of a category, e.g. "architecture". This
 * effectively converts the enum to a string.
 */
const char *genimg_get_cat_desc(enum ih_category category);

522 523 524 525 526
int genimg_get_os_id(const char *name);
int genimg_get_arch_id(const char *name);
int genimg_get_type_id(const char *name);
int genimg_get_comp_id(const char *name);
void genimg_print_size(uint32_t size);
527

528 529 530 531 532 533 534 535
#if defined(CONFIG_TIMESTAMP) || defined(CONFIG_CMD_DATE) || \
	defined(USE_HOSTCC)
#define IMAGE_ENABLE_TIMESTAMP 1
#else
#define IMAGE_ENABLE_TIMESTAMP 0
#endif
void genimg_print_time(time_t timestamp);

536 537 538 539
/* What to do with a image load address ('load = <> 'in the FIT) */
enum fit_load_op {
	FIT_LOAD_IGNORED,	/* Ignore load address */
	FIT_LOAD_OPTIONAL,	/* Can be provided, but optional */
540
	FIT_LOAD_OPTIONAL_NON_ZERO,	/* Optional, a value of 0 is ignored */
541 542 543
	FIT_LOAD_REQUIRED,	/* Must be provided */
};

544 545 546
int boot_get_setup(bootm_headers_t *images, uint8_t arch, ulong *setup_start,
		   ulong *setup_len);

547 548 549
#ifndef USE_HOSTCC
/* Image format types, returned by _get_format() routine */
#define IMAGE_FORMAT_INVALID	0x00
550
#if defined(CONFIG_IMAGE_FORMAT_LEGACY)
551
#define IMAGE_FORMAT_LEGACY	0x01	/* legacy image_header based format */
552
#endif
553
#define IMAGE_FORMAT_FIT	0x02	/* new, libfdt based format */
554
#define IMAGE_FORMAT_ANDROID	0x03	/* Android boot image */
555

556 557 558
ulong genimg_get_kernel_addr_fit(char * const img_addr,
			         const char **fit_uname_config,
			         const char **fit_uname_kernel);
559
ulong genimg_get_kernel_addr(char * const img_addr);
560
int genimg_get_format(const void *img_addr);
561
int genimg_has_config(bootm_headers_t *images);
562

563 564
int boot_get_fpga(int argc, char * const argv[], bootm_headers_t *images,
		uint8_t arch, const ulong *ld_start, ulong * const ld_len);
565
int boot_get_ramdisk(int argc, char * const argv[], bootm_headers_t *images,
566
		uint8_t arch, ulong *rd_start, ulong *rd_end);
567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591

/**
 * boot_get_loadable - routine to load a list of binaries to memory
 * @argc: Ignored Argument
 * @argv: Ignored Argument
 * @images: pointer to the bootm images structure
 * @arch: expected architecture for the image
 * @ld_start: Ignored Argument
 * @ld_len: Ignored Argument
 *
 * boot_get_loadable() will take the given FIT configuration, and look
 * for a field named "loadables".  Loadables, is a list of elements in
 * the FIT given as strings.  exe:
 *   loadables = "linux_kernel@1", "fdt@2";
 * this function will attempt to parse each string, and load the
 * corresponding element from the FIT into memory.  Once placed,
 * no aditional actions are taken.
 *
 * @return:
 *     0, if only valid images or no images are found
 *     error code, if an error occurs during fit_image_load
 */
int boot_get_loadable(int argc, char * const argv[], bootm_headers_t *images,
		uint8_t arch, const ulong *ld_start, ulong * const ld_len);
#endif /* !USE_HOSTCC */
592

593 594 595
int boot_get_setup_fit(bootm_headers_t *images, uint8_t arch,
		       ulong *setup_start, ulong *setup_len);

596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620
/**
 * boot_get_fdt_fit() - load a DTB from a FIT file (applying overlays)
 *
 * This deals with all aspects of loading an DTB from a FIT.
 * The correct base image based on configuration will be selected, and
 * then any overlays specified will be applied (as present in fit_uname_configp).
 *
 * @param images	Boot images structure
 * @param addr		Address of FIT in memory
 * @param fit_unamep	On entry this is the requested image name
 *			(e.g. "kernel@1") or NULL to use the default. On exit
 *			points to the selected image name
 * @param fit_uname_configp	On entry this is the requested configuration
 *			name (e.g. "conf@1") or NULL to use the default. On
 *			exit points to the selected configuration name.
 * @param arch		Expected architecture (IH_ARCH_...)
 * @param datap		Returns address of loaded image
 * @param lenp		Returns length of loaded image
 *
 * @return node offset of base image, or -ve error code on error
 */
int boot_get_fdt_fit(bootm_headers_t *images, ulong addr,
		   const char **fit_unamep, const char **fit_uname_configp,
		   int arch, ulong *datap, ulong *lenp);

621 622 623 624 625 626 627 628
/**
 * fit_image_load() - load an image from a FIT
 *
 * This deals with all aspects of loading an image from a FIT, including
 * selecting the right image based on configuration, verifying it, printing
 * out progress messages, checking the type/arch/os and optionally copying it
 * to the right load address.
 *
629 630
 * The property to look up is defined by image_type.
 *
631 632 633 634 635
 * @param images	Boot images structure
 * @param addr		Address of FIT in memory
 * @param fit_unamep	On entry this is the requested image name
 *			(e.g. "kernel@1") or NULL to use the default. On exit
 *			points to the selected image name
636 637 638
 * @param fit_uname_configp	On entry this is the requested configuration
 *			name (e.g. "conf@1") or NULL to use the default. On
 *			exit points to the selected configuration name.
639 640 641 642 643 644 645 646 647 648
 * @param arch		Expected architecture (IH_ARCH_...)
 * @param image_type	Required image type (IH_TYPE_...). If this is
 *			IH_TYPE_KERNEL then we allow IH_TYPE_KERNEL_NOLOAD
 *			also.
 * @param bootstage_id	ID of starting bootstage to use for progress updates.
 *			This will be added to the BOOTSTAGE_SUB values when
 *			calling bootstage_mark()
 * @param load_op	Decribes what to do with the load address
 * @param datap		Returns address of loaded image
 * @param lenp		Returns length of loaded image
649
 * @return node offset of image, or -ve error code on error
650
 */
651
int fit_image_load(bootm_headers_t *images, ulong addr,
652
		   const char **fit_unamep, const char **fit_uname_configp,
653 654 655
		   int arch, int image_type, int bootstage_id,
		   enum fit_load_op load_op, ulong *datap, ulong *lenp);

656
#ifndef USE_HOSTCC
657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686
/**
 * fit_get_node_from_config() - Look up an image a FIT by type
 *
 * This looks in the selected conf@ node (images->fit_uname_cfg) for a
 * particular image type (e.g. "kernel") and then finds the image that is
 * referred to.
 *
 * For example, for something like:
 *
 * images {
 *	kernel@1 {
 *		...
 *	};
 * };
 * configurations {
 *	conf@1 {
 *		kernel = "kernel@1";
 *	};
 * };
 *
 * the function will return the node offset of the kernel@1 node, assuming
 * that conf@1 is the chosen configuration.
 *
 * @param images	Boot images structure
 * @param prop_name	Property name to look up (FIT_..._PROP)
 * @param addr		Address of FIT in memory
 */
int fit_get_node_from_config(bootm_headers_t *images, const char *prop_name,
			ulong addr);

687 688 689
int boot_get_fdt(int flag, int argc, char * const argv[], uint8_t arch,
		 bootm_headers_t *images,
		 char **of_flat_tree, ulong *of_size);
690
void boot_fdt_add_mem_rsv_regions(struct lmb *lmb, void *fdt_blob);
691
int boot_relocate_fdt(struct lmb *lmb, char **of_flat_tree, ulong *of_size);
692

693
int boot_ramdisk_high(struct lmb *lmb, ulong rd_data, ulong rd_len,
694
		  ulong *initrd_start, ulong *initrd_end);
695
int boot_get_cmdline(struct lmb *lmb, ulong *cmd_start, ulong *cmd_end);
696
#ifdef CONFIG_SYS_BOOT_GET_KBD
697
int boot_get_kbd(struct lmb *lmb, bd_t **kbd);
698
#endif /* CONFIG_SYS_BOOT_GET_KBD */
699
#endif /* !USE_HOSTCC */
700

701 702 703
/*******************************************************************/
/* Legacy format specific code (prefixed with image_) */
/*******************************************************************/
704
static inline uint32_t image_get_header_size(void)
705
{
706
	return (sizeof(image_header_t));
707 708 709
}

#define image_get_hdr_l(f) \
710
	static inline uint32_t image_get_##f(const image_header_t *hdr) \
711
	{ \
712
		return uimage_to_cpu(hdr->ih_##f); \
713
	}
714 715 716 717 718 719 720
image_get_hdr_l(magic)		/* image_get_magic */
image_get_hdr_l(hcrc)		/* image_get_hcrc */
image_get_hdr_l(time)		/* image_get_time */
image_get_hdr_l(size)		/* image_get_size */
image_get_hdr_l(load)		/* image_get_load */
image_get_hdr_l(ep)		/* image_get_ep */
image_get_hdr_l(dcrc)		/* image_get_dcrc */
721 722

#define image_get_hdr_b(f) \
723
	static inline uint8_t image_get_##f(const image_header_t *hdr) \
724 725 726
	{ \
		return hdr->ih_##f; \
	}
727 728 729 730
image_get_hdr_b(os)		/* image_get_os */
image_get_hdr_b(arch)		/* image_get_arch */
image_get_hdr_b(type)		/* image_get_type */
image_get_hdr_b(comp)		/* image_get_comp */
731

732
static inline char *image_get_name(const image_header_t *hdr)
733 734 735 736
{
	return (char *)hdr->ih_name;
}

737
static inline uint32_t image_get_data_size(const image_header_t *hdr)
738
{
739
	return image_get_size(hdr);
740
}
741 742 743 744 745 746 747 748 749 750 751 752

/**
 * image_get_data - get image payload start address
 * @hdr: image header
 *
 * image_get_data() returns address of the image payload. For single
 * component images it is image data start. For multi component
 * images it points to the null terminated table of sub-images sizes.
 *
 * returns:
 *     image payload data start address
 */
753
static inline ulong image_get_data(const image_header_t *hdr)
754
{
755
	return ((ulong)hdr + image_get_header_size());
756 757
}

758
static inline uint32_t image_get_image_size(const image_header_t *hdr)
759
{
760
	return (image_get_size(hdr) + image_get_header_size());
761
}
762
static inline ulong image_get_image_end(const image_header_t *hdr)
763
{
764
	return ((ulong)hdr + image_get_image_size(hdr));
765 766 767 768 769
}

#define image_set_hdr_l(f) \
	static inline void image_set_##f(image_header_t *hdr, uint32_t val) \
	{ \
770
		hdr->ih_##f = cpu_to_uimage(val); \
771
	}
772 773 774 775 776 777 778
image_set_hdr_l(magic)		/* image_set_magic */
image_set_hdr_l(hcrc)		/* image_set_hcrc */
image_set_hdr_l(time)		/* image_set_time */
image_set_hdr_l(size)		/* image_set_size */
image_set_hdr_l(load)		/* image_set_load */
image_set_hdr_l(ep)		/* image_set_ep */
image_set_hdr_l(dcrc)		/* image_set_dcrc */
779 780 781 782 783 784

#define image_set_hdr_b(f) \
	static inline void image_set_##f(image_header_t *hdr, uint8_t val) \
	{ \
		hdr->ih_##f = val; \
	}
785 786 787 788
image_set_hdr_b(os)		/* image_set_os */
image_set_hdr_b(arch)		/* image_set_arch */
image_set_hdr_b(type)		/* image_set_type */
image_set_hdr_b(comp)		/* image_set_comp */
789

790
static inline void image_set_name(image_header_t *hdr, const char *name)
791
{
792
	strncpy(image_get_name(hdr), name, IH_NMLEN);
793 794
}

795 796
int image_check_hcrc(const image_header_t *hdr);
int image_check_dcrc(const image_header_t *hdr);
797
#ifndef USE_HOSTCC
798 799 800
ulong env_get_bootm_low(void);
phys_size_t env_get_bootm_size(void);
phys_size_t env_get_bootm_mapsize(void);
801
#endif
802
void memmove_wd(void *to, void *from, size_t len, ulong chunksz);
803

804
static inline int image_check_magic(const image_header_t *hdr)
805
{
806
	return (image_get_magic(hdr) == IH_MAGIC);
807
}
808
static inline int image_check_type(const image_header_t *hdr, uint8_t type)
809
{
810
	return (image_get_type(hdr) == type);
811
}
812
static inline int image_check_arch(const image_header_t *hdr, uint8_t arch)
813
{
814 815
	return (image_get_arch(hdr) == arch) ||
		(image_get_arch(hdr) == IH_ARCH_ARM && arch == IH_ARCH_ARM64);
816
}
817
static inline int image_check_os(const image_header_t *hdr, uint8_t os)
818
{
819
	return (image_get_os(hdr) == os);
820 821
}

822 823
ulong image_multi_count(const image_header_t *hdr);
void image_multi_getimg(const image_header_t *hdr, ulong idx,
824 825
			ulong *data, ulong *len);

826
void image_print_contents(const void *hdr);
827

828
#ifndef USE_HOSTCC
829
static inline int image_check_target_arch(const image_header_t *hdr)
830
{
831 832
#ifndef IH_ARCH_DEFAULT
# error "please define IH_ARCH_DEFAULT in your arch asm/u-boot.h"
833
#endif
834
	return image_check_arch(hdr, IH_ARCH_DEFAULT);
835
}
836
#endif /* USE_HOSTCC */
wdenk's avatar
wdenk committed
837

838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862
/**
 * Set up properties in the FDT
 *
 * This sets up properties in the FDT that is to be passed to linux.
 *
 * @images:	Images information
 * @blob:	FDT to update
 * @of_size:	Size of the FDT
 * @lmb:	Points to logical memory block structure
 * @return 0 if ok, <0 on failure
 */
int image_setup_libfdt(bootm_headers_t *images, void *blob,
		       int of_size, struct lmb *lmb);

/**
 * Set up the FDT to use for booting a kernel
 *
 * This performs ramdisk setup, sets up the FDT if required, and adds
 * paramters to the FDT if libfdt is available.
 *
 * @param images	Images information
 * @return 0 if ok, <0 on failure
 */
int image_setup_linux(bootm_headers_t *images);

863 864 865 866 867 868 869 870 871 872 873
/**
 * bootz_setup() - Extract stat and size of a Linux xImage
 *
 * @image: Address of image
 * @start: Returns start address of image
 * @end : Returns end address of image
 * @return 0 if OK, 1 if the image was not recognised
 */
int bootz_setup(ulong image, ulong *start, ulong *end);


874
/*******************************************************************/
875
/* New uImage format specific code (prefixed with fit_) */
876
/*******************************************************************/
877 878 879 880

#define FIT_IMAGES_PATH		"/images"
#define FIT_CONFS_PATH		"/configurations"

881
/* hash/signature node */
882 883 884
#define FIT_HASH_NODENAME	"hash"
#define FIT_ALGO_PROP		"algo"
#define FIT_VALUE_PROP		"value"
885
#define FIT_IGNORE_PROP		"uboot-ignore"
886
#define FIT_SIG_NODENAME	"signature"
887 888 889

/* image node */
#define FIT_DATA_PROP		"data"
890 891
#define FIT_DATA_OFFSET_PROP	"data-offset"
#define FIT_DATA_SIZE_PROP	"data-size"
892 893 894 895 896 897 898 899 900 901 902 903 904
#define FIT_TIMESTAMP_PROP	"timestamp"
#define FIT_DESC_PROP		"description"
#define FIT_ARCH_PROP		"arch"
#define FIT_TYPE_PROP		"type"
#define FIT_OS_PROP		"os"
#define FIT_COMP_PROP		"compression"
#define FIT_ENTRY_PROP		"entry"
#define FIT_LOAD_PROP		"load"

/* configuration node */
#define FIT_KERNEL_PROP		"kernel"
#define FIT_RAMDISK_PROP	"ramdisk"
#define FIT_FDT_PROP		"fdt"
905
#define FIT_LOADABLE_PROP	"loadables"
906
#define FIT_DEFAULT_PROP	"default"
907
#define FIT_SETUP_PROP		"setup"
908
#define FIT_FPGA_PROP		"fpga"
909

910
#define FIT_MAX_HASH_LEN	HASH_MAX_DIGEST_SIZE
911

912
#if IMAGE_ENABLE_FIT
913
/* cmdline argument format parsing */
914
int fit_parse_conf(const char *spec, ulong addr_curr,
915
		ulong *addr, const char **conf_name);
916
int fit_parse_subimage(const char *spec, ulong addr_curr,
917
		ulong *addr, const char **image_name);
918

919
int fit_get_subimage_count(const void *fit, int images_noffset);
920 921
void fit_print_contents(const void *fit);
void fit_image_print(const void *fit, int noffset, const char *p);
922 923 924 925 926 927 928 929

/**
 * fit_get_end - get FIT image size
 * @fit: pointer to the FIT format image header
 *
 * returns:
 *     size of the FIT image (blob) in memory
 */
930
static inline ulong fit_get_size(const void *fit)
931
{
932
	return fdt_totalsize(fit);
933 934 935 936 937 938 939 940 941
}

/**
 * fit_get_end - get FIT image end
 * @fit: pointer to the FIT format image header
 *
 * returns:
 *     end address of the FIT image (blob) in memory
 */
942
ulong fit_get_end(const void *fit);
943 944 945 946 947 948 949 950 951

/**
 * fit_get_name - get FIT node name
 * @fit: pointer to the FIT format image header
 *
 * returns:
 *     NULL, on error
 *     pointer to node name, on success
 */
952
static inline const char *fit_get_name(const void *fit_hdr,
953 954
		int noffset, int *len)
{
955
	return fdt_get_name(fit_hdr, noffset, len);
956 957
}

958 959 960 961 962 963 964 965 966 967 968
int fit_get_desc(const void *fit, int noffset, char **desc);
int fit_get_timestamp(const void *fit, int noffset, time_t *timestamp);

int fit_image_get_node(const void *fit, const char *image_uname);
int fit_image_get_os(const void *fit, int noffset, uint8_t *os);
int fit_image_get_arch(const void *fit, int noffset, uint8_t *arch);
int fit_image_get_type(const void *fit, int noffset, uint8_t *type);
int fit_image_get_comp(const void *fit, int noffset, uint8_t *comp);
int fit_image_get_load(const void *fit, int noffset, ulong *load);
int fit_image_get_entry(const void *fit, int noffset, ulong *entry);
int fit_image_get_data(const void *fit, int noffset,
969
				const void **data, size_t *size);
970 971
int fit_image_get_data_offset(const void *fit, int noffset, int *data_offset);
int fit_image_get_data_size(const void *fit, int noffset, int *data_size);
972

973 974
int fit_image_hash_get_algo(const void *fit, int noffset, char **algo);
int fit_image_hash_get_value(const void *fit, int noffset, uint8_t **value,
975 976
				int *value_len);

977
int fit_set_timestamp(void *fit, int noffset, time_t timestamp);
978 979

/**
980
 * fit_add_verification_data() - add verification data to FIT image nodes
981
 *
982 983 984 985 986
 * @keydir:	Directory containing keys
 * @kwydest:	FDT blob to write public key information to
 * @fit:	Pointer to the FIT format image header
 * @comment:	Comment to add to signature nodes
 * @require_keys: Mark all keys as 'required'
987
 * @engine_id:	Engine to use for signing
988 989 990 991 992 993 994 995 996 997
 *
 * Adds hash values for all component images in the FIT blob.
 * Hashes are calculated for all component images which have hash subnodes
 * with algorithm property set to one of the supported hash algorithms.
 *
 * Also add signatures if signature nodes are present.
 *
 * returns
 *     0, on success
 *     libfdt error code, on failure
998
 */
999
int fit_add_verification_data(const char *keydir, void *keydest, void *fit,
1000 1001
			      const char *comment, int require_keys,
			      const char *engine_id);
1002

1003
int fit_image_verify(const void *fit, int noffset);
1004
int fit_config_verify(const void *fit, int conf_noffset);
1005
int fit_all_image_verify(const void *fit);
1006 1007 1008 1009 1010
int fit_image_check_os(const void *fit, int noffset, uint8_t os);
int fit_image_check_arch(const void *fit, int noffset, uint8_t arch);
int fit_image_check_type(const void *fit, int noffset, uint8_t type);
int fit_image_check_comp(const void *fit, int noffset, uint8_t comp);
int fit_check_format(const void *fit);
1011

1012
int fit_conf_find_compat(const void *fit, const void *fdt);
1013
int fit_conf_get_node(const void *fit, const char *conf_uname);
1014

1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028
/**
 * fit_conf_get_prop_node() - Get node refered to by a configuration
 * @fit:	FIT to check
 * @noffset:	Offset of conf@xxx node to check
 * @prop_name:	Property to read from the conf node
 *
 * The conf@ nodes contain references to other nodes, using properties
 * like 'kernel = "kernel@1"'. Given such a property name (e.g. "kernel"),
 * return the offset of the node referred to (e.g. offset of node
 * "/images/kernel@1".
 */
int fit_conf_get_prop_node(const void *fit, int noffset,
		const char *prop_name);

1029
void fit_conf_print(const void *fit, int noffset, const char *p);
1030

1031 1032 1033
int fit_check_ramdisk(const void *fit, int os_noffset,
		uint8_t arch, int verify);

1034 1035 1036
int calculate_hash(const void *data, int data_len, const char *algo,
			uint8_t *value, int *value_len);

1037
/*
1038 1039
 * At present we only support signing on the host, and verification on the
 * device
1040 1041 1042
 */
#if defined(CONFIG_FIT_SIGNATURE)
# ifdef USE_HOSTCC
1043
#  define IMAGE_ENABLE_SIGN	1
1044
#  define IMAGE_ENABLE_VERIFY	1
1045
# include  <openssl/evp.h>
1046
#else
1047
#  define IMAGE_ENABLE_SIGN	0
1048 1049 1050
#  define IMAGE_ENABLE_VERIFY	1
# endif
#else
1051
# define IMAGE_ENABLE_SIGN	0
1052 1053 1054 1055
# define IMAGE_ENABLE_VERIFY	0
#endif

#ifdef USE_HOSTCC
1056 1057 1058
void *image_get_host_blob(void);
void image_set_host_blob(void *host_blob);
# define gd_fdt_blob()		image_get_host_blob()
1059 1060 1061 1062 1063 1064 1065 1066 1067 1068
#else
# define gd_fdt_blob()		(gd->fdt_blob)
#endif

#ifdef CONFIG_FIT_BEST_MATCH
#define IMAGE_ENABLE_BEST_MATCH	1
#else
#define IMAGE_ENABLE_BEST_MATCH	0
#endif

1069 1070 1071 1072 1073 1074
/* Information passed to the signing routines */
struct image_sign_info {
	const char *keydir;		/* Directory conaining keys */
	const char *keyname;		/* Name of key to use */
	void *fit;			/* Pointer to FIT blob */
	int node_offset;		/* Offset of signature node */
1075 1076 1077
	const char *name;		/* Algorithm name */
	struct checksum_algo *checksum;	/* Checksum algorithm information */
	struct crypto_algo *crypto;	/* Crypto algorithm information */
1078 1079 1080
	const void *fdt_blob;		/* FDT containing public keys */
	int required_keynode;		/* Node offset of key to use: -1=any */
	const char *require_keys;	/* Value for 'required' property */
1081
	const char *engine_id;		/* Engine to use for signing */
1082
};
1083
#endif /* Allow struct image_region to always be defined for rsa.h */
1084 1085 1086 1087 1088 1089 1090

/* A part of an image, used for hashing */
struct image_region {
	const void *data;
	int size;
};

1091 1092
#if IMAGE_ENABLE_FIT

1093
#if IMAGE_ENABLE_VERIFY
1094
# include <u-boot/rsa-checksum.h>
1095 1096 1097 1098
#endif
struct checksum_algo {
	const char *name;
	const int checksum_len;
1099 1100
	const int der_len;
	const uint8_t *der_prefix;
1101
#if IMAGE_ENABLE_SIGN
1102 1103
	const EVP_MD *(*calculate_sign)(void);
#endif
1104 1105 1106
	int (*calculate)(const char *name,
			 const struct image_region region[],
			 int region_count, uint8_t *checksum);
1107 1108
};

1109
struct crypto_algo {
1110
	const char *name;		/* Name of algorithm */
1111
	const int key_len;
1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159

	/**
	 * sign() - calculate and return signature for given input data
	 *
	 * @info:	Specifies key and FIT information
	 * @data:	Pointer to the input data
	 * @data_len:	Data length
	 * @sigp:	Set to an allocated buffer holding the signature
	 * @sig_len:	Set to length of the calculated hash
	 *
	 * This computes input data signature according to selected algorithm.
	 * Resulting signature value is placed in an allocated buffer, the
	 * pointer is returned as *sigp. The length of the calculated
	 * signature is returned via the sig_len pointer argument. The caller
	 * should free *sigp.
	 *
	 * @return: 0, on success, -ve on error
	 */
	int (*sign)(struct image_sign_info *info,
		    const struct image_region region[],
		    int region_count, uint8_t **sigp, uint *sig_len);

	/**
	 * add_verify_data() - Add verification information to FDT
	 *
	 * Add public key information to the FDT node, suitable for
	 * verification at run-time. The information added depends on the
	 * algorithm being used.
	 *
	 * @info:	Specifies key and FIT information
	 * @keydest:	Destination FDT blob for public key data
	 * @return: 0, on success, -ve on error
	 */
	int (*add_verify_data)(struct image_sign_info *info, void *keydest);

	/**
	 * verify() - Verify a signature against some data
	 *
	 * @info:	Specifies key and FIT information
	 * @data:	Pointer to the input data
	 * @data_len:	Data length
	 * @sig:	Signature
	 * @sig_len:	Number of bytes in signature
	 * @return 0 if verified, -ve on error
	 */
	int (*verify)(struct image_sign_info *info,
		      const struct image_region region[], int region_count,
		      uint8_t *sig, uint sig_len);
1160
};
1161

1162 1163 1164 1165 1166 1167 1168
/**
 * image_get_checksum_algo() - Look up a checksum algorithm
 *
 * @param full_name	Name of algorithm in the form "checksum,crypto"
 * @return pointer to algorithm information, or NULL if not found
 */
struct checksum_algo *image_get_checksum_algo(const char *full_name);
1169 1170

/**
1171
 * image_get_crypto_algo() - Look up a cryptosystem algorithm
1172
 *
1173
 * @param full_name	Name of algorithm in the form "checksum,crypto"
1174 1175
 * @return pointer to algorithm information, or NULL if not found
 */
1176
struct crypto_algo *image_get_crypto_algo(const char *full_name);
1177

1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213
/**
 * fit_image_verify_required_sigs() - Verify signatures marked as 'required'
 *
 * @fit:		FIT to check
 * @image_noffset:	Offset of image node to check
 * @data:		Image data to check
 * @size:		Size of image data
 * @sig_blob:		FDT containing public keys
 * @no_sigsp:		Returns 1 if no signatures were required, and
 *			therefore nothing was checked. The caller may wish
 *			to fall back to other mechanisms, or refuse to
 *			boot.
 * @return 0 if all verified ok, <0 on error
 */
int fit_image_verify_required_sigs(const void *fit, int image_noffset,
		const char *data, size_t size, const void *sig_blob,
		int *no_sigsp);

/**
 * fit_image_check_sig() - Check a single image signature node
 *
 * @fit:		FIT to check
 * @noffset:		Offset of signature node to check
 * @data:		Image data to check
 * @size:		Size of image data
 * @required_keynode:	Offset in the control FDT of the required key node,
 *			if any. If this is given, then the image wil not
 *			pass verification unless that key is used. If this is
 *			-1 then any signature will do.
 * @err_msgp:		In the event of an error, this will be pointed to a
 *			help error string to display to the user.
 * @return 0 if all verified ok, <0 on error
 */
int fit_image_check_sig(const void *fit, int noffset, const void *data,
		size_t size, int required_keynode, char **err_msgp);

1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229
/**
 * fit_region_make_list() - Make a list of regions to hash
 *
 * Given a list of FIT regions (offset, size) provided by libfdt, create
 * a list of regions (void *, size) for use by the signature creationg
 * and verification code.
 *
 * @fit:		FIT image to process
 * @fdt_regions:	Regions as returned by libfdt
 * @count:		Number of regions returned by libfdt
 * @region:		Place to put list of regions (NULL to allocate it)
 * @return pointer to list of regions, or NULL if out of memory
 */
struct image_region *fit_region_make_list(const void *fit,
		struct fdt_region *fdt_regions, int count,
		struct image_region *region);
1230

1231
static inline int fit_image_check_target_arch(const void *fdt, int node)
1232
{
1233
#ifndef USE_HOSTCC
1234
	return fit_image_check_arch(fdt, node, IH_ARCH_DEFAULT);
1235 1236 1237
#else
	return 0;
#endif
1238 1239
}

1240
#ifdef CONFIG_FIT_VERBOSE
1241
#define fit_unsupported(msg)	printf("! %s:%d " \
1242 1243 1244
				"FIT images not supported for '%s'\n", \
				__FILE__, __LINE__, (msg))

1245
#define fit_unsupported_reset(msg)	printf("! %s:%d " \
1246 1247 1248 1249 1250 1251 1252
				"FIT images not supported for '%s' " \
				"- must reset board to recover!\n", \
				__FILE__, __LINE__, (msg))
#else
#define fit_unsupported(msg)
#define fit_unsupported_reset(msg)
#endif /* CONFIG_FIT_VERBOSE */
1253
#endif /* CONFIG_FIT */
1254

1255 1256 1257 1258 1259 1260 1261 1262 1263
#if defined(CONFIG_ANDROID_BOOT_IMAGE)
struct andr_img_hdr;
int android_image_check_header(const struct andr_img_hdr *hdr);
int android_image_get_kernel(const struct andr_img_hdr *hdr, int verify,
			     ulong *os_data, ulong *os_len);
int android_image_get_ramdisk(const struct andr_img_hdr *hdr,
			      ulong *rd_data, ulong *rd_len);
ulong android_image_get_end(const struct andr_img_hdr *hdr);
ulong android_image_get_kload(const struct andr_img_hdr *hdr);
1264
void android_print_contents(const struct andr_img_hdr *hdr);
1265 1266 1267

#endif /* CONFIG_ANDROID_BOOT_IMAGE */

1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280
/**
 * board_fit_config_name_match() - Check for a matching board name
 *
 * This is used when SPL loads a FIT containing multiple device tree files
 * and wants to work out which one to use. The description of each one is
 * passed to this function. The description comes from the 'description' field
 * in each (FDT) image node.
 *
 * @name: Device tree description
 * @return 0 if this device tree should be used, non-zero to try the next
 */
int board_fit_config_name_match(const char *name);

1281 1282
#if defined(CONFIG_SPL_FIT_IMAGE_POST_PROCESS) || \
	defined(CONFIG_FIT_IMAGE_POST_PROCESS)
1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298
/**
 * board_fit_image_post_process() - Do any post-process on FIT binary data
 *
 * This is used to do any sort of image manipulation, verification, decryption
 * etc. in a platform or board specific way. Obviously, anything done here would
 * need to be comprehended in how the images were prepared before being injected
 * into the FIT creation (i.e. the binary blobs would have been pre-processed
 * before being added to the FIT image).
 *
 * @image: pointer to the image start pointer
 * @size: pointer to the image size
 * @return no return value (failure should be handled internally)
 */
void board_fit_image_post_process(void **p_image, size_t *p_size);
#endif /* CONFIG_SPL_FIT_IMAGE_POST_PROCESS */

1299 1300
#define FDT_ERROR	((ulong)(-1))

1301
ulong fdt_getprop_u32(const void *fdt, int node, const char *prop);
1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314

/**
 * fit_find_config_node() - Find the node for the best DTB in a FIT image
 *
 * A FIT image contains one or more DTBs. This function parses the
 * configurations described in the FIT images and returns the node of
 * the first matching DTB. To check if a DTB matches a board, this function
 * calls board_fit_config_name_match(). If no matching DTB is found, it returns
 * the node described by the default configuration if it exists.
 *
 * @fdt: pointer to flat device tree
 * @return the node if found, -ve otherwise
 */
1315 1316
int fit_find_config_node(const void *fdt);

1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346
/**
 * Mapping of image types to function handlers to be invoked on the associated
 * loaded images
 *
 * @type: Type of image, I.E. IH_TYPE_*
 * @handler: Function to call on loaded image
 */
struct fit_loadable_tbl {
	int type;
	/**
	 * handler() - Process a loaded image
	 *
	 * @data: Pointer to start of loaded image data
	 * @size: Size of loaded image data
	 */
	void (*handler)(ulong data, size_t size);
};

/*
 * Define a FIT loadable image type handler
 *
 * _type is a valid uimage_type ID as defined in the "Image Type" enum above
 * _handler is the handler function to call after this image type is loaded
 */
#define U_BOOT_FIT_LOADABLE_HANDLER(_type, _handler) \
	ll_entry_declare(struct fit_loadable_tbl, _function, fit_loadable) = { \
		.type = _type, \
		.handler = _handler, \
	}

1347
#endif	/* __IMAGE_H__ */