image.h 40.4 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"
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

33
#define IMAGE_ENABLE_IGNORE	0
34
#define IMAGE_INDENT_STRING	""
35

36 37 38 39
#else

#include <lmb.h>
#include <asm/u-boot.h>
40
#include <command.h>
41

42 43
/* Take notice of the 'ignore' property for hashes */
#define IMAGE_ENABLE_IGNORE	1
44
#define IMAGE_INDENT_STRING	"   "
45

46 47
#define IMAGE_ENABLE_FIT	CONFIG_IS_ENABLED(FIT)
#define IMAGE_ENABLE_OF_LIBFDT	CONFIG_IS_ENABLED(OF_LIBFDT)
48

49
#endif /* USE_HOSTCC */
50

51
#if IMAGE_ENABLE_FIT
52
#include <hash.h>
53 54
#include <libfdt.h>
#include <fdt_support.h>
55
# ifdef CONFIG_SPL_BUILD
56 57 58 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
#  ifdef CONFIG_SPL_SHA256_SUPPORT
#   define IMAGE_ENABLE_SHA256	1
#  endif
68 69 70 71
# else
#  define CONFIG_CRC32		/* FIT images need CRC32 support */
#  define CONFIG_MD5		/* and MD5 */
#  define CONFIG_SHA1		/* and SHA1 */
Heiko Schocher's avatar
Heiko Schocher committed
72
#  define CONFIG_SHA256		/* and SHA256 */
73 74 75
#  define IMAGE_ENABLE_CRC32	1
#  define IMAGE_ENABLE_MD5	1
#  define IMAGE_ENABLE_SHA1	1
Heiko Schocher's avatar
Heiko Schocher committed
76
#  define IMAGE_ENABLE_SHA256	1
77
# endif
78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99

#ifdef CONFIG_FIT_DISABLE_SHA256
#undef CONFIG_SHA256
#undef IMAGE_ENABLE_SHA256
#endif

#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

#ifndef IMAGE_ENABLE_SHA256
#define IMAGE_ENABLE_SHA256	0
#endif

100
#endif /* IMAGE_ENABLE_FIT */
101

102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124
#ifdef CONFIG_SYS_BOOT_RAMDISK_HIGH
# define IMAGE_ENABLE_RAMDISK_HIGH	1
#else
# define IMAGE_ENABLE_RAMDISK_HIGH	0
#endif

#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
125

126 127 128 129 130 131 132 133 134
enum ih_category {
	IH_ARCH,
	IH_COMP,
	IH_OS,
	IH_TYPE,

	IH_COUNT,
};

wdenk's avatar
wdenk committed
135 136
/*
 * Operating System Codes
137 138 139
 *
 * The following are exposed to uImage header.
 * Do not change values for backward compatibility.
wdenk's avatar
wdenk committed
140
 */
141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169
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	*/

	IH_OS_COUNT,
};
wdenk's avatar
wdenk committed
170 171 172

/*
 * CPU Architecture Codes (supported by Linux)
173 174 175
 *
 * The following are exposed to uImage header.
 * Do not change values for backward compatibility.
wdenk's avatar
wdenk committed
176
 */
177 178 179 180 181 182 183 184 185 186 187 188 189 190
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		*/
191
	IH_ARCH_NIOS,			/* Nios-32	*/
192 193 194 195 196 197 198 199 200 201 202
	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 */
203
	IH_ARCH_XTENSA,			/* Xtensa	*/
204 205 206

	IH_ARCH_COUNT,
};
wdenk's avatar
wdenk committed
207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234

/*
 * 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
235
 *	a multiple of 4 bytes - except for the last file).
wdenk's avatar
wdenk committed
236 237 238 239 240 241 242 243
 *
 * "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)
244
 *	as command interpreter (=> Shell Scripts).
245 246 247
 *
 * The following are exposed to uImage header.
 * Do not change values for backward compatibility.
wdenk's avatar
wdenk committed
248 249
 */

250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280
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 */
281
	IH_TYPE_VYBRIDIMAGE,	/* VYBRID .vyb Image */
