Eric Lee / smarc-uboot | Embedian Git Server

Commit 39f520bb62be67ef98303c47dd5c2d76861fea0f

Authored by Albert ARIBAUD \(3ADEV\) 2015-03-31 17:40:49 +0800

Committed by Albert ARIBAUD 2015-04-10 20:23:26 +0800

Exists in v2017.01-smarct4x and in 37 other branches

lpc32xx: add lpc32xx-spl.bin boot image target

Signed-off-by: Albert ARIBAUD (3ADEV) <albert.aribaud@3adev.fr>

Showing 4 changed files with 181 additions and 0 deletions Inline Diff

common/image.c
include/image.h
tools/Makefile
tools/lpc32xximage.c

common/image.c

Diff comments View file @ 39f520b

 /*
  * (C) Copyright 2008 Semihalf
  *
  * (C) Copyright 2000-2006
  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
  *
  * SPDX-License-Identifier:	GPL-2.0+
  */
 #ifndef USE_HOSTCC
 #include <common.h>
 #include <watchdog.h>
 #ifdef CONFIG_SHOW_BOOT_PROGRESS
 #include <status_led.h>
 #endif
 #ifdef CONFIG_HAS_DATAFLASH
 #include <dataflash.h>
 #endif
 #ifdef CONFIG_LOGBUFFER
 #include <logbuff.h>
 #endif
 #include <rtc.h>
 #include <environment.h>
 #include <image.h>
 #if defined(CONFIG_FIT) || defined(CONFIG_OF_LIBFDT)
 #include <libfdt.h>
 #include <fdt_support.h>
 #endif
 #include <u-boot/md5.h>
 #include <u-boot/sha1.h>
 #include <asm/errno.h>
 #include <asm/io.h>
 #ifdef CONFIG_CMD_BDI
 extern int do_bdinfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
 #endif
 DECLARE_GLOBAL_DATA_PTR;
 #if defined(CONFIG_IMAGE_FORMAT_LEGACY)
 static const image_header_t *image_get_ramdisk(ulong rd_addr, uint8_t arch,
 						int verify);
 #endif
 #else
 #include "mkimage.h"
 #include <u-boot/md5.h>
 #include <time.h>
 #include <image.h>
 #endif /* !USE_HOSTCC*/
 #include <u-boot/crc.h>
 #ifndef CONFIG_SYS_BARGSIZE
 #define CONFIG_SYS_BARGSIZE 512
 #endif
 static const table_entry_t uimage_arch[] = {
 	{	IH_ARCH_INVALID,	NULL,		"Invalid ARCH",	},
 	{	IH_ARCH_ALPHA,		"alpha",	"Alpha",	},
 	{	IH_ARCH_ARM,		"arm",		"ARM",		},
 	{	IH_ARCH_I386,		"x86",		"Intel x86",	},
 	{	IH_ARCH_IA64,		"ia64",		"IA64",		},
 	{	IH_ARCH_M68K,		"m68k",		"M68K",		},
 	{	IH_ARCH_MICROBLAZE,	"microblaze",	"MicroBlaze",	},
 	{	IH_ARCH_MIPS,		"mips",		"MIPS",		},
 	{	IH_ARCH_MIPS64,		"mips64",	"MIPS 64 Bit",	},
 	{	IH_ARCH_NIOS2,		"nios2",	"NIOS II",	},
 	{	IH_ARCH_PPC,		"powerpc",	"PowerPC",	},
 	{	IH_ARCH_PPC,		"ppc",		"PowerPC",	},
 	{	IH_ARCH_S390,		"s390",		"IBM S390",	},
 	{	IH_ARCH_SH,		"sh",		"SuperH",	},
 	{	IH_ARCH_SPARC,		"sparc",	"SPARC",	},
 	{	IH_ARCH_SPARC64,	"sparc64",	"SPARC 64 Bit",	},
 	{	IH_ARCH_BLACKFIN,	"blackfin",	"Blackfin",	},
 	{	IH_ARCH_AVR32,		"avr32",	"AVR32",	},
 	{	IH_ARCH_NDS32,		"nds32",	"NDS32",	},
 	{	IH_ARCH_OPENRISC,	"or1k",		"OpenRISC 1000",},
 	{	IH_ARCH_SANDBOX,	"sandbox",	"Sandbox",	},
 	{	IH_ARCH_ARM64,		"arm64",	"AArch64",	},
 	{	IH_ARCH_ARC,		"arc",		"ARC",		},
 	{	IH_ARCH_X86_64,		"x86_64",	"AMD x86_64",	},
 	{	-1,			"",		"",		},
 };
 static const table_entry_t uimage_os[] = {
 	{	IH_OS_INVALID,	NULL,		"Invalid OS",		},
 	{	IH_OS_LINUX,	"linux",	"Linux",		},
 #if defined(CONFIG_LYNXKDI) || defined(USE_HOSTCC)
 	{	IH_OS_LYNXOS,	"lynxos",	"LynxOS",		},
 #endif
 	{	IH_OS_NETBSD,	"netbsd",	"NetBSD",		},
 	{	IH_OS_OSE,	"ose",		"Enea OSE",		},
 	{	IH_OS_PLAN9,	"plan9",	"Plan 9",		},
 	{	IH_OS_RTEMS,	"rtems",	"RTEMS",		},
 	{	IH_OS_U_BOOT,	"u-boot",	"U-Boot",		},
 	{	IH_OS_VXWORKS,	"vxworks",	"VxWorks",		},
 #if defined(CONFIG_CMD_ELF) || defined(USE_HOSTCC)
 	{	IH_OS_QNX,	"qnx",		"QNX",			},
 #endif
 #if defined(CONFIG_INTEGRITY) || defined(USE_HOSTCC)
 	{	IH_OS_INTEGRITY,"integrity",	"INTEGRITY",		},
 #endif
 #ifdef USE_HOSTCC
 	{	IH_OS_4_4BSD,	"4_4bsd",	"4_4BSD",		},
 	{	IH_OS_DELL,	"dell",		"Dell",			},
 	{	IH_OS_ESIX,	"esix",		"Esix",			},
 	{	IH_OS_FREEBSD,	"freebsd",	"FreeBSD",		},
 	{	IH_OS_IRIX,	"irix",		"Irix",			},
 	{	IH_OS_NCR,	"ncr",		"NCR",			},
 	{	IH_OS_OPENBSD,	"openbsd",	"OpenBSD",		},
 	{	IH_OS_PSOS,	"psos",		"pSOS",			},
 	{	IH_OS_SCO,	"sco",		"SCO",			},
 	{	IH_OS_SOLARIS,	"solaris",	"Solaris",		},
 	{	IH_OS_SVR4,	"svr4",		"SVR4",			},
 #endif
 #if defined(CONFIG_BOOTM_OPENRTOS) || defined(USE_HOSTCC)
 	{	IH_OS_OPENRTOS,	"openrtos",	"OpenRTOS",		},
 #endif
 	{	-1,		"",		"",			},
 };
 static const table_entry_t uimage_type[] = {
 	{	IH_TYPE_AISIMAGE,   "aisimage",   "Davinci AIS image",},
 	{	IH_TYPE_FILESYSTEM, "filesystem", "Filesystem Image",	},
 	{	IH_TYPE_FIRMWARE,   "firmware",	  "Firmware",		},
 	{	IH_TYPE_FLATDT,     "flat_dt",    "Flat Device Tree",	},
 	{	IH_TYPE_GPIMAGE,    "gpimage",    "TI Keystone SPL Image",},
 	{	IH_TYPE_KERNEL,	    "kernel",	  "Kernel Image",	},
 	{	IH_TYPE_KERNEL_NOLOAD, "kernel_noload",  "Kernel Image (no loading done)", },
 	{	IH_TYPE_KWBIMAGE,   "kwbimage",   "Kirkwood Boot Image",},
 	{	IH_TYPE_IMXIMAGE,   "imximage",   "Freescale i.MX Boot Image",},
 	{	IH_TYPE_INVALID,    NULL,	  "Invalid Image",	},
 	{	IH_TYPE_MULTI,	    "multi",	  "Multi-File Image",	},
 	{	IH_TYPE_OMAPIMAGE,  "omapimage",  "TI OMAP SPL With GP CH",},
 	{	IH_TYPE_PBLIMAGE,   "pblimage",   "Freescale PBL Boot Image",},
 	{	IH_TYPE_RAMDISK,    "ramdisk",	  "RAMDisk Image",	},
 	{	IH_TYPE_SCRIPT,     "script",	  "Script",		},
 	{	IH_TYPE_SOCFPGAIMAGE, "socfpgaimage", "Altera SOCFPGA preloader",},
 	{	IH_TYPE_STANDALONE, "standalone", "Standalone Program", },
 	{	IH_TYPE_UBLIMAGE,   "ublimage",   "Davinci UBL image",},
 	{	IH_TYPE_MXSIMAGE,   "mxsimage",   "Freescale MXS Boot Image",},
 	{	IH_TYPE_ATMELIMAGE, "atmelimage", "ATMEL ROM-Boot Image",},
 	{	IH_TYPE_X86_SETUP,  "x86_setup",  "x86 setup.bin",    },
+	{	IH_TYPE_LPC32XXIMAGE, "lpc32xximage",  "LPC32XX Boot Image", },
 	{	-1,		    "",		  "",			},
 };
 static const table_entry_t uimage_comp[] = {
 	{	IH_COMP_NONE,	"none",		"uncompressed",		},
 	{	IH_COMP_BZIP2,	"bzip2",	"bzip2 compressed",	},
 	{	IH_COMP_GZIP,	"gzip",		"gzip compressed",	},
 	{	IH_COMP_LZMA,	"lzma",		"lzma compressed",	},
 	{	IH_COMP_LZO,	"lzo",		"lzo compressed",	},
 	{	-1,		"",		"",			},
 };
 /*****************************************************************************/
 /* Legacy format routines */
 /*****************************************************************************/
 int image_check_hcrc(const image_header_t *hdr)
 {
 	ulong hcrc;
 	ulong len = image_get_header_size();
 	image_header_t header;
 	/* Copy header so we can blank CRC field for re-calculation */
 	memmove(&header, (char *)hdr, image_get_header_size());
 	image_set_hcrc(&header, 0);
 	hcrc = crc32(0, (unsigned char *)&header, len);
 	return (hcrc == image_get_hcrc(hdr));
 }
 int image_check_dcrc(const image_header_t *hdr)
 {
 	ulong data = image_get_data(hdr);
 	ulong len = image_get_data_size(hdr);
 	ulong dcrc = crc32_wd(0, (unsigned char *)data, len, CHUNKSZ_CRC32);
 	return (dcrc == image_get_dcrc(hdr));
 }
 /**
  * image_multi_count - get component (sub-image) count
  * @hdr: pointer to the header of the multi component image
  *
  * image_multi_count() returns number of components in a multi
  * component image.
  *
  * Note: no checking of the image type is done, caller must pass
  * a valid multi component image.
  *
  * returns:
  *     number of components
  */
 ulong image_multi_count(const image_header_t *hdr)
 {
 	ulong i, count = 0;
 	uint32_t *size;
 	/* get start of the image payload, which in case of multi
 	 * component images that points to a table of component sizes */
 	size = (uint32_t *)image_get_data(hdr);
 	/* count non empty slots */
 	for (i = 0; size[i]; ++i)
 		count++;
 	return count;
 }
 /**
  * image_multi_getimg - get component data address and size
  * @hdr: pointer to the header of the multi component image
  * @idx: index of the requested component
  * @data: pointer to a ulong variable, will hold component data address
  * @len: pointer to a ulong variable, will hold component size
  *
  * image_multi_getimg() returns size and data address for the requested
  * component in a multi component image.
  *
  * Note: no checking of the image type is done, caller must pass
  * a valid multi component image.
  *
  * returns:
  *     data address and size of the component, if idx is valid
  *     0 in data and len, if idx is out of range
  */
 void image_multi_getimg(const image_header_t *hdr, ulong idx,
 			ulong *data, ulong *len)
 {
 	int i;
 	uint32_t *size;
 	ulong offset, count, img_data;
 	/* get number of component */
 	count = image_multi_count(hdr);
 	/* get start of the image payload, which in case of multi
 	 * component images that points to a table of component sizes */
 	size = (uint32_t *)image_get_data(hdr);
 	/* get address of the proper component data start, which means
 	 * skipping sizes table (add 1 for last, null entry) */
 	img_data = image_get_data(hdr) + (count + 1) * sizeof(uint32_t);
 	if (idx < count) {
 		*len = uimage_to_cpu(size[idx]);
 		offset = 0;
 		/* go over all indices preceding requested component idx */
 		for (i = 0; i < idx; i++) {
 			/* add up i-th component size, rounding up to 4 bytes */
 			offset += (uimage_to_cpu(size[i]) + 3) & ~3 ;
 		}
 		/* calculate idx-th component data address */
 		*data = img_data + offset;
 	} else {
 		*len = 0;
 		*data = 0;
 	}
 }
 static void image_print_type(const image_header_t *hdr)
 {
 	const char *os, *arch, *type, *comp;
 	os = genimg_get_os_name(image_get_os(hdr));
 	arch = genimg_get_arch_name(image_get_arch(hdr));
 	type = genimg_get_type_name(image_get_type(hdr));
 	comp = genimg_get_comp_name(image_get_comp(hdr));
 	printf("%s %s %s (%s)\n", arch, os, type, comp);
 }
 /**
  * image_print_contents - prints out the contents of the legacy format image
  * @ptr: pointer to the legacy format image header
  * @p: pointer to prefix string
  *
  * image_print_contents() formats a multi line legacy image contents description.
  * The routine prints out all header fields followed by the size/offset data
  * for MULTI/SCRIPT images.
  *
  * returns:
  *     no returned results
  */
 void image_print_contents(const void *ptr)
 {
 	const image_header_t *hdr = (const image_header_t *)ptr;
 	const char *p;
 	p = IMAGE_INDENT_STRING;
 	printf("%sImage Name:   %.*s\n", p, IH_NMLEN, image_get_name(hdr));
 	if (IMAGE_ENABLE_TIMESTAMP) {
 		printf("%sCreated:      ", p);
 		genimg_print_time((time_t)image_get_time(hdr));
 	}
 	printf("%sImage Type:   ", p);
 	image_print_type(hdr);
 	printf("%sData Size:    ", p);
 	genimg_print_size(image_get_data_size(hdr));
 	printf("%sLoad Address: %08x\n", p, image_get_load(hdr));
 	printf("%sEntry Point:  %08x\n", p, image_get_ep(hdr));
 	if (image_check_type(hdr, IH_TYPE_MULTI) ||
 			image_check_type(hdr, IH_TYPE_SCRIPT)) {
 		int i;
 		ulong data, len;
 		ulong count = image_multi_count(hdr);
 		printf("%sContents:\n", p);
 		for (i = 0; i < count; i++) {
 			image_multi_getimg(hdr, i, &data, &len);
 			printf("%s   Image %d: ", p, i);
 			genimg_print_size(len);
 			if (image_check_type(hdr, IH_TYPE_SCRIPT) && i > 0) {
 				/*
 				 * the user may need to know offsets
 				 * if planning to do something with
 				 * multiple files
 				 */
 				printf("%s    Offset = 0x%08lx\n", p, data);
 			}
 		}
 	}
 }
 #ifndef USE_HOSTCC
 #if defined(CONFIG_IMAGE_FORMAT_LEGACY)
 /**
  * image_get_ramdisk - get and verify ramdisk image
  * @rd_addr: ramdisk image start address
  * @arch: expected ramdisk architecture
  * @verify: checksum verification flag
  *
  * image_get_ramdisk() returns a pointer to the verified ramdisk image
  * header. Routine receives image start address and expected architecture
  * flag. Verification done covers data and header integrity and os/type/arch
  * fields checking.
  *
  * If dataflash support is enabled routine checks for dataflash addresses
  * and handles required dataflash reads.
  *
  * returns:
  *     pointer to a ramdisk image header, if image was found and valid
  *     otherwise, return NULL
  */
 static const image_header_t *image_get_ramdisk(ulong rd_addr, uint8_t arch,
 						int verify)
 {
 	const image_header_t *rd_hdr = (const image_header_t *)rd_addr;
 	if (!image_check_magic(rd_hdr)) {
 		puts("Bad Magic Number\n");
 		bootstage_error(BOOTSTAGE_ID_RD_MAGIC);
 		return NULL;
 	}
 	if (!image_check_hcrc(rd_hdr)) {
 		puts("Bad Header Checksum\n");
 		bootstage_error(BOOTSTAGE_ID_RD_HDR_CHECKSUM);
 		return NULL;
 	}
 	bootstage_mark(BOOTSTAGE_ID_RD_MAGIC);
 	image_print_contents(rd_hdr);
 	if (verify) {
 		puts("   Verifying Checksum ... ");
 		if (!image_check_dcrc(rd_hdr)) {
 			puts("Bad Data CRC\n");
 			bootstage_error(BOOTSTAGE_ID_RD_CHECKSUM);
 			return NULL;
 		}
 		puts("OK\n");
 	}
 	bootstage_mark(BOOTSTAGE_ID_RD_HDR_CHECKSUM);
 	if (!image_check_os(rd_hdr, IH_OS_LINUX) ||
 	    !image_check_arch(rd_hdr, arch) ||
 	    !image_check_type(rd_hdr, IH_TYPE_RAMDISK)) {
 		printf("No Linux %s Ramdisk Image\n",
 				genimg_get_arch_name(arch));
 		bootstage_error(BOOTSTAGE_ID_RAMDISK);
 		return NULL;
 	}
 	return rd_hdr;
 }
 #endif
 #endif /* !USE_HOSTCC */
 /*****************************************************************************/
 /* Shared dual-format routines */
 /*****************************************************************************/
 #ifndef USE_HOSTCC
 ulong load_addr = CONFIG_SYS_LOAD_ADDR;	/* Default Load Address */
 ulong save_addr;			/* Default Save Address */
 ulong save_size;			/* Default Save Size (in bytes) */
 static int on_loadaddr(const char *name, const char *value, enum env_op op,
 	int flags)
 {
 	switch (op) {
 	case env_op_create:
 	case env_op_overwrite:
 		load_addr = simple_strtoul(value, NULL, 16);
 		break;
 	default:
 		break;
 	}
 	return 0;
 }
 U_BOOT_ENV_CALLBACK(loadaddr, on_loadaddr);
 ulong getenv_bootm_low(void)
 {
 	char *s = getenv("bootm_low");
 	if (s) {
 		ulong tmp = simple_strtoul(s, NULL, 16);
 		return tmp;
 	}
 #if defined(CONFIG_SYS_SDRAM_BASE)
 	return CONFIG_SYS_SDRAM_BASE;
 #elif defined(CONFIG_ARM)
 	return gd->bd->bi_dram[0].start;
 #else
 	return 0;
 #endif
 }
 phys_size_t getenv_bootm_size(void)
 {
 	phys_size_t tmp;
 	char *s = getenv("bootm_size");
 	if (s) {
 		tmp = (phys_size_t)simple_strtoull(s, NULL, 16);
 		return tmp;
 	}
 	s = getenv("bootm_low");
 	if (s)
 		tmp = (phys_size_t)simple_strtoull(s, NULL, 16);
 	else
 		tmp = 0;
 #if defined(CONFIG_ARM)
 	return gd->bd->bi_dram[0].size - tmp;
 #else
 	return gd->bd->bi_memsize - tmp;
 #endif
 }
 phys_size_t getenv_bootm_mapsize(void)
 {
 	phys_size_t tmp;
 	char *s = getenv("bootm_mapsize");
 	if (s) {
 		tmp = (phys_size_t)simple_strtoull(s, NULL, 16);
 		return tmp;
 	}
 #if defined(CONFIG_SYS_BOOTMAPSZ)
 	return CONFIG_SYS_BOOTMAPSZ;
 #else
 	return getenv_bootm_size();
 #endif
 }
 void memmove_wd(void *to, void *from, size_t len, ulong chunksz)
 {
 	if (to == from)
 		return;
 #if defined(CONFIG_HW_WATCHDOG) || defined(CONFIG_WATCHDOG)
 	if (to > from) {
 		from += len;
 		to += len;
 	}
 	while (len > 0) {
 		size_t tail = (len > chunksz) ? chunksz : len;
 		WATCHDOG_RESET();
 		if (to > from) {
 			to -= tail;
 			from -= tail;
 		}
 		memmove(to, from, tail);
 		if (to < from) {
 			to += tail;
 			from += tail;
 		}
 		len -= tail;
 	}
 #else	/* !(CONFIG_HW_WATCHDOG || CONFIG_WATCHDOG) */
 	memmove(to, from, len);
 #endif	/* CONFIG_HW_WATCHDOG || CONFIG_WATCHDOG */
 }
 #endif /* !USE_HOSTCC */
 void genimg_print_size(uint32_t size)
 {
 #ifndef USE_HOSTCC
 	printf("%d Bytes = ", size);
 	print_size(size, "\n");
 #else
 	printf("%d Bytes = %.2f kB = %.2f MB\n",
 			size, (double)size / 1.024e3,
 			(double)size / 1.048576e6);
 #endif
 }
 #if IMAGE_ENABLE_TIMESTAMP
 void genimg_print_time(time_t timestamp)
 {
 #ifndef USE_HOSTCC
 	struct rtc_time tm;
 	to_tm(timestamp, &tm);
 	printf("%4d-%02d-%02d  %2d:%02d:%02d UTC\n",
 			tm.tm_year, tm.tm_mon, tm.tm_mday,
 			tm.tm_hour, tm.tm_min, tm.tm_sec);
 #else
 	printf("%s", ctime(&timestamp));
 #endif
 }
 #endif
 /**
  * get_table_entry_name - translate entry id to long name
  * @table: pointer to a translation table for entries of a specific type
  * @msg: message to be returned when translation fails
  * @id: entry id to be translated
  *
  * get_table_entry_name() will go over translation table trying to find
  * entry that matches given id. If matching entry is found, its long
  * name is returned to the caller.
  *
  * returns:
  *     long entry name if translation succeeds
  *     msg otherwise
  */
 char *get_table_entry_name(const table_entry_t *table, char *msg, int id)
 {
 	for (; table->id >= 0; ++table) {
 		if (table->id == id)
 #if defined(USE_HOSTCC) || !defined(CONFIG_NEEDS_MANUAL_RELOC)
 			return table->lname;
 #else
 			return table->lname + gd->reloc_off;
 #endif
 	}
 	return (msg);
 }
 const char *genimg_get_os_name(uint8_t os)
 {
 	return (get_table_entry_name(uimage_os, "Unknown OS", os));
 }
 const char *genimg_get_arch_name(uint8_t arch)
 {
 	return (get_table_entry_name(uimage_arch, "Unknown Architecture",
 					arch));
 }
 const char *genimg_get_type_name(uint8_t type)
 {
 	return (get_table_entry_name(uimage_type, "Unknown Image", type));
 }
 const char *genimg_get_comp_name(uint8_t comp)
 {
 	return (get_table_entry_name(uimage_comp, "Unknown Compression",
 					comp));
 }
 /**
  * get_table_entry_id - translate short entry name to id
  * @table: pointer to a translation table for entries of a specific type
  * @table_name: to be used in case of error
  * @name: entry short name to be translated
  *
  * get_table_entry_id() will go over translation table trying to find
  * entry that matches given short name. If matching entry is found,
  * its id returned to the caller.
  *
  * returns:
  *     entry id if translation succeeds
  *     -1 otherwise
  */
 int get_table_entry_id(const table_entry_t *table,
 		const char *table_name, const char *name)
 {
 	const table_entry_t *t;
 #ifdef USE_HOSTCC
 	int first = 1;
 	for (t = table; t->id >= 0; ++t) {
 		if (t->sname && strcasecmp(t->sname, name) == 0)
 			return(t->id);
 	}
 	fprintf(stderr, "\nInvalid %s Type - valid names are", table_name);
 	for (t = table; t->id >= 0; ++t) {
 		if (t->sname == NULL)
 			continue;
 		fprintf(stderr, "%c %s", (first) ? ':' : ',', t->sname);
 		first = 0;
 	}
 	fprintf(stderr, "\n");
 #else
 	for (t = table; t->id >= 0; ++t) {
 #ifdef CONFIG_NEEDS_MANUAL_RELOC
 		if (t->sname && strcmp(t->sname + gd->reloc_off, name) == 0)
 #else
 		if (t->sname && strcmp(t->sname, name) == 0)
 #endif
 			return (t->id);
 	}
 	debug("Invalid %s Type: %s\n", table_name, name);
 #endif /* USE_HOSTCC */
 	return (-1);
 }
 int genimg_get_os_id(const char *name)
 {
 	return (get_table_entry_id(uimage_os, "OS", name));
 }
 int genimg_get_arch_id(const char *name)
 {
 	return (get_table_entry_id(uimage_arch, "CPU", name));
 }
 int genimg_get_type_id(const char *name)
 {
 	return (get_table_entry_id(uimage_type, "Image", name));
 }
 int genimg_get_comp_id(const char *name)
 {
 	return (get_table_entry_id(uimage_comp, "Compression", name));
 }
 #ifndef USE_HOSTCC
 /**
  * genimg_get_kernel_addr_fit - get the real kernel address and return 2
  *                              FIT strings
  * @img_addr: a string might contain real image address
  * @fit_uname_config: double pointer to a char, will hold pointer to a
  *                    configuration unit name
  * @fit_uname_kernel: double pointer to a char, will hold pointer to a subimage
  *                    name
  *
  * genimg_get_kernel_addr_fit get the real kernel start address from a string
  * which is normally the first argv of bootm/bootz
  *
  * returns:
  *     kernel start address
  */
 ulong genimg_get_kernel_addr_fit(char * const img_addr,
 			     const char **fit_uname_config,
 			     const char **fit_uname_kernel)
 {
 	ulong kernel_addr;
 	/* find out kernel image address */
 	if (!img_addr) {
 		kernel_addr = load_addr;
 		debug("*  kernel: default image load address = 0x%08lx\n",
 		      load_addr);
 #if defined(CONFIG_FIT)
 	} else if (fit_parse_conf(img_addr, load_addr, &kernel_addr,
 				  fit_uname_config)) {
 		debug("*  kernel: config '%s' from image at 0x%08lx\n",
 		      *fit_uname_config, kernel_addr);
 	} else if (fit_parse_subimage(img_addr, load_addr, &kernel_addr,
 				     fit_uname_kernel)) {
 		debug("*  kernel: subimage '%s' from image at 0x%08lx\n",
 		      *fit_uname_kernel, kernel_addr);
 #endif
 	} else {
 		kernel_addr = simple_strtoul(img_addr, NULL, 16);
 		debug("*  kernel: cmdline image address = 0x%08lx\n",
 		      kernel_addr);
 	}
 	return kernel_addr;
 }
 /**
  * genimg_get_kernel_addr() is the simple version of
  * genimg_get_kernel_addr_fit(). It ignores those return FIT strings
  */
 ulong genimg_get_kernel_addr(char * const img_addr)
 {
 	const char *fit_uname_config = NULL;
 	const char *fit_uname_kernel = NULL;
 	return genimg_get_kernel_addr_fit(img_addr, &fit_uname_config,
 					  &fit_uname_kernel);
 }
 /**
  * genimg_get_format - get image format type
  * @img_addr: image start address
  *
  * genimg_get_format() checks whether provided address points to a valid
  * legacy or FIT image.
  *
  * New uImage format and FDT blob are based on a libfdt. FDT blob
  * may be passed directly or embedded in a FIT image. In both situations
  * genimg_get_format() must be able to dectect libfdt header.
  *
  * returns:
  *     image format type or IMAGE_FORMAT_INVALID if no image is present
  */
 int genimg_get_format(const void *img_addr)
 {
 #if defined(CONFIG_IMAGE_FORMAT_LEGACY)
 	const image_header_t *hdr;
 	hdr = (const image_header_t *)img_addr;
 	if (image_check_magic(hdr))
 		return IMAGE_FORMAT_LEGACY;
 #endif
 #if defined(CONFIG_FIT) || defined(CONFIG_OF_LIBFDT)
 	if (fdt_check_header(img_addr) == 0)
 		return IMAGE_FORMAT_FIT;
 #endif
 #ifdef CONFIG_ANDROID_BOOT_IMAGE
 	if (android_image_check_header(img_addr) == 0)
 		return IMAGE_FORMAT_ANDROID;
 #endif
 	return IMAGE_FORMAT_INVALID;
 }
 /**
  * genimg_get_image - get image from special storage (if necessary)
  * @img_addr: image start address
  *
  * genimg_get_image() checks if provided image start address is located
  * in a dataflash storage. If so, image is moved to a system RAM memory.
  *
  * returns:
  *     image start address after possible relocation from special storage
  */
 ulong genimg_get_image(ulong img_addr)
 {
 	ulong ram_addr = img_addr;
 #ifdef CONFIG_HAS_DATAFLASH
 	ulong h_size, d_size;
 	if (addr_dataflash(img_addr)) {
 		void *buf;
 		/* ger RAM address */
 		ram_addr = CONFIG_SYS_LOAD_ADDR;
 		/* get header size */
 		h_size = image_get_header_size();
 #if defined(CONFIG_FIT)
 		if (sizeof(struct fdt_header) > h_size)
 			h_size = sizeof(struct fdt_header);
 #endif
 		/* read in header */
 		debug("   Reading image header from dataflash address "
 			"%08lx to RAM address %08lx\n", img_addr, ram_addr);
 		buf = map_sysmem(ram_addr, 0);
 		read_dataflash(img_addr, h_size, buf);
 		/* get data size */
 		switch (genimg_get_format(buf)) {
 #if defined(CONFIG_IMAGE_FORMAT_LEGACY)
 		case IMAGE_FORMAT_LEGACY:
 			d_size = image_get_data_size(buf);
 			debug("   Legacy format image found at 0x%08lx, "
 					"size 0x%08lx\n",
 					ram_addr, d_size);
 			break;
 #endif
 #if defined(CONFIG_FIT)
 		case IMAGE_FORMAT_FIT:
 			d_size = fit_get_size(buf) - h_size;
 			debug("   FIT/FDT format image found at 0x%08lx, "
 					"size 0x%08lx\n",
 					ram_addr, d_size);
 			break;
 #endif
 		default:
 			printf("   No valid image found at 0x%08lx\n",
 				img_addr);
 			return ram_addr;
 		}
 		/* read in image data */
 		debug("   Reading image remaining data from dataflash address "
 			"%08lx to RAM address %08lx\n", img_addr + h_size,
 			ram_addr + h_size);
 		read_dataflash(img_addr + h_size, d_size,
 				(char *)(buf + h_size));
 	}
 #endif /* CONFIG_HAS_DATAFLASH */
 	return ram_addr;
 }
 /**
  * fit_has_config - check if there is a valid FIT configuration
  * @images: pointer to the bootm command headers structure
  *
  * fit_has_config() checks if there is a FIT configuration in use
  * (if FTI support is present).
  *
  * returns:
  *     0, no FIT support or no configuration found
  *     1, configuration found
  */
 int genimg_has_config(bootm_headers_t *images)
 {
 #if defined(CONFIG_FIT)
 	if (images->fit_uname_cfg)
 		return 1;
 #endif
 	return 0;
 }
 /**
  * boot_get_ramdisk - main ramdisk handling routine
  * @argc: command argument count
  * @argv: command argument list
  * @images: pointer to the bootm images structure
  * @arch: expected ramdisk architecture
  * @rd_start: pointer to a ulong variable, will hold ramdisk start address
  * @rd_end: pointer to a ulong variable, will hold ramdisk end
  *
  * boot_get_ramdisk() is responsible for finding a valid ramdisk image.
  * Curently supported are the following ramdisk sources:
  *      - multicomponent kernel/ramdisk image,
  *      - commandline provided address of decicated ramdisk image.
  *
  * returns:
  *     0, if ramdisk image was found and valid, or skiped
  *     rd_start and rd_end are set to ramdisk start/end addresses if
  *     ramdisk image is found and valid
  *
  *     1, if ramdisk image is found but corrupted, or invalid
  *     rd_start and rd_end are set to 0 if no ramdisk exists
  */
 int boot_get_ramdisk(int argc, char * const argv[], bootm_headers_t *images,
 		uint8_t arch, ulong *rd_start, ulong *rd_end)
 {
 	ulong rd_addr, rd_load;
 	ulong rd_data, rd_len;
 #if defined(CONFIG_IMAGE_FORMAT_LEGACY)
 	const image_header_t *rd_hdr;
 #endif
 	void *buf;
 #ifdef CONFIG_SUPPORT_RAW_INITRD
 	char *end;
 #endif
 #if defined(CONFIG_FIT)
 	const char	*fit_uname_config = images->fit_uname_cfg;
 	const char	*fit_uname_ramdisk = NULL;
 	ulong		default_addr;
 	int		rd_noffset;
 #endif
 	const char *select = NULL;
 	*rd_start = 0;
 	*rd_end = 0;
 	if (argc >= 2)
 		select = argv[1];
 	/*
 	 * Look for a '-' which indicates to ignore the
 	 * ramdisk argument
 	 */
 	if (select && strcmp(select, "-") ==  0) {
 		debug("## Skipping init Ramdisk\n");
 		rd_len = rd_data = 0;
 	} else if (select || genimg_has_config(images)) {
 #if defined(CONFIG_FIT)
 		if (select) {
 			/*
 			 * If the init ramdisk comes from the FIT image and
 			 * the FIT image address is omitted in the command
 			 * line argument, try to use os FIT image address or
 			 * default load address.
 			 */
 			if (images->fit_uname_os)
 				default_addr = (ulong)images->fit_hdr_os;
 			else
 				default_addr = load_addr;
 			if (fit_parse_conf(select, default_addr,
 					   &rd_addr, &fit_uname_config)) {
 				debug("*  ramdisk: config '%s' from image at "
 						"0x%08lx\n",
 						fit_uname_config, rd_addr);
 			} else if (fit_parse_subimage(select, default_addr,
 						&rd_addr, &fit_uname_ramdisk)) {
 				debug("*  ramdisk: subimage '%s' from image at "
 						"0x%08lx\n",
 						fit_uname_ramdisk, rd_addr);
 			} else
 #endif
 			{
 				rd_addr = simple_strtoul(select, NULL, 16);
 				debug("*  ramdisk: cmdline image address = "
 						"0x%08lx\n",
 						rd_addr);
 			}
 #if defined(CONFIG_FIT)
 		} else {
 			/* use FIT configuration provided in first bootm
 			 * command argument. If the property is not defined,
 			 * quit silently.
 			 */
 			rd_addr = map_to_sysmem(images->fit_hdr_os);
 			rd_noffset = fit_get_node_from_config(images,
 					FIT_RAMDISK_PROP, rd_addr);
 			if (rd_noffset == -ENOLINK)
 				return 0;
 			else if (rd_noffset < 0)
 				return 1;
 		}
 #endif
 		/* copy from dataflash if needed */
 		rd_addr = genimg_get_image(rd_addr);
 		/*
 		 * Check if there is an initrd image at the
 		 * address provided in the second bootm argument
 		 * check image type, for FIT images get FIT node.
 		 */
 		buf = map_sysmem(rd_addr, 0);
 		switch (genimg_get_format(buf)) {
 #if defined(CONFIG_IMAGE_FORMAT_LEGACY)
 		case IMAGE_FORMAT_LEGACY:
 			printf("## Loading init Ramdisk from Legacy "
 					"Image at %08lx ...\n", rd_addr);
 			bootstage_mark(BOOTSTAGE_ID_CHECK_RAMDISK);
 			rd_hdr = image_get_ramdisk(rd_addr, arch,
 							images->verify);
 			if (rd_hdr == NULL)
 				return 1;
 			rd_data = image_get_data(rd_hdr);
 			rd_len = image_get_data_size(rd_hdr);
 			rd_load = image_get_load(rd_hdr);
 			break;
 #endif
 #if defined(CONFIG_FIT)
 		case IMAGE_FORMAT_FIT:
 			rd_noffset = fit_image_load(images,
 					rd_addr, &fit_uname_ramdisk,
 					&fit_uname_config, arch,
 					IH_TYPE_RAMDISK,
 					BOOTSTAGE_ID_FIT_RD_START,
 					FIT_LOAD_OPTIONAL_NON_ZERO,
 					&rd_data, &rd_len);
 			if (rd_noffset < 0)
 				return 1;
 			images->fit_hdr_rd = map_sysmem(rd_addr, 0);
 			images->fit_uname_rd = fit_uname_ramdisk;
 			images->fit_noffset_rd = rd_noffset;
 			break;
 #endif
 		default:
 #ifdef CONFIG_SUPPORT_RAW_INITRD
 			end = NULL;
 			if (select)
 				end = strchr(select, ':');
 			if (end) {
 				rd_len = simple_strtoul(++end, NULL, 16);
 				rd_data = rd_addr;
 			} else
 #endif
 			{
 				puts("Wrong Ramdisk Image Format\n");
 				rd_data = rd_len = rd_load = 0;
 				return 1;
 			}
 		}
 	} else if (images->legacy_hdr_valid &&
 			image_check_type(&images->legacy_hdr_os_copy,
 						IH_TYPE_MULTI)) {
 		/*
 		 * Now check if we have a legacy mult-component image,
 		 * get second entry data start address and len.
 		 */
 		bootstage_mark(BOOTSTAGE_ID_RAMDISK);
 		printf("## Loading init Ramdisk from multi component "
 				"Legacy Image at %08lx ...\n",
 				(ulong)images->legacy_hdr_os);
 		image_multi_getimg(images->legacy_hdr_os, 1, &rd_data, &rd_len);
 	}
 #ifdef CONFIG_ANDROID_BOOT_IMAGE
 	else if ((genimg_get_format((void *)images->os.start)
 			== IMAGE_FORMAT_ANDROID) &&
 		 (!android_image_get_ramdisk((void *)images->os.start,
 		 &rd_data, &rd_len))) {
 		/* empty */
 	}
 #endif
 	else {
 		/*
 		 * no initrd image
 		 */
 		bootstage_mark(BOOTSTAGE_ID_NO_RAMDISK);
 		rd_len = rd_data = 0;
 	}
 	if (!rd_data) {
 		debug("## No init Ramdisk\n");
 	} else {
 		*rd_start = rd_data;
 		*rd_end = rd_data + rd_len;
 	}
 	debug("   ramdisk start = 0x%08lx, ramdisk end = 0x%08lx\n",
 			*rd_start, *rd_end);
 	return 0;
 }
 #ifdef CONFIG_SYS_BOOT_RAMDISK_HIGH
 /**
  * boot_ramdisk_high - relocate init ramdisk
  * @lmb: pointer to lmb handle, will be used for memory mgmt
  * @rd_data: ramdisk data start address
  * @rd_len: ramdisk data length
  * @initrd_start: pointer to a ulong variable, will hold final init ramdisk
  *      start address (after possible relocation)
  * @initrd_end: pointer to a ulong variable, will hold final init ramdisk
  *      end address (after possible relocation)
  *
  * boot_ramdisk_high() takes a relocation hint from "initrd_high" environment
  * variable and if requested ramdisk data is moved to a specified location.
  *
  * Initrd_start and initrd_end are set to final (after relocation) ramdisk
  * start/end addresses if ramdisk image start and len were provided,
  * otherwise set initrd_start and initrd_end set to zeros.
  *
  * returns:
  *      0 - success
  *     -1 - failure
  */
 int boot_ramdisk_high(struct lmb *lmb, ulong rd_data, ulong rd_len,
 		  ulong *initrd_start, ulong *initrd_end)
 {
 	char	*s;
 	ulong	initrd_high;
 	int	initrd_copy_to_ram = 1;
 	if ((s = getenv("initrd_high")) != NULL) {
 		/* a value of "no" or a similar string will act like 0,
 		 * turning the "load high" feature off. This is intentional.
 		 */
 		initrd_high = simple_strtoul(s, NULL, 16);
 		if (initrd_high == ~0)
 			initrd_copy_to_ram = 0;
 	} else {
 		/* not set, no restrictions to load high */
 		initrd_high = ~0;
 	}
 #ifdef CONFIG_LOGBUFFER
 	/* Prevent initrd from overwriting logbuffer */
 	lmb_reserve(lmb, logbuffer_base() - LOGBUFF_OVERHEAD, LOGBUFF_RESERVE);
 #endif
 	debug("## initrd_high = 0x%08lx, copy_to_ram = %d\n",
 			initrd_high, initrd_copy_to_ram);
 	if (rd_data) {
 		if (!initrd_copy_to_ram) {	/* zero-copy ramdisk support */
 			debug("   in-place initrd\n");
 			*initrd_start = rd_data;
 			*initrd_end = rd_data + rd_len;
 			lmb_reserve(lmb, rd_data, rd_len);
 		} else {
 			if (initrd_high)
 				*initrd_start = (ulong)lmb_alloc_base(lmb,
 						rd_len, 0x1000, initrd_high);
 			else
 				*initrd_start = (ulong)lmb_alloc(lmb, rd_len,
 								 0x1000);
 			if (*initrd_start == 0) {
 				puts("ramdisk - allocation error\n");
 				goto error;
 			}
 			bootstage_mark(BOOTSTAGE_ID_COPY_RAMDISK);
 			*initrd_end = *initrd_start + rd_len;
 			printf("   Loading Ramdisk to %08lx, end %08lx ... ",
 					*initrd_start, *initrd_end);
 			memmove_wd((void *)*initrd_start,
 					(void *)rd_data, rd_len, CHUNKSZ);
 #ifdef CONFIG_MP
 			/*
 			 * Ensure the image is flushed to memory to handle
 			 * AMP boot scenarios in which we might not be
 			 * HW cache coherent
 			 */
 			flush_cache((unsigned long)*initrd_start, rd_len);
 #endif
 			puts("OK\n");
 		}
 	} else {
 		*initrd_start = 0;
 		*initrd_end = 0;
 	}
 	debug("   ramdisk load start = 0x%08lx, ramdisk load end = 0x%08lx\n",
 			*initrd_start, *initrd_end);
 	return 0;
 error:
 	return -1;
 }
 #endif /* CONFIG_SYS_BOOT_RAMDISK_HIGH */
 int boot_get_setup(bootm_headers_t *images, uint8_t arch,
 		   ulong *setup_start, ulong *setup_len)
 {
 #if defined(CONFIG_FIT)
 	return boot_get_setup_fit(images, arch, setup_start, setup_len);
 #else
 	return -ENOENT;
 #endif
 }
 #ifdef CONFIG_SYS_BOOT_GET_CMDLINE
 /**
  * boot_get_cmdline - allocate and initialize kernel cmdline
  * @lmb: pointer to lmb handle, will be used for memory mgmt
  * @cmd_start: pointer to a ulong variable, will hold cmdline start
  * @cmd_end: pointer to a ulong variable, will hold cmdline end
  *
  * boot_get_cmdline() allocates space for kernel command line below
  * BOOTMAPSZ + getenv_bootm_low() address. If "bootargs" U-boot environemnt
  * variable is present its contents is copied to allocated kernel
  * command line.
  *
  * returns:
  *      0 - success
  *     -1 - failure
  */
 int boot_get_cmdline(struct lmb *lmb, ulong *cmd_start, ulong *cmd_end)
 {
 	char *cmdline;
 	char *s;
 	cmdline = (char *)(ulong)lmb_alloc_base(lmb, CONFIG_SYS_BARGSIZE, 0xf,
 				getenv_bootm_mapsize() + getenv_bootm_low());
 	if (cmdline == NULL)
 		return -1;
 	if ((s = getenv("bootargs")) == NULL)
 		s = "";
 	strcpy(cmdline, s);
 	*cmd_start = (ulong) & cmdline[0];
 	*cmd_end = *cmd_start + strlen(cmdline);
 	debug("## cmdline at 0x%08lx ... 0x%08lx\n", *cmd_start, *cmd_end);
 	return 0;
 }
 #endif /* CONFIG_SYS_BOOT_GET_CMDLINE */
 #ifdef CONFIG_SYS_BOOT_GET_KBD
 /**
  * boot_get_kbd - allocate and initialize kernel copy of board info
  * @lmb: pointer to lmb handle, will be used for memory mgmt
  * @kbd: double pointer to board info data
  *
  * boot_get_kbd() allocates space for kernel copy of board info data below
  * BOOTMAPSZ + getenv_bootm_low() address and kernel board info is initialized
  * with the current u-boot board info data.
  *
  * returns:
  *      0 - success
  *     -1 - failure
  */
 int boot_get_kbd(struct lmb *lmb, bd_t **kbd)
 {
 	*kbd = (bd_t *)(ulong)lmb_alloc_base(lmb, sizeof(bd_t), 0xf,
 				getenv_bootm_mapsize() + getenv_bootm_low());
 	if (*kbd == NULL)
 		return -1;
 	**kbd = *(gd->bd);
 	debug("## kernel board info at 0x%08lx\n", (ulong)*kbd);
 #if defined(DEBUG) && defined(CONFIG_CMD_BDI)
 	do_bdinfo(NULL, 0, 0, NULL);
 #endif
 	return 0;
 }
 #endif /* CONFIG_SYS_BOOT_GET_KBD */
 #ifdef CONFIG_LMB
 int image_setup_linux(bootm_headers_t *images)
 {
 	ulong of_size = images->ft_len;
 	char **of_flat_tree = &images->ft_addr;
 	ulong *initrd_start = &images->initrd_start;
 	ulong *initrd_end = &images->initrd_end;
 	struct lmb *lmb = &images->lmb;
 	ulong rd_len;
 	int ret;
 	if (IMAGE_ENABLE_OF_LIBFDT)
 		boot_fdt_add_mem_rsv_regions(lmb, *of_flat_tree);
 	if (IMAGE_BOOT_GET_CMDLINE) {
 		ret = boot_get_cmdline(lmb, &images->cmdline_start,
 				&images->cmdline_end);
 		if (ret) {
 			puts("ERROR with allocation of cmdline\n");
 			return ret;
 		}
 	}
 	if (IMAGE_ENABLE_RAMDISK_HIGH) {
 		rd_len = images->rd_end - images->rd_start;
 		ret = boot_ramdisk_high(lmb, images->rd_start, rd_len,
 				initrd_start, initrd_end);
 		if (ret)
 			return ret;
 	}
 	if (IMAGE_ENABLE_OF_LIBFDT) {
 		ret = boot_relocate_fdt(lmb, of_flat_tree, &of_size);
 		if (ret)
 			return ret;
 	}
 	if (IMAGE_ENABLE_OF_LIBFDT && of_size) {
 		ret = image_setup_libfdt(images, *of_flat_tree, of_size, lmb);
 		if (ret)
 			return ret;
 	}
 	return 0;
 }
 #endif /* CONFIG_LMB */
 #endif /* !USE_HOSTCC */

