xref: /openbmc/u-boot/common/image.c (revision 834a45d7ee81ef185cc834b44b2dae7b637631e2)
1 /*
2  * (C) Copyright 2008 Semihalf
3  *
4  * (C) Copyright 2000-2006
5  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
6  *
7  * See file CREDITS for list of people who contributed to this
8  * project.
9  *
10  * This program is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU General Public License as
12  * published by the Free Software Foundation; either version 2 of
13  * the License, or (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
23  * MA 02111-1307 USA
24  */
25 
26 #ifndef USE_HOSTCC
27 #include <common.h>
28 #include <watchdog.h>
29 
30 #ifdef CONFIG_SHOW_BOOT_PROGRESS
31 #include <status_led.h>
32 #endif
33 
34 #ifdef CONFIG_HAS_DATAFLASH
35 #include <dataflash.h>
36 #endif
37 
38 #ifdef CONFIG_LOGBUFFER
39 #include <logbuff.h>
40 #endif
41 
42 #if defined(CONFIG_TIMESTAMP) || defined(CONFIG_CMD_DATE)
43 #include <rtc.h>
44 #endif
45 
46 #include <image.h>
47 
48 #if defined(CONFIG_FIT) || defined (CONFIG_OF_LIBFDT)
49 #include <fdt.h>
50 #include <libfdt.h>
51 #include <fdt_support.h>
52 #endif
53 
54 #if defined(CONFIG_FIT)
55 #include <u-boot/md5.h>
56 #include <sha1.h>
57 
58 static int fit_check_ramdisk (const void *fit, int os_noffset,
59 		uint8_t arch, int verify);
60 #endif
61 
62 #ifdef CONFIG_CMD_BDI
63 extern int do_bdinfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
64 #endif
65 
66 DECLARE_GLOBAL_DATA_PTR;
67 
68 static const image_header_t* image_get_ramdisk (ulong rd_addr, uint8_t arch,
69 						int verify);
70 #else
71 #include "mkimage.h"
72 #include <u-boot/md5.h>
73 #include <time.h>
74 #include <image.h>
75 #endif /* !USE_HOSTCC*/
76 
77 static table_entry_t uimage_arch[] = {
78 	{	IH_ARCH_INVALID,	NULL,		"Invalid ARCH",	},
79 	{	IH_ARCH_ALPHA,		"alpha",	"Alpha",	},
80 	{	IH_ARCH_ARM,		"arm",		"ARM",		},
81 	{	IH_ARCH_I386,		"x86",		"Intel x86",	},
82 	{	IH_ARCH_IA64,		"ia64",		"IA64",		},
83 	{	IH_ARCH_M68K,		"m68k",		"M68K",		},
84 	{	IH_ARCH_MICROBLAZE,	"microblaze",	"MicroBlaze",	},
85 	{	IH_ARCH_MIPS,		"mips",		"MIPS",		},
86 	{	IH_ARCH_MIPS64,		"mips64",	"MIPS 64 Bit",	},
87 	{	IH_ARCH_NIOS2,		"nios2",	"NIOS II",	},
88 	{	IH_ARCH_PPC,		"powerpc",	"PowerPC",	},
89 	{	IH_ARCH_PPC,		"ppc",		"PowerPC",	},
90 	{	IH_ARCH_S390,		"s390",		"IBM S390",	},
91 	{	IH_ARCH_SH,		"sh",		"SuperH",	},
92 	{	IH_ARCH_SPARC,		"sparc",	"SPARC",	},
93 	{	IH_ARCH_SPARC64,	"sparc64",	"SPARC 64 Bit",	},
94 	{	IH_ARCH_BLACKFIN,	"blackfin",	"Blackfin",	},
95 	{	IH_ARCH_AVR32,		"avr32",	"AVR32",	},
96 	{	-1,			"",		"",		},
97 };
98 
99 static table_entry_t uimage_os[] = {
100 	{	IH_OS_INVALID,	NULL,		"Invalid OS",		},
101 	{	IH_OS_LINUX,	"linux",	"Linux",		},
102 #if defined(CONFIG_LYNXKDI) || defined(USE_HOSTCC)
103 	{	IH_OS_LYNXOS,	"lynxos",	"LynxOS",		},
104 #endif
105 	{	IH_OS_NETBSD,	"netbsd",	"NetBSD",		},
106 	{	IH_OS_OSE,	"ose",		"Enea OSE",		},
107 	{	IH_OS_RTEMS,	"rtems",	"RTEMS",		},
108 	{	IH_OS_U_BOOT,	"u-boot",	"U-Boot",		},
109 #if defined(CONFIG_CMD_ELF) || defined(USE_HOSTCC)
110 	{	IH_OS_QNX,	"qnx",		"QNX",			},
111 	{	IH_OS_VXWORKS,	"vxworks",	"VxWorks",		},
112 #endif
113 #if defined(CONFIG_INTEGRITY) || defined(USE_HOSTCC)
114 	{	IH_OS_INTEGRITY,"integrity",	"INTEGRITY",		},
115 #endif
116 #ifdef USE_HOSTCC
117 	{	IH_OS_4_4BSD,	"4_4bsd",	"4_4BSD",		},
118 	{	IH_OS_DELL,	"dell",		"Dell",			},
119 	{	IH_OS_ESIX,	"esix",		"Esix",			},
120 	{	IH_OS_FREEBSD,	"freebsd",	"FreeBSD",		},
121 	{	IH_OS_IRIX,	"irix",		"Irix",			},
122 	{	IH_OS_NCR,	"ncr",		"NCR",			},
123 	{	IH_OS_OPENBSD,	"openbsd",	"OpenBSD",		},
124 	{	IH_OS_PSOS,	"psos",		"pSOS",			},
125 	{	IH_OS_SCO,	"sco",		"SCO",			},
126 	{	IH_OS_SOLARIS,	"solaris",	"Solaris",		},
127 	{	IH_OS_SVR4,	"svr4",		"SVR4",			},
128 #endif
129 	{	-1,		"",		"",			},
130 };
131 
132 static table_entry_t uimage_type[] = {
133 	{	IH_TYPE_INVALID,    NULL,	  "Invalid Image",	},
134 	{	IH_TYPE_FILESYSTEM, "filesystem", "Filesystem Image",	},
135 	{	IH_TYPE_FIRMWARE,   "firmware",	  "Firmware",		},
136 	{	IH_TYPE_KERNEL,	    "kernel",	  "Kernel Image",	},
137 	{	IH_TYPE_MULTI,	    "multi",	  "Multi-File Image",	},
138 	{	IH_TYPE_RAMDISK,    "ramdisk",	  "RAMDisk Image",	},
139 	{	IH_TYPE_SCRIPT,     "script",	  "Script",		},
140 	{	IH_TYPE_STANDALONE, "standalone", "Standalone Program", },
141 	{	IH_TYPE_FLATDT,     "flat_dt",    "Flat Device Tree",	},
142 	{	IH_TYPE_KWBIMAGE,   "kwbimage",   "Kirkwood Boot Image",},
143 	{	IH_TYPE_IMXIMAGE,   "imximage",   "Freescale i.MX Boot Image",},
144 	{	-1,		    "",		  "",			},
145 };
146 
147 static table_entry_t uimage_comp[] = {
148 	{	IH_COMP_NONE,	"none",		"uncompressed",		},
149 	{	IH_COMP_BZIP2,	"bzip2",	"bzip2 compressed",	},
150 	{	IH_COMP_GZIP,	"gzip",		"gzip compressed",	},
151 	{	IH_COMP_LZMA,	"lzma",		"lzma compressed",	},
152 	{	IH_COMP_LZO,	"lzo",		"lzo compressed",	},
153 	{	-1,		"",		"",			},
154 };
155 
156 uint32_t crc32 (uint32_t, const unsigned char *, uint);
157 uint32_t crc32_wd (uint32_t, const unsigned char *, uint, uint);
158 #if defined(CONFIG_TIMESTAMP) || defined(CONFIG_CMD_DATE) || defined(USE_HOSTCC)
159 static void genimg_print_time (time_t timestamp);
160 #endif
161 
162 /*****************************************************************************/
163 /* Legacy format routines */
164 /*****************************************************************************/
165 int image_check_hcrc (const image_header_t *hdr)
166 {
167 	ulong hcrc;
168 	ulong len = image_get_header_size ();
169 	image_header_t header;
170 
171 	/* Copy header so we can blank CRC field for re-calculation */
172 	memmove (&header, (char *)hdr, image_get_header_size ());
173 	image_set_hcrc (&header, 0);
174 
175 	hcrc = crc32 (0, (unsigned char *)&header, len);
176 
177 	return (hcrc == image_get_hcrc (hdr));
178 }
179 
180 int image_check_dcrc (const image_header_t *hdr)
181 {
182 	ulong data = image_get_data (hdr);
183 	ulong len = image_get_data_size (hdr);
184 	ulong dcrc = crc32_wd (0, (unsigned char *)data, len, CHUNKSZ_CRC32);
185 
186 	return (dcrc == image_get_dcrc (hdr));
187 }
188 
189 /**
190  * image_multi_count - get component (sub-image) count
191  * @hdr: pointer to the header of the multi component image
192  *
193  * image_multi_count() returns number of components in a multi
194  * component image.
195  *
196  * Note: no checking of the image type is done, caller must pass
197  * a valid multi component image.
198  *
199  * returns:
200  *     number of components
201  */
202 ulong image_multi_count (const image_header_t *hdr)
203 {
204 	ulong i, count = 0;
205 	uint32_t *size;
206 
207 	/* get start of the image payload, which in case of multi
208 	 * component images that points to a table of component sizes */
209 	size = (uint32_t *)image_get_data (hdr);
210 
211 	/* count non empty slots */
212 	for (i = 0; size[i]; ++i)
213 		count++;
214 
215 	return count;
216 }
217 
218 /**
219  * image_multi_getimg - get component data address and size
220  * @hdr: pointer to the header of the multi component image
221  * @idx: index of the requested component
222  * @data: pointer to a ulong variable, will hold component data address
223  * @len: pointer to a ulong variable, will hold component size
224  *
225  * image_multi_getimg() returns size and data address for the requested
226  * component in a multi component image.
227  *
228  * Note: no checking of the image type is done, caller must pass
229  * a valid multi component image.
230  *
231  * returns:
232  *     data address and size of the component, if idx is valid
233  *     0 in data and len, if idx is out of range
234  */
235 void image_multi_getimg (const image_header_t *hdr, ulong idx,
236 			ulong *data, ulong *len)
237 {
238 	int i;
239 	uint32_t *size;
240 	ulong offset, count, img_data;
241 
242 	/* get number of component */
243 	count = image_multi_count (hdr);
244 
245 	/* get start of the image payload, which in case of multi
246 	 * component images that points to a table of component sizes */
247 	size = (uint32_t *)image_get_data (hdr);
248 
249 	/* get address of the proper component data start, which means
250 	 * skipping sizes table (add 1 for last, null entry) */
251 	img_data = image_get_data (hdr) + (count + 1) * sizeof (uint32_t);
252 
253 	if (idx < count) {
254 		*len = uimage_to_cpu (size[idx]);
255 		offset = 0;
256 
257 		/* go over all indices preceding requested component idx */
258 		for (i = 0; i < idx; i++) {
259 			/* add up i-th component size, rounding up to 4 bytes */
260 			offset += (uimage_to_cpu (size[i]) + 3) & ~3 ;
261 		}
262 
263 		/* calculate idx-th component data address */
264 		*data = img_data + offset;
265 	} else {
266 		*len = 0;
267 		*data = 0;
268 	}
269 }
270 
271 static void image_print_type (const image_header_t *hdr)
272 {
273 	const char *os, *arch, *type, *comp;
274 
275 	os = genimg_get_os_name (image_get_os (hdr));
276 	arch = genimg_get_arch_name (image_get_arch (hdr));
277 	type = genimg_get_type_name (image_get_type (hdr));
278 	comp = genimg_get_comp_name (image_get_comp (hdr));
279 
280 	printf ("%s %s %s (%s)\n", arch, os, type, comp);
281 }
282 
283 /**
284  * image_print_contents - prints out the contents of the legacy format image
285  * @ptr: pointer to the legacy format image header
286  * @p: pointer to prefix string
287  *
288  * image_print_contents() formats a multi line legacy image contents description.
289  * The routine prints out all header fields followed by the size/offset data
290  * for MULTI/SCRIPT images.
291  *
292  * returns:
293  *     no returned results
294  */
295 void image_print_contents (const void *ptr)
296 {
297 	const image_header_t *hdr = (const image_header_t *)ptr;
298 	const char *p;
299 
300 #ifdef USE_HOSTCC
301 	p = "";
302 #else
303 	p = "   ";
304 #endif
305 
306 	printf ("%sImage Name:   %.*s\n", p, IH_NMLEN, image_get_name (hdr));
307 #if defined(CONFIG_TIMESTAMP) || defined(CONFIG_CMD_DATE) || defined(USE_HOSTCC)
308 	printf ("%sCreated:      ", p);
309 	genimg_print_time ((time_t)image_get_time (hdr));
310 #endif
311 	printf ("%sImage Type:   ", p);
312 	image_print_type (hdr);
313 	printf ("%sData Size:    ", p);
314 	genimg_print_size (image_get_data_size (hdr));
315 	printf ("%sLoad Address: %08x\n", p, image_get_load (hdr));
316 	printf ("%sEntry Point:  %08x\n", p, image_get_ep (hdr));
317 
318 	if (image_check_type (hdr, IH_TYPE_MULTI) ||
319 			image_check_type (hdr, IH_TYPE_SCRIPT)) {
320 		int i;
321 		ulong data, len;
322 		ulong count = image_multi_count (hdr);
323 
324 		printf ("%sContents:\n", p);
325 		for (i = 0; i < count; i++) {
326 			image_multi_getimg (hdr, i, &data, &len);
327 
328 			printf ("%s   Image %d: ", p, i);
329 			genimg_print_size (len);
330 
331 			if (image_check_type (hdr, IH_TYPE_SCRIPT) && i > 0) {
332 				/*
333 				 * the user may need to know offsets
334 				 * if planning to do something with
335 				 * multiple files
336 				 */
337 				printf ("%s    Offset = 0x%08lx\n", p, data);
338 			}
339 		}
340 	}
341 }
342 
343 
344 #ifndef USE_HOSTCC
345 /**
346  * image_get_ramdisk - get and verify ramdisk image
347  * @rd_addr: ramdisk image start address
348  * @arch: expected ramdisk architecture
349  * @verify: checksum verification flag
350  *
351  * image_get_ramdisk() returns a pointer to the verified ramdisk image
352  * header. Routine receives image start address and expected architecture
353  * flag. Verification done covers data and header integrity and os/type/arch
354  * fields checking.
355  *
356  * If dataflash support is enabled routine checks for dataflash addresses
357  * and handles required dataflash reads.
358  *
359  * returns:
360  *     pointer to a ramdisk image header, if image was found and valid
361  *     otherwise, return NULL
362  */
363 static const image_header_t *image_get_ramdisk (ulong rd_addr, uint8_t arch,
364 						int verify)
365 {
366 	const image_header_t *rd_hdr = (const image_header_t *)rd_addr;
367 
368 	if (!image_check_magic (rd_hdr)) {
369 		puts ("Bad Magic Number\n");
370 		show_boot_progress (-10);
371 		return NULL;
372 	}
373 
374 	if (!image_check_hcrc (rd_hdr)) {
375 		puts ("Bad Header Checksum\n");
376 		show_boot_progress (-11);
377 		return NULL;
378 	}
379 
380 	show_boot_progress (10);
381 	image_print_contents (rd_hdr);
382 
383 	if (verify) {
384 		puts("   Verifying Checksum ... ");
385 		if (!image_check_dcrc (rd_hdr)) {
386 			puts ("Bad Data CRC\n");
387 			show_boot_progress (-12);
388 			return NULL;
389 		}
390 		puts("OK\n");
391 	}
392 
393 	show_boot_progress (11);
394 
395 	if (!image_check_os (rd_hdr, IH_OS_LINUX) ||
396 	    !image_check_arch (rd_hdr, arch) ||
397 	    !image_check_type (rd_hdr, IH_TYPE_RAMDISK)) {
398 		printf ("No Linux %s Ramdisk Image\n",
399 				genimg_get_arch_name(arch));
400 		show_boot_progress (-13);
401 		return NULL;
402 	}
403 
404 	return rd_hdr;
405 }
406 #endif /* !USE_HOSTCC */
407 
408 /*****************************************************************************/
409 /* Shared dual-format routines */
410 /*****************************************************************************/
411 #ifndef USE_HOSTCC
412 int getenv_yesno (char *var)
413 {
414 	char *s = getenv (var);
415 	return (s && (*s == 'n')) ? 0 : 1;
416 }
417 
418 ulong getenv_bootm_low(void)
419 {
420 	char *s = getenv ("bootm_low");
421 	if (s) {
422 		ulong tmp = simple_strtoul (s, NULL, 16);
423 		return tmp;
424 	}
425 
426 #if defined(CONFIG_SYS_SDRAM_BASE)
427 	return CONFIG_SYS_SDRAM_BASE;
428 #elif defined(CONFIG_ARM)
429 	return gd->bd->bi_dram[0].start;
430 #else
431 	return 0;
432 #endif
433 }
434 
435 phys_size_t getenv_bootm_size(void)
436 {
437 	phys_size_t tmp;
438 	char *s = getenv ("bootm_size");
439 	if (s) {
440 		tmp = (phys_size_t)simple_strtoull (s, NULL, 16);
441 		return tmp;
442 	}
443 	s = getenv("bootm_low");
444 	if (s)
445 		tmp = (phys_size_t)simple_strtoull (s, NULL, 16);
446 	else
447 		tmp = 0;
448 
449 
450 #if defined(CONFIG_ARM)
451 	return gd->bd->bi_dram[0].size - tmp;
452 #else
453 	return gd->bd->bi_memsize - tmp;
454 #endif
455 }
456 
457 void memmove_wd (void *to, void *from, size_t len, ulong chunksz)
458 {
459 	if (to == from)
460 		return;
461 
462 #if defined(CONFIG_HW_WATCHDOG) || defined(CONFIG_WATCHDOG)
463 	while (len > 0) {
464 		size_t tail = (len > chunksz) ? chunksz : len;
465 		WATCHDOG_RESET ();
466 		memmove (to, from, tail);
467 		to += tail;
468 		from += tail;
469 		len -= tail;
470 	}
471 #else	/* !(CONFIG_HW_WATCHDOG || CONFIG_WATCHDOG) */
472 	memmove (to, from, len);
473 #endif	/* CONFIG_HW_WATCHDOG || CONFIG_WATCHDOG */
474 }
475 #endif /* !USE_HOSTCC */
476 
477 void genimg_print_size (uint32_t size)
478 {
479 #ifndef USE_HOSTCC
480 	printf ("%d Bytes = ", size);
481 	print_size (size, "\n");
482 #else
483 	printf ("%d Bytes = %.2f kB = %.2f MB\n",
484 			size, (double)size / 1.024e3,
485 			(double)size / 1.048576e6);
486 #endif
487 }
488 
489 #if defined(CONFIG_TIMESTAMP) || defined(CONFIG_CMD_DATE) || defined(USE_HOSTCC)
490 static void genimg_print_time (time_t timestamp)
491 {
492 #ifndef USE_HOSTCC
493 	struct rtc_time tm;
494 
495 	to_tm (timestamp, &tm);
496 	printf ("%4d-%02d-%02d  %2d:%02d:%02d UTC\n",
497 			tm.tm_year, tm.tm_mon, tm.tm_mday,
498 			tm.tm_hour, tm.tm_min, tm.tm_sec);
499 #else
500 	printf ("%s", ctime(&timestamp));
501 #endif
502 }
503 #endif /* CONFIG_TIMESTAMP || CONFIG_CMD_DATE || USE_HOSTCC */
504 
505 /**
506  * get_table_entry_name - translate entry id to long name
507  * @table: pointer to a translation table for entries of a specific type
508  * @msg: message to be returned when translation fails
509  * @id: entry id to be translated
510  *
511  * get_table_entry_name() will go over translation table trying to find
512  * entry that matches given id. If matching entry is found, its long
513  * name is returned to the caller.
514  *
515  * returns:
516  *     long entry name if translation succeeds
517  *     msg otherwise
518  */
519 char *get_table_entry_name (table_entry_t *table, char *msg, int id)
520 {
521 	for (; table->id >= 0; ++table) {
522 		if (table->id == id)
523 #if defined(USE_HOSTCC) || defined(CONFIG_RELOC_FIXUP_WORKS)
524 			return table->lname;
525 #else
526 			return table->lname + gd->reloc_off;
527 #endif
528 	}
529 	return (msg);
530 }
531 
532 const char *genimg_get_os_name (uint8_t os)
533 {
534 	return (get_table_entry_name (uimage_os, "Unknown OS", os));
535 }
536 
537 const char *genimg_get_arch_name (uint8_t arch)
538 {
539 	return (get_table_entry_name (uimage_arch, "Unknown Architecture", arch));
540 }
541 
542 const char *genimg_get_type_name (uint8_t type)
543 {
544 	return (get_table_entry_name (uimage_type, "Unknown Image", type));
545 }
546 
547 const char *genimg_get_comp_name (uint8_t comp)
548 {
549 	return (get_table_entry_name (uimage_comp, "Unknown Compression", comp));
550 }
551 
552 /**
553  * get_table_entry_id - translate short entry name to id
554  * @table: pointer to a translation table for entries of a specific type
555  * @table_name: to be used in case of error
556  * @name: entry short name to be translated
557  *
558  * get_table_entry_id() will go over translation table trying to find
559  * entry that matches given short name. If matching entry is found,
560  * its id returned to the caller.
561  *
562  * returns:
563  *     entry id if translation succeeds
564  *     -1 otherwise
565  */
566 int get_table_entry_id (table_entry_t *table,
567 		const char *table_name, const char *name)
568 {
569 	table_entry_t *t;
570 #ifdef USE_HOSTCC
571 	int first = 1;
572 
573 	for (t = table; t->id >= 0; ++t) {
574 		if (t->sname && strcasecmp(t->sname, name) == 0)
575 			return (t->id);
576 	}
577 
578 	fprintf (stderr, "\nInvalid %s Type - valid names are", table_name);
579 	for (t = table; t->id >= 0; ++t) {
580 		if (t->sname == NULL)
581 			continue;
582 		fprintf (stderr, "%c %s", (first) ? ':' : ',', t->sname);
583 		first = 0;
584 	}
585 	fprintf (stderr, "\n");
586 #else
587 	for (t = table; t->id >= 0; ++t) {
588 #ifdef CONFIG_RELOC_FIXUP_WORKS
589 		if (t->sname && strcmp(t->sname, name) == 0)
590 #else
591 		if (t->sname && strcmp(t->sname + gd->reloc_off, name) == 0)
592 #endif
593 			return (t->id);
594 	}
595 	debug ("Invalid %s Type: %s\n", table_name, name);
596 #endif /* USE_HOSTCC */
597 	return (-1);
598 }
599 
600 int genimg_get_os_id (const char *name)
601 {
602 	return (get_table_entry_id (uimage_os, "OS", name));
603 }
604 
605 int genimg_get_arch_id (const char *name)
606 {
607 	return (get_table_entry_id (uimage_arch, "CPU", name));
608 }
609 
610 int genimg_get_type_id (const char *name)
611 {
612 	return (get_table_entry_id (uimage_type, "Image", name));
613 }
614 
615 int genimg_get_comp_id (const char *name)
616 {
617 	return (get_table_entry_id (uimage_comp, "Compression", name));
618 }
619 
620 #ifndef USE_HOSTCC
621 /**
622  * genimg_get_format - get image format type
623  * @img_addr: image start address
624  *
625  * genimg_get_format() checks whether provided address points to a valid
626  * legacy or FIT image.
627  *
628  * New uImage format and FDT blob are based on a libfdt. FDT blob
629  * may be passed directly or embedded in a FIT image. In both situations
630  * genimg_get_format() must be able to dectect libfdt header.
631  *
632  * returns:
633  *     image format type or IMAGE_FORMAT_INVALID if no image is present
634  */
635 int genimg_get_format (void *img_addr)
636 {
637 	ulong format = IMAGE_FORMAT_INVALID;
638 	const image_header_t *hdr;
639 #if defined(CONFIG_FIT) || defined(CONFIG_OF_LIBFDT)
640 	char *fit_hdr;
641 #endif
642 
643 	hdr = (const image_header_t *)img_addr;
644 	if (image_check_magic(hdr))
645 		format = IMAGE_FORMAT_LEGACY;
646 #if defined(CONFIG_FIT) || defined(CONFIG_OF_LIBFDT)
647 	else {
648 		fit_hdr = (char *)img_addr;
649 		if (fdt_check_header (fit_hdr) == 0)
650 			format = IMAGE_FORMAT_FIT;
651 	}
652 #endif
653 
654 	return format;
655 }
656 
657 /**
658  * genimg_get_image - get image from special storage (if necessary)
659  * @img_addr: image start address
660  *
661  * genimg_get_image() checks if provided image start adddress is located
662  * in a dataflash storage. If so, image is moved to a system RAM memory.
663  *
664  * returns:
665  *     image start address after possible relocation from special storage
666  */
667 ulong genimg_get_image (ulong img_addr)
668 {
669 	ulong ram_addr = img_addr;
670 
671 #ifdef CONFIG_HAS_DATAFLASH
672 	ulong h_size, d_size;
673 
674 	if (addr_dataflash (img_addr)){
675 		/* ger RAM address */
676 		ram_addr = CONFIG_SYS_LOAD_ADDR;
677 
678 		/* get header size */
679 		h_size = image_get_header_size ();
680 #if defined(CONFIG_FIT)
681 		if (sizeof(struct fdt_header) > h_size)
682 			h_size = sizeof(struct fdt_header);
683 #endif
684 
685 		/* read in header */
686 		debug ("   Reading image header from dataflash address "
687 			"%08lx to RAM address %08lx\n", img_addr, ram_addr);
688 
689 		read_dataflash (img_addr, h_size, (char *)ram_addr);
690 
691 		/* get data size */
692 		switch (genimg_get_format ((void *)ram_addr)) {
693 		case IMAGE_FORMAT_LEGACY:
694 			d_size = image_get_data_size ((const image_header_t *)ram_addr);
695 			debug ("   Legacy format image found at 0x%08lx, size 0x%08lx\n",
696 					ram_addr, d_size);
697 			break;
698 #if defined(CONFIG_FIT)
699 		case IMAGE_FORMAT_FIT:
700 			d_size = fit_get_size ((const void *)ram_addr) - h_size;
701 			debug ("   FIT/FDT format image found at 0x%08lx, size 0x%08lx\n",
702 					ram_addr, d_size);
703 			break;
704 #endif
705 		default:
706 			printf ("   No valid image found at 0x%08lx\n", img_addr);
707 			return ram_addr;
708 		}
709 
710 		/* read in image data */
711 		debug ("   Reading image remaining data from dataflash address "
712 			"%08lx to RAM address %08lx\n", img_addr + h_size,
713 			ram_addr + h_size);
714 
715 		read_dataflash (img_addr + h_size, d_size,
716 				(char *)(ram_addr + h_size));
717 
718 	}
719 #endif /* CONFIG_HAS_DATAFLASH */
720 
721 	return ram_addr;
722 }
723 
724 /**
725  * fit_has_config - check if there is a valid FIT configuration
726  * @images: pointer to the bootm command headers structure
727  *
728  * fit_has_config() checks if there is a FIT configuration in use
729  * (if FTI support is present).
730  *
731  * returns:
732  *     0, no FIT support or no configuration found
733  *     1, configuration found
734  */
735 int genimg_has_config (bootm_headers_t *images)
736 {
737 #if defined(CONFIG_FIT)
738 	if (images->fit_uname_cfg)
739 		return 1;
740 #endif
741 	return 0;
742 }
743 
744 /**
745  * boot_get_ramdisk - main ramdisk handling routine
746  * @argc: command argument count
747  * @argv: command argument list
748  * @images: pointer to the bootm images structure
749  * @arch: expected ramdisk architecture
750  * @rd_start: pointer to a ulong variable, will hold ramdisk start address
751  * @rd_end: pointer to a ulong variable, will hold ramdisk end
752  *
753  * boot_get_ramdisk() is responsible for finding a valid ramdisk image.
754  * Curently supported are the following ramdisk sources:
755  *      - multicomponent kernel/ramdisk image,
756  *      - commandline provided address of decicated ramdisk image.
757  *
758  * returns:
759  *     0, if ramdisk image was found and valid, or skiped
760  *     rd_start and rd_end are set to ramdisk start/end addresses if
761  *     ramdisk image is found and valid
762  *
763  *     1, if ramdisk image is found but corrupted, or invalid
764  *     rd_start and rd_end are set to 0 if no ramdisk exists
765  */
766 int boot_get_ramdisk (int argc, char * const argv[], bootm_headers_t *images,
767 		uint8_t arch, ulong *rd_start, ulong *rd_end)
768 {
769 	ulong rd_addr, rd_load;
770 	ulong rd_data, rd_len;
771 	const image_header_t *rd_hdr;
772 #if defined(CONFIG_FIT)
773 	void		*fit_hdr;
774 	const char	*fit_uname_config = NULL;
775 	const char	*fit_uname_ramdisk = NULL;
776 	ulong		default_addr;
777 	int		rd_noffset;
778 	int		cfg_noffset;
779 	const void	*data;
780 	size_t		size;
781 #endif
782 
783 	*rd_start = 0;
784 	*rd_end = 0;
785 
786 	/*
787 	 * Look for a '-' which indicates to ignore the
788 	 * ramdisk argument
789 	 */
790 	if ((argc >= 3) && (strcmp(argv[2], "-") ==  0)) {
791 		debug ("## Skipping init Ramdisk\n");
792 		rd_len = rd_data = 0;
793 	} else if (argc >= 3 || genimg_has_config (images)) {
794 #if defined(CONFIG_FIT)
795 		if (argc >= 3) {
796 			/*
797 			 * If the init ramdisk comes from the FIT image and
798 			 * the FIT image address is omitted in the command
799 			 * line argument, try to use os FIT image address or
800 			 * default load address.
801 			 */
802 			if (images->fit_uname_os)
803 				default_addr = (ulong)images->fit_hdr_os;
804 			else
805 				default_addr = load_addr;
806 
807 			if (fit_parse_conf (argv[2], default_addr,
808 						&rd_addr, &fit_uname_config)) {
809 				debug ("*  ramdisk: config '%s' from image at 0x%08lx\n",
810 						fit_uname_config, rd_addr);
811 			} else if (fit_parse_subimage (argv[2], default_addr,
812 						&rd_addr, &fit_uname_ramdisk)) {
813 				debug ("*  ramdisk: subimage '%s' from image at 0x%08lx\n",
814 						fit_uname_ramdisk, rd_addr);
815 			} else
816 #endif
817 			{
818 				rd_addr = simple_strtoul(argv[2], NULL, 16);
819 				debug ("*  ramdisk: cmdline image address = 0x%08lx\n",
820 						rd_addr);
821 			}
822 #if defined(CONFIG_FIT)
823 		} else {
824 			/* use FIT configuration provided in first bootm
825 			 * command argument
826 			 */
827 			rd_addr = (ulong)images->fit_hdr_os;
828 			fit_uname_config = images->fit_uname_cfg;
829 			debug ("*  ramdisk: using config '%s' from image at 0x%08lx\n",
830 					fit_uname_config, rd_addr);
831 
832 			/*
833 			 * Check whether configuration has ramdisk defined,
834 			 * if not, don't try to use it, quit silently.
835 			 */
836 			fit_hdr = (void *)rd_addr;
837 			cfg_noffset = fit_conf_get_node (fit_hdr, fit_uname_config);
838 			if (cfg_noffset < 0) {
839 				debug ("*  ramdisk: no such config\n");
840 				return 1;
841 			}
842 
843 			rd_noffset = fit_conf_get_ramdisk_node (fit_hdr, cfg_noffset);
844 			if (rd_noffset < 0) {
845 				debug ("*  ramdisk: no ramdisk in config\n");
846 				return 0;
847 			}
848 		}
849 #endif
850 
851 		/* copy from dataflash if needed */
852 		rd_addr = genimg_get_image (rd_addr);
853 
854 		/*
855 		 * Check if there is an initrd image at the
856 		 * address provided in the second bootm argument
857 		 * check image type, for FIT images get FIT node.
858 		 */
859 		switch (genimg_get_format ((void *)rd_addr)) {
860 		case IMAGE_FORMAT_LEGACY:
861 			printf ("## Loading init Ramdisk from Legacy "
862 					"Image at %08lx ...\n", rd_addr);
863 
864 			show_boot_progress (9);
865 			rd_hdr = image_get_ramdisk (rd_addr, arch,
866 							images->verify);
867 
868 			if (rd_hdr == NULL)
869 				return 1;
870 
871 			rd_data = image_get_data (rd_hdr);
872 			rd_len = image_get_data_size (rd_hdr);
873 			rd_load = image_get_load (rd_hdr);
874 			break;
875 #if defined(CONFIG_FIT)
876 		case IMAGE_FORMAT_FIT:
877 			fit_hdr = (void *)rd_addr;
878 			printf ("## Loading init Ramdisk from FIT "
879 					"Image at %08lx ...\n", rd_addr);
880 
881 			show_boot_progress (120);
882 			if (!fit_check_format (fit_hdr)) {
883 				puts ("Bad FIT ramdisk image format!\n");
884 				show_boot_progress (-120);
885 				return 1;
886 			}
887 			show_boot_progress (121);
888 
889 			if (!fit_uname_ramdisk) {
890 				/*
891 				 * no ramdisk image node unit name, try to get config
892 				 * node first. If config unit node name is NULL
893 				 * fit_conf_get_node() will try to find default config node
894 				 */
895 				show_boot_progress (122);
896 				cfg_noffset = fit_conf_get_node (fit_hdr, fit_uname_config);
897 				if (cfg_noffset < 0) {
898 					puts ("Could not find configuration node\n");
899 					show_boot_progress (-122);
900 					return 1;
901 				}
902 				fit_uname_config = fdt_get_name (fit_hdr, cfg_noffset, NULL);
903 				printf ("   Using '%s' configuration\n", fit_uname_config);
904 
905 				rd_noffset = fit_conf_get_ramdisk_node (fit_hdr, cfg_noffset);
906 				fit_uname_ramdisk = fit_get_name (fit_hdr, rd_noffset, NULL);
907 			} else {
908 				/* get ramdisk component image node offset */
909 				show_boot_progress (123);
910 				rd_noffset = fit_image_get_node (fit_hdr, fit_uname_ramdisk);
911 			}
912 			if (rd_noffset < 0) {
913 				puts ("Could not find subimage node\n");
914 				show_boot_progress (-124);
915 				return 1;
916 			}
917 
918 			printf ("   Trying '%s' ramdisk subimage\n", fit_uname_ramdisk);
919 
920 			show_boot_progress (125);
921 			if (!fit_check_ramdisk (fit_hdr, rd_noffset, arch, images->verify))
922 				return 1;
923 
924 			/* get ramdisk image data address and length */
925 			if (fit_image_get_data (fit_hdr, rd_noffset, &data, &size)) {
926 				puts ("Could not find ramdisk subimage data!\n");
927 				show_boot_progress (-127);
928 				return 1;
929 			}
930 			show_boot_progress (128);
931 
932 			rd_data = (ulong)data;
933 			rd_len = size;
934 
935 			if (fit_image_get_load (fit_hdr, rd_noffset, &rd_load)) {
936 				puts ("Can't get ramdisk subimage load address!\n");
937 				show_boot_progress (-129);
938 				return 1;
939 			}
940 			show_boot_progress (129);
941 
942 			images->fit_hdr_rd = fit_hdr;
943 			images->fit_uname_rd = fit_uname_ramdisk;
944 			images->fit_noffset_rd = rd_noffset;
945 			break;
946 #endif
947 		default:
948 			puts ("Wrong Ramdisk Image Format\n");
949 			rd_data = rd_len = rd_load = 0;
950 			return 1;
951 		}
952 
953 #if defined(CONFIG_B2) || defined(CONFIG_EVB4510) || defined(CONFIG_ARMADILLO)
954 		/*
955 		 * We need to copy the ramdisk to SRAM to let Linux boot
956 		 */
957 		if (rd_data) {
958 			memmove ((void *)rd_load, (uchar *)rd_data, rd_len);
959 			rd_data = rd_load;
960 		}
961 #endif /* CONFIG_B2 || CONFIG_EVB4510 || CONFIG_ARMADILLO */
962 
963 	} else if (images->legacy_hdr_valid &&
964 			image_check_type (&images->legacy_hdr_os_copy, IH_TYPE_MULTI)) {
965 		/*
966 		 * Now check if we have a legacy mult-component image,
967 		 * get second entry data start address and len.
968 		 */
969 		show_boot_progress (13);
970 		printf ("## Loading init Ramdisk from multi component "
971 				"Legacy Image at %08lx ...\n",
972 				(ulong)images->legacy_hdr_os);
973 
974 		image_multi_getimg (images->legacy_hdr_os, 1, &rd_data, &rd_len);
975 	} else {
976 		/*
977 		 * no initrd image
978 		 */
979 		show_boot_progress (14);
980 		rd_len = rd_data = 0;
981 	}
982 
983 	if (!rd_data) {
984 		debug ("## No init Ramdisk\n");
985 	} else {
986 		*rd_start = rd_data;
987 		*rd_end = rd_data + rd_len;
988 	}
989 	debug ("   ramdisk start = 0x%08lx, ramdisk end = 0x%08lx\n",
990 			*rd_start, *rd_end);
991 
992 	return 0;
993 }
994 
995 #ifdef CONFIG_SYS_BOOT_RAMDISK_HIGH
996 /**
997  * boot_ramdisk_high - relocate init ramdisk
998  * @lmb: pointer to lmb handle, will be used for memory mgmt
999  * @rd_data: ramdisk data start address
1000  * @rd_len: ramdisk data length
1001  * @initrd_start: pointer to a ulong variable, will hold final init ramdisk
1002  *      start address (after possible relocation)
1003  * @initrd_end: pointer to a ulong variable, will hold final init ramdisk
1004  *      end address (after possible relocation)
1005  *
1006  * boot_ramdisk_high() takes a relocation hint from "initrd_high" environement
1007  * variable and if requested ramdisk data is moved to a specified location.
1008  *
1009  * Initrd_start and initrd_end are set to final (after relocation) ramdisk
1010  * start/end addresses if ramdisk image start and len were provided,
1011  * otherwise set initrd_start and initrd_end set to zeros.
1012  *
1013  * returns:
1014  *      0 - success
1015  *     -1 - failure
1016  */
1017 int boot_ramdisk_high (struct lmb *lmb, ulong rd_data, ulong rd_len,
1018 		  ulong *initrd_start, ulong *initrd_end)
1019 {
1020 	char	*s;
1021 	ulong	initrd_high;
1022 	int	initrd_copy_to_ram = 1;
1023 
1024 	if ((s = getenv ("initrd_high")) != NULL) {
1025 		/* a value of "no" or a similar string will act like 0,
1026 		 * turning the "load high" feature off. This is intentional.
1027 		 */
1028 		initrd_high = simple_strtoul (s, NULL, 16);
1029 		if (initrd_high == ~0)
1030 			initrd_copy_to_ram = 0;
1031 	} else {
1032 		/* not set, no restrictions to load high */
1033 		initrd_high = ~0;
1034 	}
1035 
1036 
1037 #ifdef CONFIG_LOGBUFFER
1038 	/* Prevent initrd from overwriting logbuffer */
1039 	lmb_reserve(lmb, logbuffer_base() - LOGBUFF_OVERHEAD, LOGBUFF_RESERVE);
1040 #endif
1041 
1042 	debug ("## initrd_high = 0x%08lx, copy_to_ram = %d\n",
1043 			initrd_high, initrd_copy_to_ram);
1044 
1045 	if (rd_data) {
1046 		if (!initrd_copy_to_ram) {	/* zero-copy ramdisk support */
1047 			debug ("   in-place initrd\n");
1048 			*initrd_start = rd_data;
1049 			*initrd_end = rd_data + rd_len;
1050 			lmb_reserve(lmb, rd_data, rd_len);
1051 		} else {
1052 			if (initrd_high)
1053 				*initrd_start = (ulong)lmb_alloc_base (lmb, rd_len, 0x1000, initrd_high);
1054 			else
1055 				*initrd_start = (ulong)lmb_alloc (lmb, rd_len, 0x1000);
1056 
1057 			if (*initrd_start == 0) {
1058 				puts ("ramdisk - allocation error\n");
1059 				goto error;
1060 			}
1061 			show_boot_progress (12);
1062 
1063 			*initrd_end = *initrd_start + rd_len;
1064 			printf ("   Loading Ramdisk to %08lx, end %08lx ... ",
1065 					*initrd_start, *initrd_end);
1066 
1067 			memmove_wd ((void *)*initrd_start,
1068 					(void *)rd_data, rd_len, CHUNKSZ);
1069 
1070 			puts ("OK\n");
1071 		}
1072 	} else {
1073 		*initrd_start = 0;
1074 		*initrd_end = 0;
1075 	}
1076 	debug ("   ramdisk load start = 0x%08lx, ramdisk load end = 0x%08lx\n",
1077 			*initrd_start, *initrd_end);
1078 
1079 	return 0;
1080 
1081 error:
1082 	return -1;
1083 }
1084 #endif /* CONFIG_SYS_BOOT_RAMDISK_HIGH */
1085 
1086 #ifdef CONFIG_OF_LIBFDT
1087 static void fdt_error (const char *msg)
1088 {
1089 	puts ("ERROR: ");
1090 	puts (msg);
1091 	puts (" - must RESET the board to recover.\n");
1092 }
1093 
1094 static const image_header_t *image_get_fdt (ulong fdt_addr)
1095 {
1096 	const image_header_t *fdt_hdr = (const image_header_t *)fdt_addr;
1097 
1098 	image_print_contents (fdt_hdr);
1099 
1100 	puts ("   Verifying Checksum ... ");
1101 	if (!image_check_hcrc (fdt_hdr)) {
1102 		fdt_error ("fdt header checksum invalid");
1103 		return NULL;
1104 	}
1105 
1106 	if (!image_check_dcrc (fdt_hdr)) {
1107 		fdt_error ("fdt checksum invalid");
1108 		return NULL;
1109 	}
1110 	puts ("OK\n");
1111 
1112 	if (!image_check_type (fdt_hdr, IH_TYPE_FLATDT)) {
1113 		fdt_error ("uImage is not a fdt");
1114 		return NULL;
1115 	}
1116 	if (image_get_comp (fdt_hdr) != IH_COMP_NONE) {
1117 		fdt_error ("uImage is compressed");
1118 		return NULL;
1119 	}
1120 	if (fdt_check_header ((char *)image_get_data (fdt_hdr)) != 0) {
1121 		fdt_error ("uImage data is not a fdt");
1122 		return NULL;
1123 	}
1124 	return fdt_hdr;
1125 }
1126 
1127 /**
1128  * fit_check_fdt - verify FIT format FDT subimage
1129  * @fit_hdr: pointer to the FIT  header
1130  * fdt_noffset: FDT subimage node offset within FIT image
1131  * @verify: data CRC verification flag
1132  *
1133  * fit_check_fdt() verifies integrity of the FDT subimage and from
1134  * specified FIT image.
1135  *
1136  * returns:
1137  *     1, on success
1138  *     0, on failure
1139  */
1140 #if defined(CONFIG_FIT)
1141 static int fit_check_fdt (const void *fit, int fdt_noffset, int verify)
1142 {
1143 	fit_image_print (fit, fdt_noffset, "   ");
1144 
1145 	if (verify) {
1146 		puts ("   Verifying Hash Integrity ... ");
1147 		if (!fit_image_check_hashes (fit, fdt_noffset)) {
1148 			fdt_error ("Bad Data Hash");
1149 			return 0;
1150 		}
1151 		puts ("OK\n");
1152 	}
1153 
1154 	if (!fit_image_check_type (fit, fdt_noffset, IH_TYPE_FLATDT)) {
1155 		fdt_error ("Not a FDT image");
1156 		return 0;
1157 	}
1158 
1159 	if (!fit_image_check_comp (fit, fdt_noffset, IH_COMP_NONE)) {
1160 		fdt_error ("FDT image is compressed");
1161 		return 0;
1162 	}
1163 
1164 	return 1;
1165 }
1166 #endif /* CONFIG_FIT */
1167 
1168 #ifndef CONFIG_SYS_FDT_PAD
1169 #define CONFIG_SYS_FDT_PAD 0x3000
1170 #endif
1171 
1172 /**
1173  * boot_relocate_fdt - relocate flat device tree
1174  * @lmb: pointer to lmb handle, will be used for memory mgmt
1175  * @bootmap_base: base address of the bootmap region
1176  * @of_flat_tree: pointer to a char* variable, will hold fdt start address
1177  * @of_size: pointer to a ulong variable, will hold fdt length
1178  *
1179  * boot_relocate_fdt() determines if the of_flat_tree address is within
1180  * the bootmap and if not relocates it into that region
1181  *
1182  * of_flat_tree and of_size are set to final (after relocation) values
1183  *
1184  * returns:
1185  *      0 - success
1186  *      1 - failure
1187  */
1188 #if defined(CONFIG_SYS_BOOTMAPSZ)
1189 int boot_relocate_fdt (struct lmb *lmb, ulong bootmap_base,
1190 		char **of_flat_tree, ulong *of_size)
1191 {
1192 	char	*fdt_blob = *of_flat_tree;
1193 	ulong	relocate = 0;
1194 	ulong	of_len = 0;
1195 
1196 	/* nothing to do */
1197 	if (*of_size == 0)
1198 		return 0;
1199 
1200 	if (fdt_check_header (fdt_blob) != 0) {
1201 		fdt_error ("image is not a fdt");
1202 		goto error;
1203 	}
1204 
1205 #ifndef CONFIG_SYS_NO_FLASH
1206 	/* move the blob if it is in flash (set relocate) */
1207 	if (addr2info ((ulong)fdt_blob) != NULL)
1208 		relocate = 1;
1209 #endif
1210 
1211 	/*
1212 	 * The blob needs to be inside the boot mapping.
1213 	 */
1214 	if (fdt_blob < (char *)bootmap_base)
1215 		relocate = 1;
1216 
1217 	if ((fdt_blob + *of_size + CONFIG_SYS_FDT_PAD) >=
1218 			((char *)CONFIG_SYS_BOOTMAPSZ + bootmap_base))
1219 		relocate = 1;
1220 
1221 	/* move flattend device tree if needed */
1222 	if (relocate) {
1223 		int err;
1224 		ulong of_start = 0;
1225 
1226 		/* position on a 4K boundary before the alloc_current */
1227 		/* Pad the FDT by a specified amount */
1228 		of_len = *of_size + CONFIG_SYS_FDT_PAD;
1229 		of_start = (unsigned long)lmb_alloc_base(lmb, of_len, 0x1000,
1230 				(CONFIG_SYS_BOOTMAPSZ + bootmap_base));
1231 
1232 		if (of_start == 0) {
1233 			puts("device tree - allocation error\n");
1234 			goto error;
1235 		}
1236 
1237 		debug ("## device tree at 0x%08lX ... 0x%08lX (len=%ld=0x%lX)\n",
1238 			(ulong)fdt_blob, (ulong)fdt_blob + *of_size - 1,
1239 			of_len, of_len);
1240 
1241 		printf ("   Loading Device Tree to %08lx, end %08lx ... ",
1242 			of_start, of_start + of_len - 1);
1243 
1244 		err = fdt_open_into (fdt_blob, (void *)of_start, of_len);
1245 		if (err != 0) {
1246 			fdt_error ("fdt move failed");
1247 			goto error;
1248 		}
1249 		puts ("OK\n");
1250 
1251 		*of_flat_tree = (char *)of_start;
1252 		*of_size = of_len;
1253 	} else {
1254 		*of_flat_tree = fdt_blob;
1255 		of_len = *of_size + CONFIG_SYS_FDT_PAD;
1256 		lmb_reserve(lmb, (ulong)fdt_blob, of_len);
1257 		fdt_set_totalsize(*of_flat_tree, of_len);
1258 
1259 		*of_size = of_len;
1260 	}
1261 
1262 	set_working_fdt_addr(*of_flat_tree);
1263 	return 0;
1264 
1265 error:
1266 	return 1;
1267 }
1268 #endif /* CONFIG_SYS_BOOTMAPSZ */
1269 
1270 /**
1271  * boot_get_fdt - main fdt handling routine
1272  * @argc: command argument count
1273  * @argv: command argument list
1274  * @images: pointer to the bootm images structure
1275  * @of_flat_tree: pointer to a char* variable, will hold fdt start address
1276  * @of_size: pointer to a ulong variable, will hold fdt length
1277  *
1278  * boot_get_fdt() is responsible for finding a valid flat device tree image.
1279  * Curently supported are the following ramdisk sources:
1280  *      - multicomponent kernel/ramdisk image,
1281  *      - commandline provided address of decicated ramdisk image.
1282  *
1283  * returns:
1284  *     0, if fdt image was found and valid, or skipped
1285  *     of_flat_tree and of_size are set to fdt start address and length if
1286  *     fdt image is found and valid
1287  *
1288  *     1, if fdt image is found but corrupted
1289  *     of_flat_tree and of_size are set to 0 if no fdt exists
1290  */
1291 int boot_get_fdt (int flag, int argc, char * const argv[], bootm_headers_t *images,
1292 		char **of_flat_tree, ulong *of_size)
1293 {
1294 	const image_header_t *fdt_hdr;
1295 	ulong		fdt_addr;
1296 	char		*fdt_blob = NULL;
1297 	ulong		image_start, image_end;
1298 	ulong		load_start, load_end;
1299 #if defined(CONFIG_FIT)
1300 	void		*fit_hdr;
1301 	const char	*fit_uname_config = NULL;
1302 	const char	*fit_uname_fdt = NULL;
1303 	ulong		default_addr;
1304 	int		cfg_noffset;
1305 	int		fdt_noffset;
1306 	const void	*data;
1307 	size_t		size;
1308 #endif
1309 
1310 	*of_flat_tree = NULL;
1311 	*of_size = 0;
1312 
1313 	if (argc > 3 || genimg_has_config (images)) {
1314 #if defined(CONFIG_FIT)
1315 		if (argc > 3) {
1316 			/*
1317 			 * If the FDT blob comes from the FIT image and the
1318 			 * FIT image address is omitted in the command line
1319 			 * argument, try to use ramdisk or os FIT image
1320 			 * address or default load address.
1321 			 */
1322 			if (images->fit_uname_rd)
1323 				default_addr = (ulong)images->fit_hdr_rd;
1324 			else if (images->fit_uname_os)
1325 				default_addr = (ulong)images->fit_hdr_os;
1326 			else
1327 				default_addr = load_addr;
1328 
1329 			if (fit_parse_conf (argv[3], default_addr,
1330 						&fdt_addr, &fit_uname_config)) {
1331 				debug ("*  fdt: config '%s' from image at 0x%08lx\n",
1332 						fit_uname_config, fdt_addr);
1333 			} else if (fit_parse_subimage (argv[3], default_addr,
1334 						&fdt_addr, &fit_uname_fdt)) {
1335 				debug ("*  fdt: subimage '%s' from image at 0x%08lx\n",
1336 						fit_uname_fdt, fdt_addr);
1337 			} else
1338 #endif
1339 			{
1340 				fdt_addr = simple_strtoul(argv[3], NULL, 16);
1341 				debug ("*  fdt: cmdline image address = 0x%08lx\n",
1342 						fdt_addr);
1343 			}
1344 #if defined(CONFIG_FIT)
1345 		} else {
1346 			/* use FIT configuration provided in first bootm
1347 			 * command argument
1348 			 */
1349 			fdt_addr = (ulong)images->fit_hdr_os;
1350 			fit_uname_config = images->fit_uname_cfg;
1351 			debug ("*  fdt: using config '%s' from image at 0x%08lx\n",
1352 					fit_uname_config, fdt_addr);
1353 
1354 			/*
1355 			 * Check whether configuration has FDT blob defined,
1356 			 * if not quit silently.
1357 			 */
1358 			fit_hdr = (void *)fdt_addr;
1359 			cfg_noffset = fit_conf_get_node (fit_hdr,
1360 					fit_uname_config);
1361 			if (cfg_noffset < 0) {
1362 				debug ("*  fdt: no such config\n");
1363 				return 0;
1364 			}
1365 
1366 			fdt_noffset = fit_conf_get_fdt_node (fit_hdr,
1367 					cfg_noffset);
1368 			if (fdt_noffset < 0) {
1369 				debug ("*  fdt: no fdt in config\n");
1370 				return 0;
1371 			}
1372 		}
1373 #endif
1374 
1375 		debug ("## Checking for 'FDT'/'FDT Image' at %08lx\n",
1376 				fdt_addr);
1377 
1378 		/* copy from dataflash if needed */
1379 		fdt_addr = genimg_get_image (fdt_addr);
1380 
1381 		/*
1382 		 * Check if there is an FDT image at the
1383 		 * address provided in the second bootm argument
1384 		 * check image type, for FIT images get a FIT node.
1385 		 */
1386 		switch (genimg_get_format ((void *)fdt_addr)) {
1387 		case IMAGE_FORMAT_LEGACY:
1388 			/* verify fdt_addr points to a valid image header */
1389 			printf ("## Flattened Device Tree from Legacy Image at %08lx\n",
1390 					fdt_addr);
1391 			fdt_hdr = image_get_fdt (fdt_addr);
1392 			if (!fdt_hdr)
1393 				goto error;
1394 
1395 			/*
1396 			 * move image data to the load address,
1397 			 * make sure we don't overwrite initial image
1398 			 */
1399 			image_start = (ulong)fdt_hdr;
1400 			image_end = image_get_image_end (fdt_hdr);
1401 
1402 			load_start = image_get_load (fdt_hdr);
1403 			load_end = load_start + image_get_data_size (fdt_hdr);
1404 
1405 			if ((load_start < image_end) && (load_end > image_start)) {
1406 				fdt_error ("fdt overwritten");
1407 				goto error;
1408 			}
1409 
1410 			debug ("   Loading FDT from 0x%08lx to 0x%08lx\n",
1411 					image_get_data (fdt_hdr), load_start);
1412 
1413 			memmove ((void *)load_start,
1414 					(void *)image_get_data (fdt_hdr),
1415 					image_get_data_size (fdt_hdr));
1416 
1417 			fdt_blob = (char *)load_start;
1418 			break;
1419 		case IMAGE_FORMAT_FIT:
1420 			/*
1421 			 * This case will catch both: new uImage format
1422 			 * (libfdt based) and raw FDT blob (also libfdt
1423 			 * based).
1424 			 */
1425 #if defined(CONFIG_FIT)
1426 			/* check FDT blob vs FIT blob */
1427 			if (fit_check_format ((const void *)fdt_addr)) {
1428 				/*
1429 				 * FIT image
1430 				 */
1431 				fit_hdr = (void *)fdt_addr;
1432 				printf ("## Flattened Device Tree from FIT Image at %08lx\n",
1433 						fdt_addr);
1434 
1435 				if (!fit_uname_fdt) {
1436 					/*
1437 					 * no FDT blob image node unit name,
1438 					 * try to get config node first. If
1439 					 * config unit node name is NULL
1440 					 * fit_conf_get_node() will try to
1441 					 * find default config node
1442 					 */
1443 					cfg_noffset = fit_conf_get_node (fit_hdr,
1444 							fit_uname_config);
1445 
1446 					if (cfg_noffset < 0) {
1447 						fdt_error ("Could not find configuration node\n");
1448 						goto error;
1449 					}
1450 
1451 					fit_uname_config = fdt_get_name (fit_hdr,
1452 							cfg_noffset, NULL);
1453 					printf ("   Using '%s' configuration\n",
1454 							fit_uname_config);
1455 
1456 					fdt_noffset = fit_conf_get_fdt_node (fit_hdr,
1457 							cfg_noffset);
1458 					fit_uname_fdt = fit_get_name (fit_hdr,
1459 							fdt_noffset, NULL);
1460 				} else {
1461 					/* get FDT component image node offset */
1462 					fdt_noffset = fit_image_get_node (fit_hdr,
1463 							fit_uname_fdt);
1464 				}
1465 				if (fdt_noffset < 0) {
1466 					fdt_error ("Could not find subimage node\n");
1467 					goto error;
1468 				}
1469 
1470 				printf ("   Trying '%s' FDT blob subimage\n",
1471 						fit_uname_fdt);
1472 
1473 				if (!fit_check_fdt (fit_hdr, fdt_noffset,
1474 							images->verify))
1475 					goto error;
1476 
1477 				/* get ramdisk image data address and length */
1478 				if (fit_image_get_data (fit_hdr, fdt_noffset,
1479 							&data, &size)) {
1480 					fdt_error ("Could not find FDT subimage data");
1481 					goto error;
1482 				}
1483 
1484 				/* verift that image data is a proper FDT blob */
1485 				if (fdt_check_header ((char *)data) != 0) {
1486 					fdt_error ("Subimage data is not a FTD");
1487 					goto error;
1488 				}
1489 
1490 				/*
1491 				 * move image data to the load address,
1492 				 * make sure we don't overwrite initial image
1493 				 */
1494 				image_start = (ulong)fit_hdr;
1495 				image_end = fit_get_end (fit_hdr);
1496 
1497 				if (fit_image_get_load (fit_hdr, fdt_noffset,
1498 							&load_start) == 0) {
1499 					load_end = load_start + size;
1500 
1501 					if ((load_start < image_end) &&
1502 							(load_end > image_start)) {
1503 						fdt_error ("FDT overwritten");
1504 						goto error;
1505 					}
1506 
1507 					printf ("   Loading FDT from 0x%08lx to 0x%08lx\n",
1508 							(ulong)data, load_start);
1509 
1510 					memmove ((void *)load_start,
1511 							(void *)data, size);
1512 
1513 					fdt_blob = (char *)load_start;
1514 				} else {
1515 					fdt_blob = (char *)data;
1516 				}
1517 
1518 				images->fit_hdr_fdt = fit_hdr;
1519 				images->fit_uname_fdt = fit_uname_fdt;
1520 				images->fit_noffset_fdt = fdt_noffset;
1521 				break;
1522 			} else
1523 #endif
1524 			{
1525 				/*
1526 				 * FDT blob
1527 				 */
1528 				fdt_blob = (char *)fdt_addr;
1529 				debug ("*  fdt: raw FDT blob\n");
1530 				printf ("## Flattened Device Tree blob at %08lx\n", (long)fdt_blob);
1531 			}
1532 			break;
1533 		default:
1534 			puts ("ERROR: Did not find a cmdline Flattened Device Tree\n");
1535 			goto error;
1536 		}
1537 
1538 		printf ("   Booting using the fdt blob at 0x%x\n", (int)fdt_blob);
1539 
1540 	} else if (images->legacy_hdr_valid &&
1541 			image_check_type (&images->legacy_hdr_os_copy, IH_TYPE_MULTI)) {
1542 
1543 		ulong fdt_data, fdt_len;
1544 
1545 		/*
1546 		 * Now check if we have a legacy multi-component image,
1547 		 * get second entry data start address and len.
1548 		 */
1549 		printf ("## Flattened Device Tree from multi "
1550 			"component Image at %08lX\n",
1551 			(ulong)images->legacy_hdr_os);
1552 
1553 		image_multi_getimg (images->legacy_hdr_os, 2, &fdt_data, &fdt_len);
1554 		if (fdt_len) {
1555 
1556 			fdt_blob = (char *)fdt_data;
1557 			printf ("   Booting using the fdt at 0x%x\n", (int)fdt_blob);
1558 
1559 			if (fdt_check_header (fdt_blob) != 0) {
1560 				fdt_error ("image is not a fdt");
1561 				goto error;
1562 			}
1563 
1564 			if (fdt_totalsize(fdt_blob) != fdt_len) {
1565 				fdt_error ("fdt size != image size");
1566 				goto error;
1567 			}
1568 		} else {
1569 			debug ("## No Flattened Device Tree\n");
1570 			return 0;
1571 		}
1572 	} else {
1573 		debug ("## No Flattened Device Tree\n");
1574 		return 0;
1575 	}
1576 
1577 	*of_flat_tree = fdt_blob;
1578 	*of_size = fdt_totalsize(fdt_blob);
1579 	debug ("   of_flat_tree at 0x%08lx size 0x%08lx\n",
1580 			(ulong)*of_flat_tree, *of_size);
1581 
1582 	return 0;
1583 
1584 error:
1585 	*of_flat_tree = 0;
1586 	*of_size = 0;
1587 	return 1;
1588 }
1589 #endif /* CONFIG_OF_LIBFDT */
1590 
1591 #ifdef CONFIG_SYS_BOOT_GET_CMDLINE
1592 /**
1593  * boot_get_cmdline - allocate and initialize kernel cmdline
1594  * @lmb: pointer to lmb handle, will be used for memory mgmt
1595  * @cmd_start: pointer to a ulong variable, will hold cmdline start
1596  * @cmd_end: pointer to a ulong variable, will hold cmdline end
1597  * @bootmap_base: ulong variable, holds offset in physical memory to
1598  * base of bootmap
1599  *
1600  * boot_get_cmdline() allocates space for kernel command line below
1601  * BOOTMAPSZ + bootmap_base address. If "bootargs" U-boot environemnt
1602  * variable is present its contents is copied to allocated kernel
1603  * command line.
1604  *
1605  * returns:
1606  *      0 - success
1607  *     -1 - failure
1608  */
1609 int boot_get_cmdline (struct lmb *lmb, ulong *cmd_start, ulong *cmd_end,
1610 			ulong bootmap_base)
1611 {
1612 	char *cmdline;
1613 	char *s;
1614 
1615 	cmdline = (char *)(ulong)lmb_alloc_base(lmb, CONFIG_SYS_BARGSIZE, 0xf,
1616 					 CONFIG_SYS_BOOTMAPSZ + bootmap_base);
1617 
1618 	if (cmdline == NULL)
1619 		return -1;
1620 
1621 	if ((s = getenv("bootargs")) == NULL)
1622 		s = "";
1623 
1624 	strcpy(cmdline, s);
1625 
1626 	*cmd_start = (ulong) & cmdline[0];
1627 	*cmd_end = *cmd_start + strlen(cmdline);
1628 
1629 	debug ("## cmdline at 0x%08lx ... 0x%08lx\n", *cmd_start, *cmd_end);
1630 
1631 	return 0;
1632 }
1633 #endif /* CONFIG_SYS_BOOT_GET_CMDLINE */
1634 
1635 #ifdef CONFIG_SYS_BOOT_GET_KBD
1636 /**
1637  * boot_get_kbd - allocate and initialize kernel copy of board info
1638  * @lmb: pointer to lmb handle, will be used for memory mgmt
1639  * @kbd: double pointer to board info data
1640  * @bootmap_base: ulong variable, holds offset in physical memory to
1641  * base of bootmap
1642  *
1643  * boot_get_kbd() allocates space for kernel copy of board info data below
1644  * BOOTMAPSZ + bootmap_base address and kernel board info is initialized with
1645  * the current u-boot board info data.
1646  *
1647  * returns:
1648  *      0 - success
1649  *     -1 - failure
1650  */
1651 int boot_get_kbd (struct lmb *lmb, bd_t **kbd, ulong bootmap_base)
1652 {
1653 	*kbd = (bd_t *)(ulong)lmb_alloc_base(lmb, sizeof(bd_t), 0xf,
1654 				      CONFIG_SYS_BOOTMAPSZ + bootmap_base);
1655 	if (*kbd == NULL)
1656 		return -1;
1657 
1658 	**kbd = *(gd->bd);
1659 
1660 	debug ("## kernel board info at 0x%08lx\n", (ulong)*kbd);
1661 
1662 #if defined(DEBUG) && defined(CONFIG_CMD_BDI)
1663 	do_bdinfo(NULL, 0, 0, NULL);
1664 #endif
1665 
1666 	return 0;
1667 }
1668 #endif /* CONFIG_SYS_BOOT_GET_KBD */
1669 #endif /* !USE_HOSTCC */
1670 
1671 #if defined(CONFIG_FIT)
1672 /*****************************************************************************/
1673 /* New uImage format routines */
1674 /*****************************************************************************/
1675 #ifndef USE_HOSTCC
1676 static int fit_parse_spec (const char *spec, char sepc, ulong addr_curr,
1677 		ulong *addr, const char **name)
1678 {
1679 	const char *sep;
1680 
1681 	*addr = addr_curr;
1682 	*name = NULL;
1683 
1684 	sep = strchr (spec, sepc);
1685 	if (sep) {
1686 		if (sep - spec > 0)
1687 			*addr = simple_strtoul (spec, NULL, 16);
1688 
1689 		*name = sep + 1;
1690 		return 1;
1691 	}
1692 
1693 	return 0;
1694 }
1695 
1696 /**
1697  * fit_parse_conf - parse FIT configuration spec
1698  * @spec: input string, containing configuration spec
1699  * @add_curr: current image address (to be used as a possible default)
1700  * @addr: pointer to a ulong variable, will hold FIT image address of a given
1701  * configuration
1702  * @conf_name double pointer to a char, will hold pointer to a configuration
1703  * unit name
1704  *
1705  * fit_parse_conf() expects configuration spec in the for of [<addr>]#<conf>,
1706  * where <addr> is a FIT image address that contains configuration
1707  * with a <conf> unit name.
1708  *
1709  * Address part is optional, and if omitted default add_curr will
1710  * be used instead.
1711  *
1712  * returns:
1713  *     1 if spec is a valid configuration string,
1714  *     addr and conf_name are set accordingly
1715  *     0 otherwise
1716  */
1717 inline int fit_parse_conf (const char *spec, ulong addr_curr,
1718 		ulong *addr, const char **conf_name)
1719 {
1720 	return fit_parse_spec (spec, '#', addr_curr, addr, conf_name);
1721 }
1722 
1723 /**
1724  * fit_parse_subimage - parse FIT subimage spec
1725  * @spec: input string, containing subimage spec
1726  * @add_curr: current image address (to be used as a possible default)
1727  * @addr: pointer to a ulong variable, will hold FIT image address of a given
1728  * subimage
1729  * @image_name: double pointer to a char, will hold pointer to a subimage name
1730  *
1731  * fit_parse_subimage() expects subimage spec in the for of
1732  * [<addr>]:<subimage>, where <addr> is a FIT image address that contains
1733  * subimage with a <subimg> unit name.
1734  *
1735  * Address part is optional, and if omitted default add_curr will
1736  * be used instead.
1737  *
1738  * returns:
1739  *     1 if spec is a valid subimage string,
1740  *     addr and image_name are set accordingly
1741  *     0 otherwise
1742  */
1743 inline int fit_parse_subimage (const char *spec, ulong addr_curr,
1744 		ulong *addr, const char **image_name)
1745 {
1746 	return fit_parse_spec (spec, ':', addr_curr, addr, image_name);
1747 }
1748 #endif /* !USE_HOSTCC */
1749 
1750 static void fit_get_debug (const void *fit, int noffset,
1751 		char *prop_name, int err)
1752 {
1753 	debug ("Can't get '%s' property from FIT 0x%08lx, "
1754 		"node: offset %d, name %s (%s)\n",
1755 		prop_name, (ulong)fit, noffset,
1756 		fit_get_name (fit, noffset, NULL),
1757 		fdt_strerror (err));
1758 }
1759 
1760 /**
1761  * fit_print_contents - prints out the contents of the FIT format image
1762  * @fit: pointer to the FIT format image header
1763  * @p: pointer to prefix string
1764  *
1765  * fit_print_contents() formats a multi line FIT image contents description.
1766  * The routine prints out FIT image properties (root node level) follwed by
1767  * the details of each component image.
1768  *
1769  * returns:
1770  *     no returned results
1771  */
1772 void fit_print_contents (const void *fit)
1773 {
1774 	char *desc;
1775 	char *uname;
1776 	int images_noffset;
1777 	int confs_noffset;
1778 	int noffset;
1779 	int ndepth;
1780 	int count = 0;
1781 	int ret;
1782 	const char *p;
1783 #if defined(CONFIG_TIMESTAMP) || defined(CONFIG_CMD_DATE) || defined(USE_HOSTCC)
1784 	time_t timestamp;
1785 #endif
1786 
1787 #ifdef USE_HOSTCC
1788 	p = "";
1789 #else
1790 	p = "   ";
1791 #endif
1792 
1793 	/* Root node properties */
1794 	ret = fit_get_desc (fit, 0, &desc);
1795 	printf ("%sFIT description: ", p);
1796 	if (ret)
1797 		printf ("unavailable\n");
1798 	else
1799 		printf ("%s\n", desc);
1800 
1801 #if defined(CONFIG_TIMESTAMP) || defined(CONFIG_CMD_DATE) || defined(USE_HOSTCC)
1802 	ret = fit_get_timestamp (fit, 0, &timestamp);
1803 	printf ("%sCreated:         ", p);
1804 	if (ret)
1805 		printf ("unavailable\n");
1806 	else
1807 		genimg_print_time (timestamp);
1808 #endif
1809 
1810 	/* Find images parent node offset */
1811 	images_noffset = fdt_path_offset (fit, FIT_IMAGES_PATH);
1812 	if (images_noffset < 0) {
1813 		printf ("Can't find images parent node '%s' (%s)\n",
1814 			FIT_IMAGES_PATH, fdt_strerror (images_noffset));
1815 		return;
1816 	}
1817 
1818 	/* Process its subnodes, print out component images details */
1819 	for (ndepth = 0, count = 0, noffset = fdt_next_node (fit, images_noffset, &ndepth);
1820 	     (noffset >= 0) && (ndepth > 0);
1821 	     noffset = fdt_next_node (fit, noffset, &ndepth)) {
1822 		if (ndepth == 1) {
1823 			/*
1824 			 * Direct child node of the images parent node,
1825 			 * i.e. component image node.
1826 			 */
1827 			printf ("%s Image %u (%s)\n", p, count++,
1828 					fit_get_name(fit, noffset, NULL));
1829 
1830 			fit_image_print (fit, noffset, p);
1831 		}
1832 	}
1833 
1834 	/* Find configurations parent node offset */
1835 	confs_noffset = fdt_path_offset (fit, FIT_CONFS_PATH);
1836 	if (confs_noffset < 0) {
1837 		debug ("Can't get configurations parent node '%s' (%s)\n",
1838 			FIT_CONFS_PATH, fdt_strerror (confs_noffset));
1839 		return;
1840 	}
1841 
1842 	/* get default configuration unit name from default property */
1843 	uname = (char *)fdt_getprop (fit, noffset, FIT_DEFAULT_PROP, NULL);
1844 	if (uname)
1845 		printf ("%s Default Configuration: '%s'\n", p, uname);
1846 
1847 	/* Process its subnodes, print out configurations details */
1848 	for (ndepth = 0, count = 0, noffset = fdt_next_node (fit, confs_noffset, &ndepth);
1849 	     (noffset >= 0) && (ndepth > 0);
1850 	     noffset = fdt_next_node (fit, noffset, &ndepth)) {
1851 		if (ndepth == 1) {
1852 			/*
1853 			 * Direct child node of the configurations parent node,
1854 			 * i.e. configuration node.
1855 			 */
1856 			printf ("%s Configuration %u (%s)\n", p, count++,
1857 					fit_get_name(fit, noffset, NULL));
1858 
1859 			fit_conf_print (fit, noffset, p);
1860 		}
1861 	}
1862 }
1863 
1864 /**
1865  * fit_image_print - prints out the FIT component image details
1866  * @fit: pointer to the FIT format image header
1867  * @image_noffset: offset of the component image node
1868  * @p: pointer to prefix string
1869  *
1870  * fit_image_print() lists all mandatory properies for the processed component
1871  * image. If present, hash nodes are printed out as well. Load
1872  * address for images of type firmware is also printed out. Since the load
1873  * address is not mandatory for firmware images, it will be output as
1874  * "unavailable" when not present.
1875  *
1876  * returns:
1877  *     no returned results
1878  */
1879 void fit_image_print (const void *fit, int image_noffset, const char *p)
1880 {
1881 	char *desc;
1882 	uint8_t type, arch, os, comp;
1883 	size_t size;
1884 	ulong load, entry;
1885 	const void *data;
1886 	int noffset;
1887 	int ndepth;
1888 	int ret;
1889 
1890 	/* Mandatory properties */
1891 	ret = fit_get_desc (fit, image_noffset, &desc);
1892 	printf ("%s  Description:  ", p);
1893 	if (ret)
1894 		printf ("unavailable\n");
1895 	else
1896 		printf ("%s\n", desc);
1897 
1898 	fit_image_get_type (fit, image_noffset, &type);
1899 	printf ("%s  Type:         %s\n", p, genimg_get_type_name (type));
1900 
1901 	fit_image_get_comp (fit, image_noffset, &comp);
1902 	printf ("%s  Compression:  %s\n", p, genimg_get_comp_name (comp));
1903 
1904 	ret = fit_image_get_data (fit, image_noffset, &data, &size);
1905 
1906 #ifndef USE_HOSTCC
1907 	printf ("%s  Data Start:   ", p);
1908 	if (ret)
1909 		printf ("unavailable\n");
1910 	else
1911 		printf ("0x%08lx\n", (ulong)data);
1912 #endif
1913 
1914 	printf ("%s  Data Size:    ", p);
1915 	if (ret)
1916 		printf ("unavailable\n");
1917 	else
1918 		genimg_print_size (size);
1919 
1920 	/* Remaining, type dependent properties */
1921 	if ((type == IH_TYPE_KERNEL) || (type == IH_TYPE_STANDALONE) ||
1922 	    (type == IH_TYPE_RAMDISK) || (type == IH_TYPE_FIRMWARE) ||
1923 	    (type == IH_TYPE_FLATDT)) {
1924 		fit_image_get_arch (fit, image_noffset, &arch);
1925 		printf ("%s  Architecture: %s\n", p, genimg_get_arch_name (arch));
1926 	}
1927 
1928 	if (type == IH_TYPE_KERNEL) {
1929 		fit_image_get_os (fit, image_noffset, &os);
1930 		printf ("%s  OS:           %s\n", p, genimg_get_os_name (os));
1931 	}
1932 
1933 	if ((type == IH_TYPE_KERNEL) || (type == IH_TYPE_STANDALONE) ||
1934 		(type == IH_TYPE_FIRMWARE)) {
1935 		ret = fit_image_get_load (fit, image_noffset, &load);
1936 		printf ("%s  Load Address: ", p);
1937 		if (ret)
1938 			printf ("unavailable\n");
1939 		else
1940 			printf ("0x%08lx\n", load);
1941 	}
1942 
1943 	if ((type == IH_TYPE_KERNEL) || (type == IH_TYPE_STANDALONE)) {
1944 		fit_image_get_entry (fit, image_noffset, &entry);
1945 		printf ("%s  Entry Point:  ", p);
1946 		if (ret)
1947 			printf ("unavailable\n");
1948 		else
1949 			printf ("0x%08lx\n", entry);
1950 	}
1951 
1952 	/* Process all hash subnodes of the component image node */
1953 	for (ndepth = 0, noffset = fdt_next_node (fit, image_noffset, &ndepth);
1954 	     (noffset >= 0) && (ndepth > 0);
1955 	     noffset = fdt_next_node (fit, noffset, &ndepth)) {
1956 		if (ndepth == 1) {
1957 			/* Direct child node of the component image node */
1958 			fit_image_print_hash (fit, noffset, p);
1959 		}
1960 	}
1961 }
1962 
1963 /**
1964  * fit_image_print_hash - prints out the hash node details
1965  * @fit: pointer to the FIT format image header
1966  * @noffset: offset of the hash node
1967  * @p: pointer to prefix string
1968  *
1969  * fit_image_print_hash() lists properies for the processed hash node
1970  *
1971  * returns:
1972  *     no returned results
1973  */
1974 void fit_image_print_hash (const void *fit, int noffset, const char *p)
1975 {
1976 	char *algo;
1977 	uint8_t *value;
1978 	int value_len;
1979 	int i, ret;
1980 
1981 	/*
1982 	 * Check subnode name, must be equal to "hash".
1983 	 * Multiple hash nodes require unique unit node
1984 	 * names, e.g. hash@1, hash@2, etc.
1985 	 */
1986 	if (strncmp (fit_get_name(fit, noffset, NULL),
1987 			FIT_HASH_NODENAME,
1988 			strlen(FIT_HASH_NODENAME)) != 0)
1989 		return;
1990 
1991 	debug ("%s  Hash node:    '%s'\n", p,
1992 			fit_get_name (fit, noffset, NULL));
1993 
1994 	printf ("%s  Hash algo:    ", p);
1995 	if (fit_image_hash_get_algo (fit, noffset, &algo)) {
1996 		printf ("invalid/unsupported\n");
1997 		return;
1998 	}
1999 	printf ("%s\n", algo);
2000 
2001 	ret = fit_image_hash_get_value (fit, noffset, &value,
2002 					&value_len);
2003 	printf ("%s  Hash value:   ", p);
2004 	if (ret) {
2005 		printf ("unavailable\n");
2006 	} else {
2007 		for (i = 0; i < value_len; i++)
2008 			printf ("%02x", value[i]);
2009 		printf ("\n");
2010 	}
2011 
2012 	debug  ("%s  Hash len:     %d\n", p, value_len);
2013 }
2014 
2015 /**
2016  * fit_get_desc - get node description property
2017  * @fit: pointer to the FIT format image header
2018  * @noffset: node offset
2019  * @desc: double pointer to the char, will hold pointer to the descrption
2020  *
2021  * fit_get_desc() reads description property from a given node, if
2022  * description is found pointer to it is returened in third call argument.
2023  *
2024  * returns:
2025  *     0, on success
2026  *     -1, on failure
2027  */
2028 int fit_get_desc (const void *fit, int noffset, char **desc)
2029 {
2030 	int len;
2031 
2032 	*desc = (char *)fdt_getprop (fit, noffset, FIT_DESC_PROP, &len);
2033 	if (*desc == NULL) {
2034 		fit_get_debug (fit, noffset, FIT_DESC_PROP, len);
2035 		return -1;
2036 	}
2037 
2038 	return 0;
2039 }
2040 
2041 /**
2042  * fit_get_timestamp - get node timestamp property
2043  * @fit: pointer to the FIT format image header
2044  * @noffset: node offset
2045  * @timestamp: pointer to the time_t, will hold read timestamp
2046  *
2047  * fit_get_timestamp() reads timestamp poperty from given node, if timestamp
2048  * is found and has a correct size its value is retured in third call
2049  * argument.
2050  *
2051  * returns:
2052  *     0, on success
2053  *     -1, on property read failure
2054  *     -2, on wrong timestamp size
2055  */
2056 int fit_get_timestamp (const void *fit, int noffset, time_t *timestamp)
2057 {
2058 	int len;
2059 	const void *data;
2060 
2061 	data = fdt_getprop (fit, noffset, FIT_TIMESTAMP_PROP, &len);
2062 	if (data == NULL) {
2063 		fit_get_debug (fit, noffset, FIT_TIMESTAMP_PROP, len);
2064 		return -1;
2065 	}
2066 	if (len != sizeof (uint32_t)) {
2067 		debug ("FIT timestamp with incorrect size of (%u)\n", len);
2068 		return -2;
2069 	}
2070 
2071 	*timestamp = uimage_to_cpu (*((uint32_t *)data));
2072 	return 0;
2073 }
2074 
2075 /**
2076  * fit_image_get_node - get node offset for component image of a given unit name
2077  * @fit: pointer to the FIT format image header
2078  * @image_uname: component image node unit name
2079  *
2080  * fit_image_get_node() finds a component image (withing the '/images'
2081  * node) of a provided unit name. If image is found its node offset is
2082  * returned to the caller.
2083  *
2084  * returns:
2085  *     image node offset when found (>=0)
2086  *     negative number on failure (FDT_ERR_* code)
2087  */
2088 int fit_image_get_node (const void *fit, const char *image_uname)
2089 {
2090 	int noffset, images_noffset;
2091 
2092 	images_noffset = fdt_path_offset (fit, FIT_IMAGES_PATH);
2093 	if (images_noffset < 0) {
2094 		debug ("Can't find images parent node '%s' (%s)\n",
2095 			FIT_IMAGES_PATH, fdt_strerror (images_noffset));
2096 		return images_noffset;
2097 	}
2098 
2099 	noffset = fdt_subnode_offset (fit, images_noffset, image_uname);
2100 	if (noffset < 0) {
2101 		debug ("Can't get node offset for image unit name: '%s' (%s)\n",
2102 			image_uname, fdt_strerror (noffset));
2103 	}
2104 
2105 	return noffset;
2106 }
2107 
2108 /**
2109  * fit_image_get_os - get os id for a given component image node
2110  * @fit: pointer to the FIT format image header
2111  * @noffset: component image node offset
2112  * @os: pointer to the uint8_t, will hold os numeric id
2113  *
2114  * fit_image_get_os() finds os property in a given component image node.
2115  * If the property is found, its (string) value is translated to the numeric
2116  * id which is returned to the caller.
2117  *
2118  * returns:
2119  *     0, on success
2120  *     -1, on failure
2121  */
2122 int fit_image_get_os (const void *fit, int noffset, uint8_t *os)
2123 {
2124 	int len;
2125 	const void *data;
2126 
2127 	/* Get OS name from property data */
2128 	data = fdt_getprop (fit, noffset, FIT_OS_PROP, &len);
2129 	if (data == NULL) {
2130 		fit_get_debug (fit, noffset, FIT_OS_PROP, len);
2131 		*os = -1;
2132 		return -1;
2133 	}
2134 
2135 	/* Translate OS name to id */
2136 	*os = genimg_get_os_id (data);
2137 	return 0;
2138 }
2139 
2140 /**
2141  * fit_image_get_arch - get arch id for a given component image node
2142  * @fit: pointer to the FIT format image header
2143  * @noffset: component image node offset
2144  * @arch: pointer to the uint8_t, will hold arch numeric id
2145  *
2146  * fit_image_get_arch() finds arch property in a given component image node.
2147  * If the property is found, its (string) value is translated to the numeric
2148  * id which is returned to the caller.
2149  *
2150  * returns:
2151  *     0, on success
2152  *     -1, on failure
2153  */
2154 int fit_image_get_arch (const void *fit, int noffset, uint8_t *arch)
2155 {
2156 	int len;
2157 	const void *data;
2158 
2159 	/* Get architecture name from property data */
2160 	data = fdt_getprop (fit, noffset, FIT_ARCH_PROP, &len);
2161 	if (data == NULL) {
2162 		fit_get_debug (fit, noffset, FIT_ARCH_PROP, len);
2163 		*arch = -1;
2164 		return -1;
2165 	}
2166 
2167 	/* Translate architecture name to id */
2168 	*arch = genimg_get_arch_id (data);
2169 	return 0;
2170 }
2171 
2172 /**
2173  * fit_image_get_type - get type id for a given component image node
2174  * @fit: pointer to the FIT format image header
2175  * @noffset: component image node offset
2176  * @type: pointer to the uint8_t, will hold type numeric id
2177  *
2178  * fit_image_get_type() finds type property in a given component image node.
2179  * If the property is found, its (string) value is translated to the numeric
2180  * id which is returned to the caller.
2181  *
2182  * returns:
2183  *     0, on success
2184  *     -1, on failure
2185  */
2186 int fit_image_get_type (const void *fit, int noffset, uint8_t *type)
2187 {
2188 	int len;
2189 	const void *data;
2190 
2191 	/* Get image type name from property data */
2192 	data = fdt_getprop (fit, noffset, FIT_TYPE_PROP, &len);
2193 	if (data == NULL) {
2194 		fit_get_debug (fit, noffset, FIT_TYPE_PROP, len);
2195 		*type = -1;
2196 		return -1;
2197 	}
2198 
2199 	/* Translate image type name to id */
2200 	*type = genimg_get_type_id (data);
2201 	return 0;
2202 }
2203 
2204 /**
2205  * fit_image_get_comp - get comp id for a given component image node
2206  * @fit: pointer to the FIT format image header
2207  * @noffset: component image node offset
2208  * @comp: pointer to the uint8_t, will hold comp numeric id
2209  *
2210  * fit_image_get_comp() finds comp property in a given component image node.
2211  * If the property is found, its (string) value is translated to the numeric
2212  * id which is returned to the caller.
2213  *
2214  * returns:
2215  *     0, on success
2216  *     -1, on failure
2217  */
2218 int fit_image_get_comp (const void *fit, int noffset, uint8_t *comp)
2219 {
2220 	int len;
2221 	const void *data;
2222 
2223 	/* Get compression name from property data */
2224 	data = fdt_getprop (fit, noffset, FIT_COMP_PROP, &len);
2225 	if (data == NULL) {
2226 		fit_get_debug (fit, noffset, FIT_COMP_PROP, len);
2227 		*comp = -1;
2228 		return -1;
2229 	}
2230 
2231 	/* Translate compression name to id */
2232 	*comp = genimg_get_comp_id (data);
2233 	return 0;
2234 }
2235 
2236 /**
2237  * fit_image_get_load - get load address property for a given component image node
2238  * @fit: pointer to the FIT format image header
2239  * @noffset: component image node offset
2240  * @load: pointer to the uint32_t, will hold load address
2241  *
2242  * fit_image_get_load() finds load address property in a given component image node.
2243  * If the property is found, its value is returned to the caller.
2244  *
2245  * returns:
2246  *     0, on success
2247  *     -1, on failure
2248  */
2249 int fit_image_get_load (const void *fit, int noffset, ulong *load)
2250 {
2251 	int len;
2252 	const uint32_t *data;
2253 
2254 	data = fdt_getprop (fit, noffset, FIT_LOAD_PROP, &len);
2255 	if (data == NULL) {
2256 		fit_get_debug (fit, noffset, FIT_LOAD_PROP, len);
2257 		return -1;
2258 	}
2259 
2260 	*load = uimage_to_cpu (*data);
2261 	return 0;
2262 }
2263 
2264 /**
2265  * fit_image_get_entry - get entry point address property for a given component image node
2266  * @fit: pointer to the FIT format image header
2267  * @noffset: component image node offset
2268  * @entry: pointer to the uint32_t, will hold entry point address
2269  *
2270  * fit_image_get_entry() finds entry point address property in a given component image node.
2271  * If the property is found, its value is returned to the caller.
2272  *
2273  * returns:
2274  *     0, on success
2275  *     -1, on failure
2276  */
2277 int fit_image_get_entry (const void *fit, int noffset, ulong *entry)
2278 {
2279 	int len;
2280 	const uint32_t *data;
2281 
2282 	data = fdt_getprop (fit, noffset, FIT_ENTRY_PROP, &len);
2283 	if (data == NULL) {
2284 		fit_get_debug (fit, noffset, FIT_ENTRY_PROP, len);
2285 		return -1;
2286 	}
2287 
2288 	*entry = uimage_to_cpu (*data);
2289 	return 0;
2290 }
2291 
2292 /**
2293  * fit_image_get_data - get data property and its size for a given component image node
2294  * @fit: pointer to the FIT format image header
2295  * @noffset: component image node offset
2296  * @data: double pointer to void, will hold data property's data address
2297  * @size: pointer to size_t, will hold data property's data size
2298  *
2299  * fit_image_get_data() finds data property in a given component image node.
2300  * If the property is found its data start address and size are returned to
2301  * the caller.
2302  *
2303  * returns:
2304  *     0, on success
2305  *     -1, on failure
2306  */
2307 int fit_image_get_data (const void *fit, int noffset,
2308 		const void **data, size_t *size)
2309 {
2310 	int len;
2311 
2312 	*data = fdt_getprop (fit, noffset, FIT_DATA_PROP, &len);
2313 	if (*data == NULL) {
2314 		fit_get_debug (fit, noffset, FIT_DATA_PROP, len);
2315 		*size = 0;
2316 		return -1;
2317 	}
2318 
2319 	*size = len;
2320 	return 0;
2321 }
2322 
2323 /**
2324  * fit_image_hash_get_algo - get hash algorithm name
2325  * @fit: pointer to the FIT format image header
2326  * @noffset: hash node offset
2327  * @algo: double pointer to char, will hold pointer to the algorithm name
2328  *
2329  * fit_image_hash_get_algo() finds hash algorithm property in a given hash node.
2330  * If the property is found its data start address is returned to the caller.
2331  *
2332  * returns:
2333  *     0, on success
2334  *     -1, on failure
2335  */
2336 int fit_image_hash_get_algo (const void *fit, int noffset, char **algo)
2337 {
2338 	int len;
2339 
2340 	*algo = (char *)fdt_getprop (fit, noffset, FIT_ALGO_PROP, &len);
2341 	if (*algo == NULL) {
2342 		fit_get_debug (fit, noffset, FIT_ALGO_PROP, len);
2343 		return -1;
2344 	}
2345 
2346 	return 0;
2347 }
2348 
2349 /**
2350  * fit_image_hash_get_value - get hash value and length
2351  * @fit: pointer to the FIT format image header
2352  * @noffset: hash node offset
2353  * @value: double pointer to uint8_t, will hold address of a hash value data
2354  * @value_len: pointer to an int, will hold hash data length
2355  *
2356  * fit_image_hash_get_value() finds hash value property in a given hash node.
2357  * If the property is found its data start address and size are returned to
2358  * the caller.
2359  *
2360  * returns:
2361  *     0, on success
2362  *     -1, on failure
2363  */
2364 int fit_image_hash_get_value (const void *fit, int noffset, uint8_t **value,
2365 				int *value_len)
2366 {
2367 	int len;
2368 
2369 	*value = (uint8_t *)fdt_getprop (fit, noffset, FIT_VALUE_PROP, &len);
2370 	if (*value == NULL) {
2371 		fit_get_debug (fit, noffset, FIT_VALUE_PROP, len);
2372 		*value_len = 0;
2373 		return -1;
2374 	}
2375 
2376 	*value_len = len;
2377 	return 0;
2378 }
2379 
2380 /**
2381  * fit_set_timestamp - set node timestamp property
2382  * @fit: pointer to the FIT format image header
2383  * @noffset: node offset
2384  * @timestamp: timestamp value to be set
2385  *
2386  * fit_set_timestamp() attempts to set timestamp property in the requested
2387  * node and returns operation status to the caller.
2388  *
2389  * returns:
2390  *     0, on success
2391  *     -1, on property read failure
2392  */
2393 int fit_set_timestamp (void *fit, int noffset, time_t timestamp)
2394 {
2395 	uint32_t t;
2396 	int ret;
2397 
2398 	t = cpu_to_uimage (timestamp);
2399 	ret = fdt_setprop (fit, noffset, FIT_TIMESTAMP_PROP, &t,
2400 				sizeof (uint32_t));
2401 	if (ret) {
2402 		printf ("Can't set '%s' property for '%s' node (%s)\n",
2403 			FIT_TIMESTAMP_PROP, fit_get_name (fit, noffset, NULL),
2404 			fdt_strerror (ret));
2405 		return -1;
2406 	}
2407 
2408 	return 0;
2409 }
2410 
2411 /**
2412  * calculate_hash - calculate and return hash for provided input data
2413  * @data: pointer to the input data
2414  * @data_len: data length
2415  * @algo: requested hash algorithm
2416  * @value: pointer to the char, will hold hash value data (caller must
2417  * allocate enough free space)
2418  * value_len: length of the calculated hash
2419  *
2420  * calculate_hash() computes input data hash according to the requested algorithm.
2421  * Resulting hash value is placed in caller provided 'value' buffer, length
2422  * of the calculated hash is returned via value_len pointer argument.
2423  *
2424  * returns:
2425  *     0, on success
2426  *    -1, when algo is unsupported
2427  */
2428 static int calculate_hash (const void *data, int data_len, const char *algo,
2429 			uint8_t *value, int *value_len)
2430 {
2431 	if (strcmp (algo, "crc32") == 0 ) {
2432 		*((uint32_t *)value) = crc32_wd (0, data, data_len,
2433 							CHUNKSZ_CRC32);
2434 		*((uint32_t *)value) = cpu_to_uimage (*((uint32_t *)value));
2435 		*value_len = 4;
2436 	} else if (strcmp (algo, "sha1") == 0 ) {
2437 		sha1_csum_wd ((unsigned char *) data, data_len,
2438 				(unsigned char *) value, CHUNKSZ_SHA1);
2439 		*value_len = 20;
2440 	} else if (strcmp (algo, "md5") == 0 ) {
2441 		md5_wd ((unsigned char *)data, data_len, value, CHUNKSZ_MD5);
2442 		*value_len = 16;
2443 	} else {
2444 		debug ("Unsupported hash alogrithm\n");
2445 		return -1;
2446 	}
2447 	return 0;
2448 }
2449 
2450 #ifdef USE_HOSTCC
2451 /**
2452  * fit_set_hashes - process FIT component image nodes and calculate hashes
2453  * @fit: pointer to the FIT format image header
2454  *
2455  * fit_set_hashes() adds hash values for all component images in the FIT blob.
2456  * Hashes are calculated for all component images which have hash subnodes
2457  * with algorithm property set to one of the supported hash algorithms.
2458  *
2459  * returns
2460  *     0, on success
2461  *     libfdt error code, on failure
2462  */
2463 int fit_set_hashes (void *fit)
2464 {
2465 	int images_noffset;
2466 	int noffset;
2467 	int ndepth;
2468 	int ret;
2469 
2470 	/* Find images parent node offset */
2471 	images_noffset = fdt_path_offset (fit, FIT_IMAGES_PATH);
2472 	if (images_noffset < 0) {
2473 		printf ("Can't find images parent node '%s' (%s)\n",
2474 			FIT_IMAGES_PATH, fdt_strerror (images_noffset));
2475 		return images_noffset;
2476 	}
2477 
2478 	/* Process its subnodes, print out component images details */
2479 	for (ndepth = 0, noffset = fdt_next_node (fit, images_noffset, &ndepth);
2480 	     (noffset >= 0) && (ndepth > 0);
2481 	     noffset = fdt_next_node (fit, noffset, &ndepth)) {
2482 		if (ndepth == 1) {
2483 			/*
2484 			 * Direct child node of the images parent node,
2485 			 * i.e. component image node.
2486 			 */
2487 			ret = fit_image_set_hashes (fit, noffset);
2488 			if (ret)
2489 				return ret;
2490 		}
2491 	}
2492 
2493 	return 0;
2494 }
2495 
2496 /**
2497  * fit_image_set_hashes - calculate/set hashes for given component image node
2498  * @fit: pointer to the FIT format image header
2499  * @image_noffset: requested component image node
2500  *
2501  * fit_image_set_hashes() adds hash values for an component image node. All
2502  * existing hash subnodes are checked, if algorithm property is set to one of
2503  * the supported hash algorithms, hash value is computed and corresponding
2504  * hash node property is set, for example:
2505  *
2506  * Input component image node structure:
2507  *
2508  * o image@1 (at image_noffset)
2509  *   | - data = [binary data]
2510  *   o hash@1
2511  *     |- algo = "sha1"
2512  *
2513  * Output component image node structure:
2514  *
2515  * o image@1 (at image_noffset)
2516  *   | - data = [binary data]
2517  *   o hash@1
2518  *     |- algo = "sha1"
2519  *     |- value = sha1(data)
2520  *
2521  * returns:
2522  *     0 on sucess
2523  *    <0 on failure
2524  */
2525 int fit_image_set_hashes (void *fit, int image_noffset)
2526 {
2527 	const void *data;
2528 	size_t size;
2529 	char *algo;
2530 	uint8_t value[FIT_MAX_HASH_LEN];
2531 	int value_len;
2532 	int noffset;
2533 	int ndepth;
2534 
2535 	/* Get image data and data length */
2536 	if (fit_image_get_data (fit, image_noffset, &data, &size)) {
2537 		printf ("Can't get image data/size\n");
2538 		return -1;
2539 	}
2540 
2541 	/* Process all hash subnodes of the component image node */
2542 	for (ndepth = 0, noffset = fdt_next_node (fit, image_noffset, &ndepth);
2543 	     (noffset >= 0) && (ndepth > 0);
2544 	     noffset = fdt_next_node (fit, noffset, &ndepth)) {
2545 		if (ndepth == 1) {
2546 			/* Direct child node of the component image node */
2547 
2548 			/*
2549 			 * Check subnode name, must be equal to "hash".
2550 			 * Multiple hash nodes require unique unit node
2551 			 * names, e.g. hash@1, hash@2, etc.
2552 			 */
2553 			if (strncmp (fit_get_name(fit, noffset, NULL),
2554 						FIT_HASH_NODENAME,
2555 						strlen(FIT_HASH_NODENAME)) != 0) {
2556 				/* Not a hash subnode, skip it */
2557 				continue;
2558 			}
2559 
2560 			if (fit_image_hash_get_algo (fit, noffset, &algo)) {
2561 				printf ("Can't get hash algo property for "
2562 					"'%s' hash node in '%s' image node\n",
2563 					fit_get_name (fit, noffset, NULL),
2564 					fit_get_name (fit, image_noffset, NULL));
2565 				return -1;
2566 			}
2567 
2568 			if (calculate_hash (data, size, algo, value, &value_len)) {
2569 				printf ("Unsupported hash algorithm (%s) for "
2570 					"'%s' hash node in '%s' image node\n",
2571 					algo, fit_get_name (fit, noffset, NULL),
2572 					fit_get_name (fit, image_noffset, NULL));
2573 				return -1;
2574 			}
2575 
2576 			if (fit_image_hash_set_value (fit, noffset, value,
2577 							value_len)) {
2578 				printf ("Can't set hash value for "
2579 					"'%s' hash node in '%s' image node\n",
2580 					fit_get_name (fit, noffset, NULL),
2581 					fit_get_name (fit, image_noffset, NULL));
2582 				return -1;
2583 			}
2584 		}
2585 	}
2586 
2587 	return 0;
2588 }
2589 
2590 /**
2591  * fit_image_hash_set_value - set hash value in requested has node
2592  * @fit: pointer to the FIT format image header
2593  * @noffset: hash node offset
2594  * @value: hash value to be set
2595  * @value_len: hash value length
2596  *
2597  * fit_image_hash_set_value() attempts to set hash value in a node at offset
2598  * given and returns operation status to the caller.
2599  *
2600  * returns
2601  *     0, on success
2602  *     -1, on failure
2603  */
2604 int fit_image_hash_set_value (void *fit, int noffset, uint8_t *value,
2605 				int value_len)
2606 {
2607 	int ret;
2608 
2609 	ret = fdt_setprop (fit, noffset, FIT_VALUE_PROP, value, value_len);
2610 	if (ret) {
2611 		printf ("Can't set hash '%s' property for '%s' node (%s)\n",
2612 			FIT_VALUE_PROP, fit_get_name (fit, noffset, NULL),
2613 			fdt_strerror (ret));
2614 		return -1;
2615 	}
2616 
2617 	return 0;
2618 }
2619 #endif /* USE_HOSTCC */
2620 
2621 /**
2622  * fit_image_check_hashes - verify data intergity
2623  * @fit: pointer to the FIT format image header
2624  * @image_noffset: component image node offset
2625  *
2626  * fit_image_check_hashes() goes over component image hash nodes,
2627  * re-calculates each data hash and compares with the value stored in hash
2628  * node.
2629  *
2630  * returns:
2631  *     1, if all hashes are valid
2632  *     0, otherwise (or on error)
2633  */
2634 int fit_image_check_hashes (const void *fit, int image_noffset)
2635 {
2636 	const void	*data;
2637 	size_t		size;
2638 	char		*algo;
2639 	uint8_t		*fit_value;
2640 	int		fit_value_len;
2641 	uint8_t		value[FIT_MAX_HASH_LEN];
2642 	int		value_len;
2643 	int		noffset;
2644 	int		ndepth;
2645 	char		*err_msg = "";
2646 
2647 	/* Get image data and data length */
2648 	if (fit_image_get_data (fit, image_noffset, &data, &size)) {
2649 		printf ("Can't get image data/size\n");
2650 		return 0;
2651 	}
2652 
2653 	/* Process all hash subnodes of the component image node */
2654 	for (ndepth = 0, noffset = fdt_next_node (fit, image_noffset, &ndepth);
2655 	     (noffset >= 0) && (ndepth > 0);
2656 	     noffset = fdt_next_node (fit, noffset, &ndepth)) {
2657 		if (ndepth == 1) {
2658 			/* Direct child node of the component image node */
2659 
2660 			/*
2661 			 * Check subnode name, must be equal to "hash".
2662 			 * Multiple hash nodes require unique unit node
2663 			 * names, e.g. hash@1, hash@2, etc.
2664 			 */
2665 			if (strncmp (fit_get_name(fit, noffset, NULL),
2666 					FIT_HASH_NODENAME,
2667 					strlen(FIT_HASH_NODENAME)) != 0)
2668 				continue;
2669 
2670 			if (fit_image_hash_get_algo (fit, noffset, &algo)) {
2671 				err_msg = " error!\nCan't get hash algo "
2672 						"property";
2673 				goto error;
2674 			}
2675 			printf ("%s", algo);
2676 
2677 			if (fit_image_hash_get_value (fit, noffset, &fit_value,
2678 							&fit_value_len)) {
2679 				err_msg = " error!\nCan't get hash value "
2680 						"property";
2681 				goto error;
2682 			}
2683 
2684 			if (calculate_hash (data, size, algo, value, &value_len)) {
2685 				err_msg = " error!\nUnsupported hash algorithm";
2686 				goto error;
2687 			}
2688 
2689 			if (value_len != fit_value_len) {
2690 				err_msg = " error !\nBad hash value len";
2691 				goto error;
2692 			} else if (memcmp (value, fit_value, value_len) != 0) {
2693 				err_msg = " error!\nBad hash value";
2694 				goto error;
2695 			}
2696 			printf ("+ ");
2697 		}
2698 	}
2699 
2700 	return 1;
2701 
2702 error:
2703 	printf ("%s for '%s' hash node in '%s' image node\n",
2704 			err_msg, fit_get_name (fit, noffset, NULL),
2705 			fit_get_name (fit, image_noffset, NULL));
2706 	return 0;
2707 }
2708 
2709 /**
2710  * fit_all_image_check_hashes - verify data intergity for all images
2711  * @fit: pointer to the FIT format image header
2712  *
2713  * fit_all_image_check_hashes() goes over all images in the FIT and
2714  * for every images checks if all it's hashes are valid.
2715  *
2716  * returns:
2717  *     1, if all hashes of all images are valid
2718  *     0, otherwise (or on error)
2719  */
2720 int fit_all_image_check_hashes (const void *fit)
2721 {
2722 	int images_noffset;
2723 	int noffset;
2724 	int ndepth;
2725 	int count;
2726 
2727 	/* Find images parent node offset */
2728 	images_noffset = fdt_path_offset (fit, FIT_IMAGES_PATH);
2729 	if (images_noffset < 0) {
2730 		printf ("Can't find images parent node '%s' (%s)\n",
2731 			FIT_IMAGES_PATH, fdt_strerror (images_noffset));
2732 		return 0;
2733 	}
2734 
2735 	/* Process all image subnodes, check hashes for each */
2736 	printf ("## Checking hash(es) for FIT Image at %08lx ...\n",
2737 		(ulong)fit);
2738 	for (ndepth = 0, count = 0,
2739 		noffset = fdt_next_node (fit, images_noffset, &ndepth);
2740 		(noffset >= 0) && (ndepth > 0);
2741 		noffset = fdt_next_node (fit, noffset, &ndepth)) {
2742 		if (ndepth == 1) {
2743 			/*
2744 			 * Direct child node of the images parent node,
2745 			 * i.e. component image node.
2746 			 */
2747 			printf ("   Hash(es) for Image %u (%s): ", count++,
2748 					fit_get_name (fit, noffset, NULL));
2749 
2750 			if (!fit_image_check_hashes (fit, noffset))
2751 				return 0;
2752 			printf ("\n");
2753 		}
2754 	}
2755 	return 1;
2756 }
2757 
2758 /**
2759  * fit_image_check_os - check whether image node is of a given os type
2760  * @fit: pointer to the FIT format image header
2761  * @noffset: component image node offset
2762  * @os: requested image os
2763  *
2764  * fit_image_check_os() reads image os property and compares its numeric
2765  * id with the requested os. Comparison result is returned to the caller.
2766  *
2767  * returns:
2768  *     1 if image is of given os type
2769  *     0 otherwise (or on error)
2770  */
2771 int fit_image_check_os (const void *fit, int noffset, uint8_t os)
2772 {
2773 	uint8_t image_os;
2774 
2775 	if (fit_image_get_os (fit, noffset, &image_os))
2776 		return 0;
2777 	return (os == image_os);
2778 }
2779 
2780 /**
2781  * fit_image_check_arch - check whether image node is of a given arch
2782  * @fit: pointer to the FIT format image header
2783  * @noffset: component image node offset
2784  * @arch: requested imagearch
2785  *
2786  * fit_image_check_arch() reads image arch property and compares its numeric
2787  * id with the requested arch. Comparison result is returned to the caller.
2788  *
2789  * returns:
2790  *     1 if image is of given arch
2791  *     0 otherwise (or on error)
2792  */
2793 int fit_image_check_arch (const void *fit, int noffset, uint8_t arch)
2794 {
2795 	uint8_t image_arch;
2796 
2797 	if (fit_image_get_arch (fit, noffset, &image_arch))
2798 		return 0;
2799 	return (arch == image_arch);
2800 }
2801 
2802 /**
2803  * fit_image_check_type - check whether image node is of a given type
2804  * @fit: pointer to the FIT format image header
2805  * @noffset: component image node offset
2806  * @type: requested image type
2807  *
2808  * fit_image_check_type() reads image type property and compares its numeric
2809  * id with the requested type. Comparison result is returned to the caller.
2810  *
2811  * returns:
2812  *     1 if image is of given type
2813  *     0 otherwise (or on error)
2814  */
2815 int fit_image_check_type (const void *fit, int noffset, uint8_t type)
2816 {
2817 	uint8_t image_type;
2818 
2819 	if (fit_image_get_type (fit, noffset, &image_type))
2820 		return 0;
2821 	return (type == image_type);
2822 }
2823 
2824 /**
2825  * fit_image_check_comp - check whether image node uses given compression
2826  * @fit: pointer to the FIT format image header
2827  * @noffset: component image node offset
2828  * @comp: requested image compression type
2829  *
2830  * fit_image_check_comp() reads image compression property and compares its
2831  * numeric id with the requested compression type. Comparison result is
2832  * returned to the caller.
2833  *
2834  * returns:
2835  *     1 if image uses requested compression
2836  *     0 otherwise (or on error)
2837  */
2838 int fit_image_check_comp (const void *fit, int noffset, uint8_t comp)
2839 {
2840 	uint8_t image_comp;
2841 
2842 	if (fit_image_get_comp (fit, noffset, &image_comp))
2843 		return 0;
2844 	return (comp == image_comp);
2845 }
2846 
2847 /**
2848  * fit_check_format - sanity check FIT image format
2849  * @fit: pointer to the FIT format image header
2850  *
2851  * fit_check_format() runs a basic sanity FIT image verification.
2852  * Routine checks for mandatory properties, nodes, etc.
2853  *
2854  * returns:
2855  *     1, on success
2856  *     0, on failure
2857  */
2858 int fit_check_format (const void *fit)
2859 {
2860 	/* mandatory / node 'description' property */
2861 	if (fdt_getprop (fit, 0, FIT_DESC_PROP, NULL) == NULL) {
2862 		debug ("Wrong FIT format: no description\n");
2863 		return 0;
2864 	}
2865 
2866 #if defined(CONFIG_TIMESTAMP) || defined(CONFIG_CMD_DATE) || defined(USE_HOSTCC)
2867 	/* mandatory / node 'timestamp' property */
2868 	if (fdt_getprop (fit, 0, FIT_TIMESTAMP_PROP, NULL) == NULL) {
2869 		debug ("Wrong FIT format: no timestamp\n");
2870 		return 0;
2871 	}
2872 #endif
2873 
2874 	/* mandatory subimages parent '/images' node */
2875 	if (fdt_path_offset (fit, FIT_IMAGES_PATH) < 0) {
2876 		debug ("Wrong FIT format: no images parent node\n");
2877 		return 0;
2878 	}
2879 
2880 	return 1;
2881 }
2882 
2883 /**
2884  * fit_conf_get_node - get node offset for configuration of a given unit name
2885  * @fit: pointer to the FIT format image header
2886  * @conf_uname: configuration node unit name
2887  *
2888  * fit_conf_get_node() finds a configuration (withing the '/configurations'
2889  * parant node) of a provided unit name. If configuration is found its node offset
2890  * is returned to the caller.
2891  *
2892  * When NULL is provided in second argument fit_conf_get_node() will search
2893  * for a default configuration node instead. Default configuration node unit name
2894  * is retrived from FIT_DEFAULT_PROP property of the '/configurations' node.
2895  *
2896  * returns:
2897  *     configuration node offset when found (>=0)
2898  *     negative number on failure (FDT_ERR_* code)
2899  */
2900 int fit_conf_get_node (const void *fit, const char *conf_uname)
2901 {
2902 	int noffset, confs_noffset;
2903 	int len;
2904 
2905 	confs_noffset = fdt_path_offset (fit, FIT_CONFS_PATH);
2906 	if (confs_noffset < 0) {
2907 		debug ("Can't find configurations parent node '%s' (%s)\n",
2908 			FIT_CONFS_PATH, fdt_strerror (confs_noffset));
2909 		return confs_noffset;
2910 	}
2911 
2912 	if (conf_uname == NULL) {
2913 		/* get configuration unit name from the default property */
2914 		debug ("No configuration specified, trying default...\n");
2915 		conf_uname = (char *)fdt_getprop (fit, confs_noffset, FIT_DEFAULT_PROP, &len);
2916 		if (conf_uname == NULL) {
2917 			fit_get_debug (fit, confs_noffset, FIT_DEFAULT_PROP, len);
2918 			return len;
2919 		}
2920 		debug ("Found default configuration: '%s'\n", conf_uname);
2921 	}
2922 
2923 	noffset = fdt_subnode_offset (fit, confs_noffset, conf_uname);
2924 	if (noffset < 0) {
2925 		debug ("Can't get node offset for configuration unit name: '%s' (%s)\n",
2926 			conf_uname, fdt_strerror (noffset));
2927 	}
2928 
2929 	return noffset;
2930 }
2931 
2932 static int __fit_conf_get_prop_node (const void *fit, int noffset,
2933 		const char *prop_name)
2934 {
2935 	char *uname;
2936 	int len;
2937 
2938 	/* get kernel image unit name from configuration kernel property */
2939 	uname = (char *)fdt_getprop (fit, noffset, prop_name, &len);
2940 	if (uname == NULL)
2941 		return len;
2942 
2943 	return fit_image_get_node (fit, uname);
2944 }
2945 
2946 /**
2947  * fit_conf_get_kernel_node - get kernel image node offset that corresponds to
2948  * a given configuration
2949  * @fit: pointer to the FIT format image header
2950  * @noffset: configuration node offset
2951  *
2952  * fit_conf_get_kernel_node() retrives kernel image node unit name from
2953  * configuration FIT_KERNEL_PROP property and translates it to the node
2954  * offset.
2955  *
2956  * returns:
2957  *     image node offset when found (>=0)
2958  *     negative number on failure (FDT_ERR_* code)
2959  */
2960 int fit_conf_get_kernel_node (const void *fit, int noffset)
2961 {
2962 	return __fit_conf_get_prop_node (fit, noffset, FIT_KERNEL_PROP);
2963 }
2964 
2965 /**
2966  * fit_conf_get_ramdisk_node - get ramdisk image node offset that corresponds to
2967  * a given configuration
2968  * @fit: pointer to the FIT format image header
2969  * @noffset: configuration node offset
2970  *
2971  * fit_conf_get_ramdisk_node() retrives ramdisk image node unit name from
2972  * configuration FIT_KERNEL_PROP property and translates it to the node
2973  * offset.
2974  *
2975  * returns:
2976  *     image node offset when found (>=0)
2977  *     negative number on failure (FDT_ERR_* code)
2978  */
2979 int fit_conf_get_ramdisk_node (const void *fit, int noffset)
2980 {
2981 	return __fit_conf_get_prop_node (fit, noffset, FIT_RAMDISK_PROP);
2982 }
2983 
2984 /**
2985  * fit_conf_get_fdt_node - get fdt image node offset that corresponds to
2986  * a given configuration
2987  * @fit: pointer to the FIT format image header
2988  * @noffset: configuration node offset
2989  *
2990  * fit_conf_get_fdt_node() retrives fdt image node unit name from
2991  * configuration FIT_KERNEL_PROP property and translates it to the node
2992  * offset.
2993  *
2994  * returns:
2995  *     image node offset when found (>=0)
2996  *     negative number on failure (FDT_ERR_* code)
2997  */
2998 int fit_conf_get_fdt_node (const void *fit, int noffset)
2999 {
3000 	return __fit_conf_get_prop_node (fit, noffset, FIT_FDT_PROP);
3001 }
3002 
3003 /**
3004  * fit_conf_print - prints out the FIT configuration details
3005  * @fit: pointer to the FIT format image header
3006  * @noffset: offset of the configuration node
3007  * @p: pointer to prefix string
3008  *
3009  * fit_conf_print() lists all mandatory properies for the processed
3010  * configuration node.
3011  *
3012  * returns:
3013  *     no returned results
3014  */
3015 void fit_conf_print (const void *fit, int noffset, const char *p)
3016 {
3017 	char *desc;
3018 	char *uname;
3019 	int ret;
3020 
3021 	/* Mandatory properties */
3022 	ret = fit_get_desc (fit, noffset, &desc);
3023 	printf ("%s  Description:  ", p);
3024 	if (ret)
3025 		printf ("unavailable\n");
3026 	else
3027 		printf ("%s\n", desc);
3028 
3029 	uname = (char *)fdt_getprop (fit, noffset, FIT_KERNEL_PROP, NULL);
3030 	printf ("%s  Kernel:       ", p);
3031 	if (uname == NULL)
3032 		printf ("unavailable\n");
3033 	else
3034 		printf ("%s\n", uname);
3035 
3036 	/* Optional properties */
3037 	uname = (char *)fdt_getprop (fit, noffset, FIT_RAMDISK_PROP, NULL);
3038 	if (uname)
3039 		printf ("%s  Init Ramdisk: %s\n", p, uname);
3040 
3041 	uname = (char *)fdt_getprop (fit, noffset, FIT_FDT_PROP, NULL);
3042 	if (uname)
3043 		printf ("%s  FDT:          %s\n", p, uname);
3044 }
3045 
3046 /**
3047  * fit_check_ramdisk - verify FIT format ramdisk subimage
3048  * @fit_hdr: pointer to the FIT ramdisk header
3049  * @rd_noffset: ramdisk subimage node offset within FIT image
3050  * @arch: requested ramdisk image architecture type
3051  * @verify: data CRC verification flag
3052  *
3053  * fit_check_ramdisk() verifies integrity of the ramdisk subimage and from
3054  * specified FIT image.
3055  *
3056  * returns:
3057  *     1, on success
3058  *     0, on failure
3059  */
3060 #ifndef USE_HOSTCC
3061 static int fit_check_ramdisk (const void *fit, int rd_noffset, uint8_t arch, int verify)
3062 {
3063 	fit_image_print (fit, rd_noffset, "   ");
3064 
3065 	if (verify) {
3066 		puts ("   Verifying Hash Integrity ... ");
3067 		if (!fit_image_check_hashes (fit, rd_noffset)) {
3068 			puts ("Bad Data Hash\n");
3069 			show_boot_progress (-125);
3070 			return 0;
3071 		}
3072 		puts ("OK\n");
3073 	}
3074 
3075 	show_boot_progress (126);
3076 	if (!fit_image_check_os (fit, rd_noffset, IH_OS_LINUX) ||
3077 	    !fit_image_check_arch (fit, rd_noffset, arch) ||
3078 	    !fit_image_check_type (fit, rd_noffset, IH_TYPE_RAMDISK)) {
3079 		printf ("No Linux %s Ramdisk Image\n",
3080 				genimg_get_arch_name(arch));
3081 		show_boot_progress (-126);
3082 		return 0;
3083 	}
3084 
3085 	show_boot_progress (127);
3086 	return 1;
3087 }
3088 #endif /* USE_HOSTCC */
3089 #endif /* CONFIG_FIT */
3090