282 283 284

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

wdenk's avatar
wdenk committed
286 287
/*
 * Compression Types
288 289 290
 *
 * The following are exposed to uImage header.
 * Do not change values for backward compatibility.
wdenk's avatar
wdenk committed
291
 */
292 293 294 295 296 297 298 299 300 301
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
302 303 304 305

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

306 307 308
/* Reused from common.h */
#define ROUND(a, b)		(((a) + (b) - 1) & ~((b) - 1))

wdenk's avatar
wdenk committed
309
/*
310 311
 * Legacy format image header,
 * all data in network byte order (aka natural aka bigendian).
wdenk's avatar
wdenk committed
312 313
 */
typedef struct image_header {
314 315 316 317 318 319 320
	__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
321 322 323 324 325 326 327
	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;

328 329 330 331 332
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 */
333
	uint8_t		arch;			/* CPU architecture */
334 335
} image_info_t;

336 337 338 339 340 341 342
/*
 * 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
343
	 * then boot_get_ramdisk() and get_fdt() will attempt to get
344 345
	 * data from second and third component accordingly.
	 */
346 347
	image_header_t	*legacy_hdr_os;		/* image header pointer */
	image_header_t	legacy_hdr_os_copy;	/* header copy */
348 349
	ulong		legacy_hdr_valid;

350
#if IMAGE_ENABLE_FIT
351 352
	const char	*fit_uname_cfg;	/* configuration node unit name */

353
	void		*fit_hdr_os;	/* os FIT image header */
354
	const char	*fit_uname_os;	/* os subimage node unit name */
355
	int		fit_noffset_os;	/* os subimage node offset */
356 357

	void		*fit_hdr_rd;	/* init ramdisk FIT image header */
358 359
	const char	*fit_uname_rd;	/* init ramdisk subimage node unit name */
	int		fit_noffset_rd;	/* init ramdisk subimage node offset */
360 361

	void		*fit_hdr_fdt;	/* FDT blob FIT image header */
362 363
	const char	*fit_uname_fdt;	/* FDT blob subimage node unit name */
	int		fit_noffset_fdt;/* FDT blob subimage node offset */
364 365 366 367

	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 */
368
#endif
369

Kumar Gala's avatar
Kumar Gala committed
370
#ifndef USE_HOSTCC
371
	image_info_t	os;		/* os image info */
372 373
	ulong		ep;		/* entry point of OS */

374 375
	ulong		rd_start, rd_end;/* ramdisk start/end */

376 377 378
	char		*ft_addr;	/* flat dev tree address */
	ulong		ft_len;		/* length of flat device tree */

Kumar Gala's avatar
Kumar Gala committed
379 380 381 382 383 384 385
	ulong		initrd_start;
	ulong		initrd_end;
	ulong		cmdline_start;
	ulong		cmdline_end;
	bd_t		*kbd;
#endif

386
	int		verify;		/* getenv("verify")[0] != 'n' */
Kumar Gala's avatar
Kumar Gala committed
387 388

#define	BOOTM_STATE_START	(0x00000001)
389 390 391 392 393 394 395 396
#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)
397 398
#define	BOOTM_STATE_OS_FAKE_GO	(0x00000200)	/* 'Almost' run the OS */
#define	BOOTM_STATE_OS_GO	(0x00000400)
Kumar Gala's avatar
Kumar Gala committed
399 400
	int		state;

401
#ifdef CONFIG_LMB
402 403
	struct lmb	lmb;		/* for memory mgmt */
#endif
404 405
} bootm_headers_t;

Simon Schwarz's avatar
Simon Schwarz committed
406 407
extern bootm_headers_t images;

408 409 410
/*
 * Some systems (for example LWMON) have very short watchdog periods;
 * we must make sure to split long operations like memmove() or
411
 * checksum calculations into reasonable chunks.
412
 */
413
#ifndef CHUNKSZ
414
#define CHUNKSZ (64 * 1024)
415 416 417 418 419 420 421 422 423 424 425 426 427
#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
428