include/image.h

Diff comments View file @ 39f520b

 /*
  * (C) Copyright 2008 Semihalf
  *
  * (C) Copyright 2000-2005
  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
  *
  * SPDX-License-Identifier:	GPL-2.0+
  ********************************************************************
  * 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".
  ********************************************************************
  */
 #ifndef __IMAGE_H__
 #define __IMAGE_H__
 #include "compiler.h"
 #include <asm/byteorder.h>
 /* Define this to avoid #ifdefs later on */
 struct lmb;
 #ifdef USE_HOSTCC
 /* new uImage format support enabled on host */
 #define CONFIG_FIT		1
 #define CONFIG_OF_LIBFDT	1
 #define CONFIG_FIT_VERBOSE	1 /* enable fit_format_{error,warning}() */
 #define IMAGE_ENABLE_IGNORE	0
 #define IMAGE_INDENT_STRING	""
 #else
 #include <lmb.h>
 #include <asm/u-boot.h>
 #include <command.h>
 /* Take notice of the 'ignore' property for hashes */
 #define IMAGE_ENABLE_IGNORE	1
 #define IMAGE_INDENT_STRING	"   "
 #endif /* USE_HOSTCC */
 #if defined(CONFIG_FIT)
 #include <hash.h>
 #include <libfdt.h>
 #include <fdt_support.h>
 # ifdef CONFIG_SPL_BUILD
 #  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
 # else
 #  define CONFIG_CRC32		/* FIT images need CRC32 support */
 #  define CONFIG_MD5		/* and MD5 */
 #  define CONFIG_SHA1		/* and SHA1 */
 #  define CONFIG_SHA256		/* and SHA256 */
 #  define IMAGE_ENABLE_CRC32	1
 #  define IMAGE_ENABLE_MD5	1
 #  define IMAGE_ENABLE_SHA1	1
 #  define IMAGE_ENABLE_SHA256	1
 # endif
 #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
 #endif /* CONFIG_FIT */
 #ifdef CONFIG_SYS_BOOT_RAMDISK_HIGH
 # define IMAGE_ENABLE_RAMDISK_HIGH	1
 #else
 # define IMAGE_ENABLE_RAMDISK_HIGH	0
 #endif
 #ifdef CONFIG_OF_LIBFDT
 # define IMAGE_ENABLE_OF_LIBFDT	1
 #else
 # define IMAGE_ENABLE_OF_LIBFDT	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
 /*
  * Operating System Codes
  */
 #define IH_OS_INVALID		0	/* Invalid OS	*/
 #define IH_OS_OPENBSD		1	/* OpenBSD	*/
 #define IH_OS_NETBSD		2	/* NetBSD	*/
 #define IH_OS_FREEBSD		3	/* FreeBSD	*/
 #define IH_OS_4_4BSD		4	/* 4.4BSD	*/
 #define IH_OS_LINUX		5	/* Linux	*/
 #define IH_OS_SVR4		6	/* SVR4		*/
 #define IH_OS_ESIX		7	/* Esix		*/
 #define IH_OS_SOLARIS		8	/* Solaris	*/
 #define IH_OS_IRIX		9	/* Irix		*/
 #define IH_OS_SCO		10	/* SCO		*/
 #define IH_OS_DELL		11	/* Dell		*/
 #define IH_OS_NCR		12	/* NCR		*/
 #define IH_OS_LYNXOS		13	/* LynxOS	*/
 #define IH_OS_VXWORKS		14	/* VxWorks	*/
 #define IH_OS_PSOS		15	/* pSOS		*/
 #define IH_OS_QNX		16	/* QNX		*/
 #define IH_OS_U_BOOT		17	/* Firmware	*/
 #define IH_OS_RTEMS		18	/* RTEMS	*/
 #define IH_OS_ARTOS		19	/* ARTOS	*/
 #define IH_OS_UNITY		20	/* Unity OS	*/
 #define IH_OS_INTEGRITY		21	/* INTEGRITY	*/
 #define IH_OS_OSE		22	/* OSE		*/
 #define IH_OS_PLAN9		23	/* Plan 9	*/
 #define IH_OS_OPENRTOS		24	/* OpenRTOS	*/
 /*
  * CPU Architecture Codes (supported by Linux)
  */
 #define IH_ARCH_INVALID		0	/* Invalid CPU	*/
 #define IH_ARCH_ALPHA		1	/* Alpha	*/
 #define IH_ARCH_ARM		2	/* ARM		*/
 #define IH_ARCH_I386		3	/* Intel x86	*/
 #define IH_ARCH_IA64		4	/* IA64		*/
 #define IH_ARCH_MIPS		5	/* MIPS		*/
 #define IH_ARCH_MIPS64		6	/* MIPS	 64 Bit */
 #define IH_ARCH_PPC		7	/* PowerPC	*/
 #define IH_ARCH_S390		8	/* IBM S390	*/
 #define IH_ARCH_SH		9	/* SuperH	*/
 #define IH_ARCH_SPARC		10	/* Sparc	*/
 #define IH_ARCH_SPARC64		11	/* Sparc 64 Bit */
 #define IH_ARCH_M68K		12	/* M68K		*/
 #define IH_ARCH_MICROBLAZE	14	/* MicroBlaze   */
 #define IH_ARCH_NIOS2		15	/* Nios-II	*/
 #define IH_ARCH_BLACKFIN	16	/* Blackfin	*/
 #define IH_ARCH_AVR32		17	/* AVR32	*/
 #define IH_ARCH_ST200	        18	/* STMicroelectronics ST200  */
 #define IH_ARCH_SANDBOX		19	/* Sandbox architecture (test only) */
 #define IH_ARCH_NDS32	        20	/* ANDES Technology - NDS32  */
 #define IH_ARCH_OPENRISC        21	/* OpenRISC 1000  */
 #define IH_ARCH_ARM64		22	/* ARM64	*/
 #define IH_ARCH_ARC		23	/* Synopsys DesignWare ARC */
 #define IH_ARCH_X86_64		24	/* AMD x86_64, Intel and Via */
 /*
  * 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
  *	a multiple of 4 bytes - except for the last file).
  *
  * "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)
  *	as command interpreter (=> Shell Scripts).
  */
 #define IH_TYPE_INVALID		0	/* Invalid Image		*/
 #define IH_TYPE_STANDALONE	1	/* Standalone Program		*/
 #define IH_TYPE_KERNEL		2	/* OS Kernel Image		*/
 #define IH_TYPE_RAMDISK		3	/* RAMDisk Image		*/
 #define IH_TYPE_MULTI		4	/* Multi-File Image		*/
 #define IH_TYPE_FIRMWARE	5	/* Firmware Image		*/
 #define IH_TYPE_SCRIPT		6	/* Script file			*/
 #define IH_TYPE_FILESYSTEM	7	/* Filesystem Image (any type)	*/
 #define IH_TYPE_FLATDT		8	/* Binary Flat Device Tree Blob	*/
 #define IH_TYPE_KWBIMAGE	9	/* Kirkwood Boot Image		*/
 #define IH_TYPE_IMXIMAGE	10	/* Freescale IMXBoot Image	*/
 #define IH_TYPE_UBLIMAGE	11	/* Davinci UBL Image		*/
 #define IH_TYPE_OMAPIMAGE	12	/* TI OMAP Config Header Image	*/
 #define IH_TYPE_AISIMAGE	13	/* TI Davinci AIS Image		*/
 #define IH_TYPE_KERNEL_NOLOAD	14	/* OS Kernel Image, can run from any load address */
 #define IH_TYPE_PBLIMAGE	15	/* Freescale PBL Boot Image	*/
 #define IH_TYPE_MXSIMAGE	16	/* Freescale MXSBoot Image	*/
 #define IH_TYPE_GPIMAGE		17	/* TI Keystone GPHeader Image	*/
 #define IH_TYPE_ATMELIMAGE	18	/* ATMEL ROM bootable Image	*/
 #define IH_TYPE_SOCFPGAIMAGE	19	/* Altera SOCFPGA Preloader	*/
 #define IH_TYPE_X86_SETUP	20	/* x86 setup.bin Image		*/