429 430
#define uimage_to_cpu(x)		be32_to_cpu(x)
#define cpu_to_uimage(x)		cpu_to_be32(x)
431

432 433 434 435 436 437 438 439 440 441 442 443 444 445 446
/*
 * 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.
 */
447
int get_table_entry_id(const table_entry_t *table,
448 449 450 451 452 453
		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.
 */
454
char *get_table_entry_name(const table_entry_t *table, char *msg, int id);
455

456
const char *genimg_get_os_name(uint8_t os);
457 458 459 460 461 462 463 464 465

/**
 * 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);

466
const char *genimg_get_arch_name(uint8_t arch);
467 468 469 470 471 472 473 474 475

/**
 * 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);

476
const char *genimg_get_type_name(uint8_t type);
477 478 479 480 481 482 483 484 485

/**
 * 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);

486
const char *genimg_get_comp_name(uint8_t comp);
487 488 489 490 491 492 493 494 495

/**
 * 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);

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 522 523 524 525 526 527 528 529
/**
 * 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);

530 531 532 533 534
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);
535

536 537 538 539 540 541 542 543
#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);

544 545 546 547
/* 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 */
548
	FIT_LOAD_OPTIONAL_NON_ZERO,	/* Optional, a value of 0 is ignored */
549 550 551
	FIT_LOAD_REQUIRED,	/* Must be provided */
};

552 553 554
int boot_get_setup(bootm_headers_t *images, uint8_t arch, ulong *setup_start,
		   ulong *setup_len);

555 556 557
#ifndef USE_HOSTCC
/* Image format types, returned by _get_format() routine */
#define IMAGE_FORMAT_INVALID	0x00
558
#if defined(CONFIG_IMAGE_FORMAT_LEGACY)
559
#define IMAGE_FORMAT_LEGACY	0x01	/* legacy image_header based format */
560
#endif
561
#define IMAGE_FORMAT_FIT	0x02	/* new, libfdt based format */
562
#define IMAGE_FORMAT_ANDROID	0x03	/* Android boot image */
563

564 565 566
ulong genimg_get_kernel_addr_fit(char * const img_addr,
			         const char **fit_uname_config,
			         const char **fit_uname_kernel);
567
ulong genimg_get_kernel_addr(char * const img_addr);
568
int genimg_get_format(const void *img_addr);
569 570
int genimg_has_config(bootm_headers_t *images);
ulong genimg_get_image(ulong img_addr);
571

572 573
int boot_get_fpga(int argc, char * const argv[], bootm_headers_t *images,
		uint8_t arch, const ulong *ld_start, ulong * const ld_len);
574
int boot_get_ramdisk(int argc, char * const argv[], bootm_headers_t *images,
575
		uint8_t arch, ulong *rd_start, ulong *rd_end);
576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600

/**
 * 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 */
601

602 603 604
int boot_get_setup_fit(bootm_headers_t *images, uint8_t arch,
		       ulong *setup_start, ulong *setup_len);

605 606 607 608 609 610 611 612
/**
 * 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.
 *
613 614
 * The property to look up is defined by image_type.
 *
615 616 617 618 619
 * @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
620 621 622
 * @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.
623 624 625 626 627 628 629 630 631 632
 * @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
633
 * @return node offset of image, or -ve error code on error
634
 */
635
int fit_image_load(bootm_headers_t *images, ulong addr,
636
		   const char **fit_unamep, const char **fit_uname_configp,
637 638 639
		   int arch, int image_type, int bootstage_id,
		   enum fit_load_op load_op, ulong *datap, ulong *lenp);