+#define IH_TYPE_LPC32XXIMAGE	21	/* x86 setup.bin Image		*/
 /*
  * Compression Types
  */
 #define IH_COMP_NONE		0	/*  No	 Compression Used	*/
 #define IH_COMP_GZIP		1	/* gzip	 Compression Used	*/
 #define IH_COMP_BZIP2		2	/* bzip2 Compression Used	*/
 #define IH_COMP_LZMA		3	/* lzma  Compression Used	*/
 #define IH_COMP_LZO		4	/* lzo   Compression Used	*/
 #define IH_MAGIC	0x27051956	/* Image Magic Number		*/
 #define IH_NMLEN		32	/* Image Name Length		*/
 /* Reused from common.h */
 #define ROUND(a, b)		(((a) + (b) - 1) & ~((b) - 1))
 /*
  * Legacy format image header,
  * all data in network byte order (aka natural aka bigendian).
  */
 typedef struct image_header {
 	__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	*/
 	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;
 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 */
 	uint8_t		arch;			/* CPU architecture */
 } image_info_t;
 /*
  * 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
 	 * then boot_get_ramdisk() and get_fdt() will attempt to get
 	 * data from second and third component accordingly.
 	 */
 	image_header_t	*legacy_hdr_os;		/* image header pointer */
 	image_header_t	legacy_hdr_os_copy;	/* header copy */
 	ulong		legacy_hdr_valid;
 #if defined(CONFIG_FIT)
 	const char	*fit_uname_cfg;	/* configuration node unit name */
 	void		*fit_hdr_os;	/* os FIT image header */
 	const char	*fit_uname_os;	/* os subimage node unit name */
 	int		fit_noffset_os;	/* os subimage node offset */
 	void		*fit_hdr_rd;	/* init ramdisk FIT image header */
 	const char	*fit_uname_rd;	/* init ramdisk subimage node unit name */
 	int		fit_noffset_rd;	/* init ramdisk subimage node offset */
 	void		*fit_hdr_fdt;	/* FDT blob FIT image header */
 	const char	*fit_uname_fdt;	/* FDT blob subimage node unit name */
 	int		fit_noffset_fdt;/* FDT blob subimage node offset */
 	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 */
 #endif
 #ifndef USE_HOSTCC
 	image_info_t	os;		/* os image info */
 	ulong		ep;		/* entry point of OS */
 	ulong		rd_start, rd_end;/* ramdisk start/end */
 	char		*ft_addr;	/* flat dev tree address */
 	ulong		ft_len;		/* length of flat device tree */
 	ulong		initrd_start;
 	ulong		initrd_end;
 	ulong		cmdline_start;
 	ulong		cmdline_end;
 	bd_t		*kbd;
 #endif
 	int		verify;		/* getenv("verify")[0] != 'n' */
 #define	BOOTM_STATE_START	(0x00000001)
 #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)
 #define	BOOTM_STATE_OS_FAKE_GO	(0x00000200)	/* 'Almost' run the OS */
 #define	BOOTM_STATE_OS_GO	(0x00000400)
 	int		state;
 #ifdef CONFIG_LMB
 	struct lmb	lmb;		/* for memory mgmt */
 #endif
 } bootm_headers_t;
 extern bootm_headers_t images;
 /*
  * Some systems (for example LWMON) have very short watchdog periods;
  * we must make sure to split long operations like memmove() or
  * checksum calculations into reasonable chunks.
  */
 #ifndef CHUNKSZ
 #define CHUNKSZ (64 * 1024)
 #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
 #define uimage_to_cpu(x)		be32_to_cpu(x)
 #define cpu_to_uimage(x)		cpu_to_be32(x)
 /*
  * 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.
  */
 int get_table_entry_id(const table_entry_t *table,
 		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.
  */
 char *get_table_entry_name(const table_entry_t *table, char *msg, int id);
 const char *genimg_get_os_name(uint8_t os);
 const char *genimg_get_arch_name(uint8_t arch);
 const char *genimg_get_type_name(uint8_t type);
 const char *genimg_get_comp_name(uint8_t comp);
 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);
 #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);
 /* 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 */
 	FIT_LOAD_OPTIONAL_NON_ZERO,	/* Optional, a value of 0 is ignored */
 	FIT_LOAD_REQUIRED,	/* Must be provided */
 };
 int boot_get_setup(bootm_headers_t *images, uint8_t arch, ulong *setup_start,
 		   ulong *setup_len);
 #ifndef USE_HOSTCC
 /* Image format types, returned by _get_format() routine */
 #define IMAGE_FORMAT_INVALID	0x00
 #if defined(CONFIG_IMAGE_FORMAT_LEGACY)
 #define IMAGE_FORMAT_LEGACY	0x01	/* legacy image_header based format */
 #endif
 #define IMAGE_FORMAT_FIT	0x02	/* new, libfdt based format */
 #define IMAGE_FORMAT_ANDROID	0x03	/* Android boot image */
 ulong genimg_get_kernel_addr_fit(char * const img_addr,
 			         const char **fit_uname_config,
 			         const char **fit_uname_kernel);
 ulong genimg_get_kernel_addr(char * const img_addr);
 int genimg_get_format(const void *img_addr);
 int genimg_has_config(bootm_headers_t *images);
 ulong genimg_get_image(ulong img_addr);
 int boot_get_ramdisk(int argc, char * const argv[], bootm_headers_t *images,
 		uint8_t arch, ulong *rd_start, ulong *rd_end);
 #endif
 int boot_get_setup_fit(bootm_headers_t *images, uint8_t arch,
 		       ulong *setup_start, ulong *setup_len);
 /**
  * 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.
  *
  * The property to look up is defined by image_type.
  *
  * @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 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
  * @return node offset of image, or -ve error code on error
  */
 int fit_image_load(bootm_headers_t *images, ulong addr,
 		   const char **fit_unamep, const char **fit_uname_configp,
 		   int arch, int image_type, int bootstage_id,
 		   enum fit_load_op load_op, ulong *datap, ulong *lenp);
 #ifndef USE_HOSTCC
 /**
  * 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);
 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);
 void boot_fdt_add_mem_rsv_regions(struct lmb *lmb, void *fdt_blob);
 int boot_relocate_fdt(struct lmb *lmb, char **of_flat_tree, ulong *of_size);
 int boot_ramdisk_high(struct lmb *lmb, ulong rd_data, ulong rd_len,
 		  ulong *initrd_start, ulong *initrd_end);
 int boot_get_cmdline(struct lmb *lmb, ulong *cmd_start, ulong *cmd_end);
 #ifdef CONFIG_SYS_BOOT_GET_KBD
 int boot_get_kbd(struct lmb *lmb, bd_t **kbd);
 #endif /* CONFIG_SYS_BOOT_GET_KBD */
 #endif /* !USE_HOSTCC */
 /*******************************************************************/
 /* Legacy format specific code (prefixed with image_) */
 /*******************************************************************/
 static inline uint32_t image_get_header_size(void)
 {
 	return (sizeof(image_header_t));
 }
 #define image_get_hdr_l(f) \
 	static inline uint32_t image_get_##f(const image_header_t *hdr) \
 	{ \
 		return uimage_to_cpu(hdr->ih_##f); \
 	}
 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 */
 #define image_get_hdr_b(f) \
 	static inline uint8_t image_get_##f(const image_header_t *hdr) \
 	{ \
 		return hdr->ih_##f; \
 	}
 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 */
 static inline char *image_get_name(const image_header_t *hdr)
 {
 	return (char *)hdr->ih_name;
 }
 static inline uint32_t image_get_data_size(const image_header_t *hdr)
 {
 	return image_get_size(hdr);
 }
 /**
  * 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
  */
 static inline ulong image_get_data(const image_header_t *hdr)
 {
 	return ((ulong)hdr + image_get_header_size());
 }
 static inline uint32_t image_get_image_size(const image_header_t *hdr)
 {
 	return (image_get_size(hdr) + image_get_header_size());
 }
 static inline ulong image_get_image_end(const image_header_t *hdr)
 {
 	return ((ulong)hdr + image_get_image_size(hdr));
 }
 #define image_set_hdr_l(f) \
 	static inline void image_set_##f(image_header_t *hdr, uint32_t val) \
 	{ \
 		hdr->ih_##f = cpu_to_uimage(val); \
 	}
 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 */
 #define image_set_hdr_b(f) \
 	static inline void image_set_##f(image_header_t *hdr, uint8_t val) \
 	{ \
 		hdr->ih_##f = val; \
 	}
 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 */
 static inline void image_set_name(image_header_t *hdr, const char *name)
 {
 	strncpy(image_get_name(hdr), name, IH_NMLEN);
 }
 int image_check_hcrc(const image_header_t *hdr);
 int image_check_dcrc(const image_header_t *hdr);
 #ifndef USE_HOSTCC
 ulong getenv_bootm_low(void);
 phys_size_t getenv_bootm_size(void);
 phys_size_t getenv_bootm_mapsize(void);
 #endif
 void memmove_wd(void *to, void *from, size_t len, ulong chunksz);
 static inline int image_check_magic(const image_header_t *hdr)
 {
 	return (image_get_magic(hdr) == IH_MAGIC);
 }
 static inline int image_check_type(const image_header_t *hdr, uint8_t type)
 {
 	return (image_get_type(hdr) == type);
 }
 static inline int image_check_arch(const image_header_t *hdr, uint8_t arch)
 {
 	return (image_get_arch(hdr) == arch);
 }
 static inline int image_check_os(const image_header_t *hdr, uint8_t os)
 {
 	return (image_get_os(hdr) == os);
 }
 ulong image_multi_count(const image_header_t *hdr);
 void image_multi_getimg(const image_header_t *hdr, ulong idx,
 			ulong *data, ulong *len);
 void image_print_contents(const void *hdr);
 #ifndef USE_HOSTCC
 static inline int image_check_target_arch(const image_header_t *hdr)
 {
 #ifndef IH_ARCH_DEFAULT
 # error "please define IH_ARCH_DEFAULT in your arch asm/u-boot.h"
 #endif
 	return image_check_arch(hdr, IH_ARCH_DEFAULT);
 }
 #endif /* USE_HOSTCC */
 /**
  * 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);
 /**
  * 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);
 /*******************************************************************/
 /* New uImage format specific code (prefixed with fit_) */
 /*******************************************************************/
 #if defined(CONFIG_FIT)
 #define FIT_IMAGES_PATH		"/images"
 #define FIT_CONFS_PATH		"/configurations"
 /* hash/signature node */
 #define FIT_HASH_NODENAME	"hash"
 #define FIT_ALGO_PROP		"algo"
 #define FIT_VALUE_PROP		"value"
 #define FIT_IGNORE_PROP		"uboot-ignore"
 #define FIT_SIG_NODENAME	"signature"
 /* 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"
 #define FIT_DEFAULT_PROP	"default"
 #define FIT_SETUP_PROP		"setup"
 #define FIT_MAX_HASH_LEN	HASH_MAX_DIGEST_SIZE
 /* cmdline argument format parsing */
 int fit_parse_conf(const char *spec, ulong addr_curr,
 		ulong *addr, const char **conf_name);
 int fit_parse_subimage(const char *spec, ulong addr_curr,
 		ulong *addr, const char **image_name);
 int fit_get_subimage_count(const void *fit, int images_noffset);
 void fit_print_contents(const void *fit);
 void fit_image_print(const void *fit, int noffset, const char *p);
 /**
  * fit_get_end - get FIT image size
  * @fit: pointer to the FIT format image header
  *
  * returns:
  *     size of the FIT image (blob) in memory
  */
 static inline ulong fit_get_size(const void *fit)
 {
 	return fdt_totalsize(fit);
 }
 /**
  * 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
  */
 static inline ulong fit_get_end(const void *fit)
 {
 	return (ulong)fit + fdt_totalsize(fit);
 }
 /**
  * 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
  */
 static inline const char *fit_get_name(const void *fit_hdr,
 		int noffset, int *len)
 {
 	return fdt_get_name(fit_hdr, noffset, len);
 }
 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,
 				const void **data, size_t *size);
 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,
 				int *value_len);
 int fit_set_timestamp(void *fit, int noffset, time_t timestamp);
 /**
  * fit_add_verification_data() - add verification data to FIT image nodes
  *
  * @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
  */
 int fit_add_verification_data(const char *keydir, void *keydest, void *fit,
 			      const char *comment, int require_keys);
 int fit_image_verify(const void *fit, int noffset);
 int fit_config_verify(const void *fit, int conf_noffset);
 int fit_all_image_verify(const void *fit);
 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);
 int fit_conf_find_compat(const void *fit, const void *fdt);
 int fit_conf_get_node(const void *fit, const char *conf_uname);
 /**
  * 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);
 void fit_conf_print(const void *fit, int noffset, const char *p);
 int fit_check_ramdisk(const void *fit, int os_noffset,
 		uint8_t arch, int verify);
 int calculate_hash(const void *data, int data_len, const char *algo,
 			uint8_t *value, int *value_len);
 /*
  * At present we only support signing on the host, and verification on the
  * device
  */
 #if defined(CONFIG_FIT_SIGNATURE)
 # ifdef USE_HOSTCC
 #  define IMAGE_ENABLE_SIGN	1
 #  define IMAGE_ENABLE_VERIFY	1
 # include  <openssl/evp.h>
 #else
 #  define IMAGE_ENABLE_SIGN	0
 #  define IMAGE_ENABLE_VERIFY	1
 # endif
 #else
 # define IMAGE_ENABLE_SIGN	0
 # define IMAGE_ENABLE_VERIFY	0
 #endif
 #ifdef USE_HOSTCC
 void *image_get_host_blob(void);
 void image_set_host_blob(void *host_blob);
 # define gd_fdt_blob()		image_get_host_blob()
 #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
 /* 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 */
 	struct image_sig_algo *algo;	/* Algorithm information */
 	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 */
 };
 /* A part of an image, used for hashing */
 struct image_region {
 	const void *data;
 	int size;
 };
 #if IMAGE_ENABLE_VERIFY
 # include <u-boot/rsa-checksum.h>
 #endif
 struct checksum_algo {
 	const char *name;
 	const int checksum_len;
 	const int pad_len;
 #if IMAGE_ENABLE_SIGN
 	const EVP_MD *(*calculate_sign)(void);
 #endif
 	int (*calculate)(const char *name,
 			 const struct image_region region[],
 			 int region_count, uint8_t *checksum);
 	const uint8_t *rsa_padding;
 };
 struct image_sig_algo {
 	const char *name;		/* Name of algorithm */
 	/**
 	 * 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);
 	/* pointer to checksum algorithm */
 	struct checksum_algo *checksum;
 };
 /**
  * image_get_sig_algo() - Look up a signature algortihm
  *
  * @param name		Name of algorithm
  * @return pointer to algorithm information, or NULL if not found
  */
 struct image_sig_algo *image_get_sig_algo(const char *name);
 /**
  * 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);
 /**
  * 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);
 static inline int fit_image_check_target_arch(const void *fdt, int node)
 {
 #ifndef USE_HOSTCC
 	return fit_image_check_arch(fdt, node, IH_ARCH_DEFAULT);
 #else
 	return 0;
 #endif
 }
 #ifdef CONFIG_FIT_VERBOSE
 #define fit_unsupported(msg)	printf("! %s:%d " \
 				"FIT images not supported for '%s'\n", \
 				__FILE__, __LINE__, (msg))
 #define fit_unsupported_reset(msg)	printf("! %s:%d " \
 				"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 */
 #endif /* CONFIG_FIT */
 #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);
 #endif /* CONFIG_ANDROID_BOOT_IMAGE */
 #endif	/* __IMAGE_H__ */

tools/Makefile

Diff comments View file @ 39f520b

 #
 # (C) Copyright 2000-2006
 # Wolfgang Denk, DENX Software Engineering, wd@denx.de.
 #
 # SPDX-License-Identifier:	GPL-2.0+
 #
 # Enable all the config-independent tools
 ifneq ($(HOST_TOOLS_ALL),)
 CONFIG_LCD_LOGO = y
 CONFIG_CMD_LOADS = y
 CONFIG_CMD_NET = y
 CONFIG_XWAY_SWAP_BYTES = y
 CONFIG_NETCONSOLE = y
 CONFIG_SHA1_CHECK_UB_IMG = y
 endif
 subdir-$(HOST_TOOLS_ALL) += easylogo
 subdir-$(HOST_TOOLS_ALL) += gdb
 # Merge all the different vars for envcrc into one
 ENVCRC-$(CONFIG_ENV_IS_EMBEDDED) = y
 ENVCRC-$(CONFIG_ENV_IS_IN_DATAFLASH) = y
 ENVCRC-$(CONFIG_ENV_IS_IN_EEPROM) = y
 ENVCRC-$(CONFIG_ENV_IS_IN_FLASH) = y
 ENVCRC-$(CONFIG_ENV_IS_IN_ONENAND) = y
 ENVCRC-$(CONFIG_ENV_IS_IN_NAND) = y
 ENVCRC-$(CONFIG_ENV_IS_IN_NVRAM) = y
 ENVCRC-$(CONFIG_ENV_IS_IN_SPI_FLASH) = y
 CONFIG_BUILD_ENVCRC ?= $(ENVCRC-y)
 hostprogs-$(CONFIG_SPL_GENERATE_ATMEL_PMECC_HEADER) += atmel_pmecc_params
 # TODO: CONFIG_CMD_LICENSE does not work
 hostprogs-$(CONFIG_CMD_LICENSE) += bin2header
 hostprogs-$(CONFIG_LCD_LOGO) += bmp_logo
 hostprogs-$(CONFIG_VIDEO_LOGO) += bmp_logo
 HOSTCFLAGS_bmp_logo.o := -pedantic
 hostprogs-$(CONFIG_BUILD_ENVCRC) += envcrc
 envcrc-objs := envcrc.o lib/crc32.o common/env_embedded.o lib/sha1.o
 hostprogs-$(CONFIG_CMD_NET) += gen_eth_addr
 HOSTCFLAGS_gen_eth_addr.o := -pedantic
 hostprogs-$(CONFIG_CMD_LOADS) += img2srec
 HOSTCFLAGS_img2srec.o := -pedantic
 hostprogs-$(CONFIG_XWAY_SWAP_BYTES) += xway-swap-bytes
 HOSTCFLAGS_xway-swap-bytes.o := -pedantic
 hostprogs-y += mkenvimage
 mkenvimage-objs := mkenvimage.o os_support.o lib/crc32.o
 hostprogs-y += dumpimage mkimage
 hostprogs-$(CONFIG_FIT_SIGNATURE) += fit_info fit_check_sign
 FIT_SIG_OBJS-$(CONFIG_FIT_SIGNATURE) := common/image-sig.o
 # Flattened device tree objects
 LIBFDT_OBJS := $(addprefix lib/libfdt/, \
 			fdt.o fdt_ro.o fdt_rw.o fdt_strerror.o fdt_wip.o)
 RSA_OBJS-$(CONFIG_FIT_SIGNATURE) := $(addprefix lib/rsa/, \
 					rsa-sign.o rsa-verify.o rsa-checksum.o \
 					rsa-mod-exp.o)
 # common objs for dumpimage and mkimage
 dumpimage-mkimage-objs := aisimage.o \
 			atmelimage.o \
 			$(FIT_SIG_OBJS-y) \
 			common/bootm.o \
 			lib/crc32.o \
 			default_image.o \
 			lib/fdtdec_common.o \
 			lib/fdtdec.o \
 			fit_common.o \
 			fit_image.o \
 			gpimage.o \
 			gpimage-common.o \
 			common/image-fit.o \
 			image-host.o \
 			common/image.o \
 			imagetool.o \
 			imximage.o \
 			kwbimage.o \
 			lib/md5.o \