640
#ifndef USE_HOSTCC
641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670
/**
 * 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);

671 672 673
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);
674
void boot_fdt_add_mem_rsv_regions(struct lmb *lmb, void *fdt_blob);
675
int boot_relocate_fdt(struct lmb *lmb, char **of_flat_tree, ulong *of_size);
676

677
int boot_ramdisk_high(struct lmb *lmb, ulong rd_data, ulong rd_len,
678
		  ulong *initrd_start, ulong *initrd_end);
679
int boot_get_cmdline(struct lmb *lmb, ulong *cmd_start, ulong *cmd_end);
680
#ifdef CONFIG_SYS_BOOT_GET_KBD
681
int boot_get_kbd(struct lmb *lmb, bd_t **kbd);
682
#endif /* CONFIG_SYS_BOOT_GET_KBD */
683
#endif /* !USE_HOSTCC */
684

685 686 687
/*******************************************************************/
/* Legacy format specific code (prefixed with image_) */
/*******************************************************************/
688
static inline uint32_t image_get_header_size(void)
689
{
690
	return (sizeof(image_header_t));
691 692 693
}

#define image_get_hdr_l(f) \
694
	static inline uint32_t image_get_##f(const image_header_t *hdr) \
695
	{ \
696
		return uimage_to_cpu(hdr->ih_##f); \
697
	}
698 699 700 701 702 703 704
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 */
705 706

#define image_get_hdr_b(f) \
707
	static inline uint8_t image_get_##f(const image_header_t *hdr) \
708 709 710
	{ \
		return hdr->ih_##f; \
	}
711 712 713 714
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 */
715

716
static inline char *image_get_name(const image_header_t *hdr)
717 718 719 720
{
	return (char *)hdr->ih_name;
}

721
static inline uint32_t image_get_data_size(const image_header_t *hdr)
722
{
723
	return image_get_size(hdr);
724
}
725 726 727 728 729 730 731 732 733 734 735 736

/**
 * 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
 */
737
static inline ulong image_get_data(const image_header_t *hdr)
738
{
739
	return ((ulong)hdr + image_get_header_size());
740 741
}

742
static inline uint32_t image_get_image_size(const image_header_t *hdr)
743
{
744
	return (image_get_size(hdr) + image_get_header_size());
745
}
746
static inline ulong image_get_image_end(const image_header_t *hdr)
747
{
748
	return ((ulong)hdr + image_get_image_size(hdr));
749 750 751 752 753
}

#define image_set_hdr_l(f) \
	static inline void image_set_##f(image_header_t *hdr, uint32_t val) \
	{ \
754
		hdr->ih_##f = cpu_to_uimage(val); \
755
	}
756 757 758 759 760 761 762
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 */
763 764 765 766 767 768

#define image_set_hdr_b(f) \
	static inline void image_set_##f(image_header_t *hdr, uint8_t val) \
	{ \
		hdr->ih_##f = val; \
	}
769 770 771 772
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 */
773

774
static inline void image_set_name(image_header_t *hdr, const char *name)
775
{
776
	strncpy(image_get_name(hdr), name, IH_NMLEN);
777 778
}

779 780
int image_check_hcrc(const image_header_t *hdr);
int image_check_dcrc(const image_header_t *hdr);
781
#ifndef USE_HOSTCC
782
ulong getenv_bootm_low(void);
783
phys_size_t getenv_bootm_size(void);
784
phys_size_t getenv_bootm_mapsize(void);
785
#endif
786
void memmove_wd(void *to, void *from, size_t len, ulong chunksz);
787

788
static inline int image_check_magic(const image_header_t *hdr)
789
{
790
	return (image_get_magic(hdr) == IH_MAGIC);
791
}
792
static inline int image_check_type(const image_header_t *hdr, uint8_t type)
793
{
794
	return (image_get_type(hdr) == type);
795
}
796
static inline int image_check_arch(const image_header_t *hdr, uint8_t arch)
797
{
798
	return (image_get_arch(hdr) == arch);
799
}
800
static inline int image_check_os(const image_header_t *hdr, uint8_t os)
801
{
802
	return (image_get_os(hdr) == os);
803 804
}

805 806
ulong image_multi_count(const image_header_t *hdr);
void image_multi_getimg(const image_header_t *hdr, ulong idx,
807 808
			ulong *data, ulong *len);

809
void image_print_contents(const void *hdr);
810

811
#ifndef USE_HOSTCC
812
static inline int image_check_target_arch(const image_header_t *hdr)
813
{
814 815
#ifndef IH_ARCH_DEFAULT
# error "please define IH_ARCH_DEFAULT in your arch asm/u-boot.h"
816
#endif
817
	return image_check_arch(hdr, IH_ARCH_DEFAULT);
818
}
819
#endif /* USE_HOSTCC */
wdenk's avatar
wdenk committed
820

821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845
/**
 * 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);

846 847 848 849 850 851 852 853 854 855 856
/**
 * 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);


857
/*******************************************************************/
858
/* New uImage format specific code (prefixed with fit_) */
859
/*******************************************************************/
860 861 862 863

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

864
/* hash/signature node */
865 866 867
#define FIT_HASH_NODENAME	"hash"
#define FIT_ALGO_PROP		"algo"
#define FIT_VALUE_PROP		"value"
868
#define FIT_IGNORE_PROP		"uboot-ignore"
869
#define FIT_SIG_NODENAME	"signature"
870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885

/* image node */
#define FIT_DATA_PROP		"data"
#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"
886
#define FIT_LOADABLE_PROP	"loadables"
887
#define FIT_DEFAULT_PROP	"default"
888
#define FIT_SETUP_PROP		"setup"
889
#define FIT_FPGA_PROP		"fpga"
890

891
#define FIT_MAX_HASH_LEN	HASH_MAX_DIGEST_SIZE
892

893
#if IMAGE_ENABLE_FIT
894
/* cmdline argument format parsing */
895
int fit_parse_conf(const char *spec, ulong addr_curr,
896
		ulong *addr, const char **conf_name);
897
int fit_parse_subimage(const char *spec, ulong addr_curr,
898
		ulong *addr, const char **image_name);
899

900
int fit_get_subimage_count(const void *fit, int images_noffset);
901 902
void fit_print_contents(const void *fit);
void fit_image_print(const void *fit, int noffset, const char *p);
903 904 905 906 907 908 909 910

/**
 * fit_get_end - get FIT image size
 * @fit: pointer to the FIT format image header
 *
 * returns:
 *     size of the FIT image (blob) in memory
 */
911
static inline ulong fit_get_size(const void *fit)
912
{
913
	return fdt_totalsize(fit);
914 915 916 917 918 919 920 921 922
}

/**
 * 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
 */
923
ulong fit_get_end(const void *fit);
924 925 926 927 928 929 930 931 932

/**
 * 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
 */
933
static inline const char *fit_get_name(const void *fit_hdr,
934 935
		int noffset, int *len)
{
936
	return fdt_get_name(fit_hdr, noffset, len);
937 938
}

939 940 941 942 943 944 945 946 947 948 949
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,
950 951
				const void **data, size_t *size);