+			lpc32xximage.o \
 			mxsimage.o \
 			omapimage.o \
 			os_support.o \
 			pblimage.o \
 			pbl_crc32.o \
 			socfpgaimage.o \
 			lib/sha1.o \
 			lib/sha256.o \
 			common/hash.o \
 			ublimage.o \
 			$(LIBFDT_OBJS) \
 			$(RSA_OBJS-y)
 dumpimage-objs := $(dumpimage-mkimage-objs) dumpimage.o
 mkimage-objs   := $(dumpimage-mkimage-objs) mkimage.o
 fit_info-objs   := $(dumpimage-mkimage-objs) fit_info.o
 fit_check_sign-objs   := $(dumpimage-mkimage-objs) fit_check_sign.o
 # TODO(sjg@chromium.org): Is this correct on Mac OS?
 ifneq ($(CONFIG_MX23)$(CONFIG_MX28),)
 # Add CONFIG_MXS into host CFLAGS, so we can check whether or not register
 # the mxsimage support within tools/mxsimage.c .
 HOSTCFLAGS_mxsimage.o += -DCONFIG_MXS
 endif
 ifdef CONFIG_FIT_SIGNATURE
 # This affects include/image.h, but including the board config file
 # is tricky, so manually define this options here.
 HOST_EXTRACFLAGS	+= -DCONFIG_FIT_SIGNATURE
 endif
 ifdef CONFIG_SYS_SPI_U_BOOT_OFFS
 HOSTCFLAGS_kwbimage.o += -DCONFIG_SYS_SPI_U_BOOT_OFFS=$(CONFIG_SYS_SPI_U_BOOT_OFFS)
 endif
 # MXSImage needs LibSSL
 ifneq ($(CONFIG_MX23)$(CONFIG_MX28)$(CONFIG_FIT_SIGNATURE),)
 HOSTLOADLIBES_mkimage += -lssl -lcrypto
 endif
 HOSTLOADLIBES_dumpimage := $(HOSTLOADLIBES_mkimage)
 HOSTLOADLIBES_fit_info := $(HOSTLOADLIBES_mkimage)
 HOSTLOADLIBES_fit_check_sign := $(HOSTLOADLIBES_mkimage)
 hostprogs-$(CONFIG_EXYNOS5250) += mkexynosspl
 hostprogs-$(CONFIG_EXYNOS5420) += mkexynosspl
 HOSTCFLAGS_mkexynosspl.o := -pedantic
 ifdtool-objs := $(LIBFDT_OBJS) ifdtool.o
 hostprogs-$(CONFIG_X86) += ifdtool
 hostprogs-$(CONFIG_MX23) += mxsboot
 hostprogs-$(CONFIG_MX28) += mxsboot
 HOSTCFLAGS_mxsboot.o := -pedantic
 hostprogs-$(CONFIG_SUNXI) += mksunxiboot
 hostprogs-$(CONFIG_NETCONSOLE) += ncb
 hostprogs-$(CONFIG_SHA1_CHECK_UB_IMG) += ubsha1
 ubsha1-objs := os_support.o ubsha1.o lib/sha1.o
 HOSTCFLAGS_ubsha1.o := -pedantic
 hostprogs-$(CONFIG_KIRKWOOD) += kwboot
 hostprogs-$(CONFIG_ARMADA_XP) += kwboot
 hostprogs-y += proftool
 hostprogs-$(CONFIG_STATIC_RELA) += relocate-rela
 # We build some files with extra pedantic flags to try to minimize things
 # that won't build on some weird host compiler -- though there are lots of
 # exceptions for files that aren't complaint.
 HOSTCFLAGS_crc32.o := -pedantic
 HOSTCFLAGS_md5.o := -pedantic
 HOSTCFLAGS_sha1.o := -pedantic
 HOSTCFLAGS_sha256.o := -pedantic
 # Don't build by default
 #hostprogs-$(CONFIG_PPC) += mpc86x_clk
 #HOSTCFLAGS_mpc86x_clk.o := -pedantic
 quiet_cmd_wrap = WRAP    $@
 cmd_wrap = echo "\#include <../$(patsubst $(obj)/%,%,$@)>" >$@
 $(obj)/lib/%.c $(obj)/common/%.c:
 	$(call cmd,wrap)
 clean-dirs := lib common
 always := $(hostprogs-y)
 # Generated LCD/video logo
 LOGO_H = $(objtree)/include/bmp_logo.h
 LOGO_DATA_H = $(objtree)/include/bmp_logo_data.h
 LOGO-$(CONFIG_LCD_LOGO) += $(LOGO_H)
 LOGO-$(CONFIG_LCD_LOGO) += $(LOGO_DATA_H)
 LOGO-$(CONFIG_VIDEO_LOGO) += $(LOGO_H)
 LOGO-$(CONFIG_VIDEO_LOGO) += $(LOGO_DATA_H)
 # Generic logo
 ifeq ($(LOGO_BMP),)
 LOGO_BMP= $(srctree)/$(src)/logos/denx.bmp
 # Use board logo and fallback to vendor
 ifneq ($(wildcard $(srctree)/$(src)/logos/$(BOARD).bmp),)
 LOGO_BMP= $(srctree)/$(src)/logos/$(BOARD).bmp
 else
 ifneq ($(wildcard $(srctree)/$(src)/logos/$(VENDOR).bmp),)
 LOGO_BMP= $(srctree)/$(src)/logos/$(VENDOR).bmp
 endif
 endif
 endif # !LOGO_BMP
 #
 # Use native tools and options
 # Define __KERNEL_STRICT_NAMES to prevent typedef overlaps
 # Define _GNU_SOURCE to obtain the getline prototype from stdio.h
 #
 HOST_EXTRACFLAGS += -include $(srctree)/include/libfdt_env.h \
 		$(patsubst -I%,-idirafter%, $(filter -I%, $(UBOOTINCLUDE))) \
 		-I$(srctree)/lib/libfdt \
 		-I$(srctree)/tools \
 		-DCONFIG_SYS_TEXT_BASE=$(CONFIG_SYS_TEXT_BASE) \
 		-DUSE_HOSTCC \
 		-D__KERNEL_STRICT_NAMES \
 		-D_GNU_SOURCE
 __build:	$(LOGO-y)
 $(LOGO_H):	$(obj)/bmp_logo $(LOGO_BMP)
 	$(obj)/bmp_logo --gen-info $(LOGO_BMP) > $@
 $(LOGO_DATA_H):	$(obj)/bmp_logo $(LOGO_BMP)
 	$(obj)/bmp_logo --gen-data $(LOGO_BMP) > $@
 # Let clean descend into subdirs
 subdir- += env
 ifneq ($(CROSS_BUILD_TOOLS),)
 HOSTCC = $(CC)
 quiet_cmd_crosstools_strip = STRIP   $^
       cmd_crosstools_strip = $(STRIP) $^; touch $@
 $(obj)/.strip: $(call objectify,$(filter $(always),$(hostprogs-y)))
 	$(call cmd,crosstools_strip)
 always += .strip
 endif
 clean-files += .strip