952 953
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,
954 955
				int *value_len);

956
int fit_set_timestamp(void *fit, int noffset, time_t timestamp);
957 958

/**
959
 * fit_add_verification_data() - add verification data to FIT image nodes
960
 *
961 962 963 964 965 966 967 968 969 970 971 972 973 974 975
 * @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'
 *
 * 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
976
 */
977 978
int fit_add_verification_data(const char *keydir, void *keydest, void *fit,
			      const char *comment, int require_keys);
979

980
int fit_image_verify(const void *fit, int noffset);
981
int fit_config_verify(const void *fit, int conf_noffset);
982
int fit_all_image_verify(const void *fit);
983 984 985 986 987
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);
988

989
int fit_conf_find_compat(const void *fit, const void *fdt);
990
int fit_conf_get_node(const void *fit, const char *conf_uname);
991

992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005
/**
 * 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);

1006
void fit_conf_print(const void *fit, int noffset, const char *p);
1007

1008 1009 1010
int fit_check_ramdisk(const void *fit, int os_noffset,
		uint8_t arch, int verify);

1011 1012 1013
int calculate_hash(const void *data, int data_len, const char *algo,
			uint8_t *value, int *value_len);

1014
/*
1015 1016
 * At present we only support signing on the host, and verification on the
 * device
1017 1018 1019
 */
#if defined(CONFIG_FIT_SIGNATURE)
# ifdef USE_HOSTCC
1020
#  define IMAGE_ENABLE_SIGN	1
1021
#  define IMAGE_ENABLE_VERIFY	1
1022
# include  <openssl/evp.h>
1023
#else
1024
#  define IMAGE_ENABLE_SIGN	0
1025 1026 1027
#  define IMAGE_ENABLE_VERIFY	1
# endif
#else
1028
# define IMAGE_ENABLE_SIGN	0
1029 1030 1031 1032
# define IMAGE_ENABLE_VERIFY	0
#endif

#ifdef USE_HOSTCC
1033 1034 1035
void *image_get_host_blob(void);
void image_set_host_blob(void *host_blob);
# define gd_fdt_blob()		image_get_host_blob()
1036 1037 1038 1039 1040 1041 1042 1043 1044 1045
#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

1046 1047 1048 1049 1050 1051
/* 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 */
1052 1053 1054
	const char *name;		/* Algorithm name */
	struct checksum_algo *checksum;	/* Checksum algorithm information */
	struct crypto_algo *crypto;	/* Crypto algorithm information */
1055 1056 1057 1058
	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 */
};
1059
#endif /* Allow struct image_region to always be defined for rsa.h */
1060 1061 1062 1063 1064 1065 1066

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

1067 1068
#if IMAGE_ENABLE_FIT

1069
#if IMAGE_ENABLE_VERIFY
1070
# include <u-boot/rsa-checksum.h>
1071 1072 1073 1074
#endif
struct checksum_algo {
	const char *name;
	const int checksum_len;
1075 1076
	const int der_len;
	const uint8_t *der_prefix;
1077
#if IMAGE_ENABLE_SIGN
1078 1079
	const EVP_MD *(*calculate_sign)(void);
#endif
1080 1081 1082
	int (*calculate)(const char *name,
			 const struct image_region region[],
			 int region_count, uint8_t *checksum);
1083 1084
};

1085
struct crypto_algo {
1086
	const char *name;		/* Name of algorithm */
1087
	const int key_len;
1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135

	/**
	 * 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);
1136
};
1137

1138 1139 1140 1141 1142 1143 1144
/**
 * 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);
1145 1146

/**
1147
 * image_get_crypto_algo() - Look up a cryptosystem algorithm
1148
 *
1149
 * @param full_name	Name of algorithm in the form "checksum,crypto"
1150 1151
 * @return pointer to algorithm information, or NULL if not found
 */
1152
struct crypto_algo *image_get_crypto_algo(const char *full_name);
1153

1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189
/**
 * 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);

1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205
/**
 * 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);
1206

1207
static inline int fit_image_check_target_arch(const void *fdt, int node)
1208
{
1209
#ifndef USE_HOSTCC
1210
	return fit_image_check_arch(fdt, node, IH_ARCH_DEFAULT);
1211 1212 1213
#else
	return 0;
#endif
1214 1215
}

1216
#ifdef CONFIG_FIT_VERBOSE
1217
#define fit_unsupported(msg)	printf("! %s:%d " \
1218 1219 1220
				"FIT images not supported for '%s'\n", \
				__FILE__, __LINE__, (msg))

1221
#define fit_unsupported_reset(msg)	printf("! %s:%d " \
1222 1223 1224 1225 1226 1227 1228
				"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 */
1229
#endif /* CONFIG_FIT */
1230

1231 1232 1233 1234 1235 1236 1237 1238 1239
#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);
1240
void android_print_contents(const struct andr_img_hdr *hdr);
1241 1242 1243

#endif /* CONFIG_ANDROID_BOOT_IMAGE */

1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256
/**
 * 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);

1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273
#ifdef CONFIG_SPL_FIT_IMAGE_POST_PROCESS
/**
 * 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 */

1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303
/**
 * 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, \
	}

1304
#endif	/* __IMAGE_H__ */