tools/lpc32xximage.c

Diff comments View file @ 39f520b

File was created	1	/*
	2	* Image manipulator for LPC32XX SoCs
	3	*
	4	* (C) Copyright 2015 DENX Software Engineering GmbH
	5	* Written-by: Albert ARIBAUD <albert.aribaud@3adev.fr>
	6	*
	7	* Derived from omapimage.c:
	8	*
	9	* (C) Copyright 2010
	10	* Linaro LTD, www.linaro.org
	11	* Author: John Rigby <john.rigby@linaro.org>
	12	* Based on TI's signGP.c
	13	*
	14	* (C) Copyright 2009
	15	* Stefano Babic, DENX Software Engineering, sbabic@denx.de.
	16	*
	17	* (C) Copyright 2008
	18	* Marvell Semiconductor <www.marvell.com>
	19	* Written-by: Prafulla Wadaskar <prafulla@marvell.com>
	20	*
	21	* SPDX-License-Identifier: GPL-2.0+
	22	*/
	23
	24	#include "imagetool.h"
	25	#include <compiler.h>
	26	#include <image.h>
	27
	28	/*
	29	* NAND page 0 boot header
	30	*/
	31
	32	struct nand_page_0_boot_header {
	33	uint32_t data[129];
	34	uint32_t pad[383];
	35	};
	36
	37	/*
	38	* Default ICC (interface configuration data [sic]) if none specified
	39	* in board config
	40	*/
	41
	42	#ifndef LPC32XX_BOOT_ICR
	43	#define LPC32XX_BOOT_ICR 0x00000096
	44	#endif
	45
	46	/*
	47	* Default boot NAND page size if none specified in board config
	48	*/
	49
	50	#ifndef LPC32XX_BOOT_NAND_PAGESIZE
	51	#define LPC32XX_BOOT_NAND_PAGESIZE 2048
	52	#endif
	53
	54	/*
	55	* Default boot NAND pages per sector if none specified in board config
	56	*/
	57
	58	#ifndef LPC32XX_BOOT_NAND_PAGES_PER_SECTOR
	59	#define LPC32XX_BOOT_NAND_PAGES_PER_SECTOR 64
	60	#endif
	61
	62	/*
	63	* Maximum size for boot code is 56K unless defined in board config
	64	*/
	65
	66	#ifndef LPC32XX_BOOT_CODESIZE
	67	#define LPC32XX_BOOT_CODESIZE (56*1024)
	68	#endif
	69
	70	/* signature byte for a readable block */
	71
	72	#define LPC32XX_BOOT_BLOCK_OK 0xaa
	73
	74	static struct nand_page_0_boot_header lpc32xximage_header;
	75
	76	static int lpc32xximage_check_image_types(uint8_t type)
	77	{
	78	if (type == IH_TYPE_LPC32XXIMAGE)
	79	return EXIT_SUCCESS;
	80	return EXIT_FAILURE;
	81	}
	82
	83	static int lpc32xximage_verify_header(unsigned char *ptr, int image_size,
	84	struct image_tool_params *params)
	85	{
	86	struct nand_page_0_boot_header *hdr =
	87	(struct nand_page_0_boot_header *)ptr;
	88
	89	/* turn image size from bytes to NAND pages, page 0 included */
	90	int image_size_in_pages = ((image_size - 1)
	91	/ LPC32XX_BOOT_NAND_PAGESIZE);
	92
	93	if (hdr->data[0] != (0xff & LPC32XX_BOOT_ICR))
	94	return -1;
	95	if (hdr->data[1] != (0xff & ~LPC32XX_BOOT_ICR))
	96	return -1;
	97	if (hdr->data[2] != (0xff & LPC32XX_BOOT_ICR))
	98	return -1;
	99	if (hdr->data[3] != (0xff & ~LPC32XX_BOOT_ICR))
	100	return -1;
	101	if (hdr->data[4] != (0xff & image_size_in_pages))
	102	return -1;
	103	if (hdr->data[5] != (0xff & ~image_size_in_pages))
	104	return -1;
	105	if (hdr->data[6] != (0xff & image_size_in_pages))
	106	return -1;
	107	if (hdr->data[7] != (0xff & ~image_size_in_pages))
	108	return -1;
	109	if (hdr->data[8] != (0xff & image_size_in_pages))
	110	return -1;
	111	if (hdr->data[9] != (0xff & ~image_size_in_pages))
	112	return -1;
	113	if (hdr->data[10] != (0xff & image_size_in_pages))
	114	return -1;
	115	if (hdr->data[11] != (0xff & ~image_size_in_pages))
	116	return -1;
	117	if (hdr->data[12] != LPC32XX_BOOT_BLOCK_OK)
	118	return -1;
	119	if (hdr->data[128] != LPC32XX_BOOT_BLOCK_OK)
	120	return -1;
	121	return 0;
	122	}
	123
	124	static void print_hdr_byte(struct nand_page_0_boot_header *hdr, int ofs)
	125	{
	126	printf("header[%d] = %02x\n", ofs, hdr->data[ofs]);
	127	}
	128
	129	static void lpc32xximage_print_header(const void *ptr)
	130	{
	131	struct nand_page_0_boot_header *hdr =
	132	(struct nand_page_0_boot_header *)ptr;
	133	int ofs;
	134
	135	for (ofs = 0; ofs <= 12; ofs++)
	136	print_hdr_byte(hdr, ofs);
	137	print_hdr_byte(hdr, 128);
	138	}
	139
	140	static void lpc32xximage_set_header(void ptr, struct stat sbuf, int ifd,
	141	struct image_tool_params *params)
	142	{
	143	struct nand_page_0_boot_header *hdr =
	144	(struct nand_page_0_boot_header *)ptr;
	145
	146	/* turn image size from bytes to NAND pages, page 0 included */
	147	int image_size_in_pages = ((sbuf->st_size
	148	+ LPC32XX_BOOT_NAND_PAGESIZE - 1)
	149	/ LPC32XX_BOOT_NAND_PAGESIZE);
	150
	151	/* fill header -- default byte value is 0x00, not 0xFF */
	152	memset((void )hdr, 0, sizeof(hdr));
	153	hdr->data[0] = (hdr->data[2] = 0xff & LPC32XX_BOOT_ICR);
	154	hdr->data[1] = (hdr->data[3] = 0xff & ~LPC32XX_BOOT_ICR);
	155	hdr->data[4] = (hdr->data[6] = (hdr->data[8]
	156	= (hdr->data[10] = 0xff & image_size_in_pages)));
	157	hdr->data[5] = (hdr->data[7] = (hdr->data[9]
	158	= (hdr->data[11] = 0xff & ~image_size_in_pages)));
	159	hdr->data[12] = (hdr->data[128] = LPC32XX_BOOT_BLOCK_OK);
	160	}
	161
	162	/*
	163	* lpc32xximage parameters
	164	*/
	165	U_BOOT_IMAGE_TYPE(
	166	lpc32xximage,
	167	"LPC32XX Boot Image",
	168	sizeof(lpc32xximage_header),
	169	(void *)&lpc32xximage_header,
	170	NULL,
	171	lpc32xximage_verify_header,
	172	lpc32xximage_print_header,
	173	lpc32xximage_set_header,
	174	NULL,
	175	lpc32xximage_check_image_types,
	176	NULL,
	177	NULL
	178	);
	179