xref: /openbmc/u-boot/common/image.c (revision 9637c4b2)
1 /*
2  * (C) Copyright 2008 Semihalf
3  *
4  * (C) Copyright 2000-2006
5  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
6  *
7  * SPDX-License-Identifier:	GPL-2.0+
8  */
9 
10 #ifndef USE_HOSTCC
11 #include <common.h>
12 #include <watchdog.h>
13 
14 #ifdef CONFIG_SHOW_BOOT_PROGRESS
15 #include <status_led.h>
16 #endif
17 
18 #ifdef CONFIG_HAS_DATAFLASH
19 #include <dataflash.h>
20 #endif
21 
22 #ifdef CONFIG_LOGBUFFER
23 #include <logbuff.h>
24 #endif
25 
26 #include <rtc.h>
27 
28 #include <environment.h>
29 #include <image.h>
30 
31 #if defined(CONFIG_FIT) || defined(CONFIG_OF_LIBFDT)
32 #include <libfdt.h>
33 #include <fdt_support.h>
34 #endif
35 
36 #include <u-boot/md5.h>
37 #include <u-boot/sha1.h>
38 #include <asm/errno.h>
39 #include <asm/io.h>
40 
41 #ifdef CONFIG_CMD_BDI
42 extern int do_bdinfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
43 #endif
44 
45 DECLARE_GLOBAL_DATA_PTR;
46 
47 #if defined(CONFIG_IMAGE_FORMAT_LEGACY)
48 static const image_header_t *image_get_ramdisk(ulong rd_addr, uint8_t arch,
49 						int verify);
50 #endif
51 #else
52 #include "mkimage.h"
53 #include <u-boot/md5.h>
54 #include <time.h>
55 #include <image.h>
56 #endif /* !USE_HOSTCC*/
57 
58 #include <u-boot/crc.h>
59 
60 #ifndef CONFIG_SYS_BARGSIZE
61 #define CONFIG_SYS_BARGSIZE 512
62 #endif
63 
64 static const table_entry_t uimage_arch[] = {
65 	{	IH_ARCH_INVALID,	NULL,		"Invalid ARCH",	},
66 	{	IH_ARCH_ALPHA,		"alpha",	"Alpha",	},
67 	{	IH_ARCH_ARM,		"arm",		"ARM",		},
68 	{	IH_ARCH_I386,		"x86",		"Intel x86",	},
69 	{	IH_ARCH_IA64,		"ia64",		"IA64",		},
70 	{	IH_ARCH_M68K,		"m68k",		"M68K",		},
71 	{	IH_ARCH_MICROBLAZE,	"microblaze",	"MicroBlaze",	},
72 	{	IH_ARCH_MIPS,		"mips",		"MIPS",		},
73 	{	IH_ARCH_MIPS64,		"mips64",	"MIPS 64 Bit",	},
74 	{	IH_ARCH_NIOS2,		"nios2",	"NIOS II",	},
75 	{	IH_ARCH_PPC,		"powerpc",	"PowerPC",	},
76 	{	IH_ARCH_PPC,		"ppc",		"PowerPC",	},
77 	{	IH_ARCH_S390,		"s390",		"IBM S390",	},
78 	{	IH_ARCH_SH,		"sh",		"SuperH",	},
79 	{	IH_ARCH_SPARC,		"sparc",	"SPARC",	},
80 	{	IH_ARCH_SPARC64,	"sparc64",	"SPARC 64 Bit",	},
81 	{	IH_ARCH_BLACKFIN,	"blackfin",	"Blackfin",	},
82 	{	IH_ARCH_AVR32,		"avr32",	"AVR32",	},
83 	{	IH_ARCH_NDS32,		"nds32",	"NDS32",	},
84 	{	IH_ARCH_OPENRISC,	"or1k",		"OpenRISC 1000",},
85 	{	IH_ARCH_SANDBOX,	"sandbox",	"Sandbox",	},
86 	{	IH_ARCH_ARM64,		"arm64",	"AArch64",	},
87 	{	IH_ARCH_ARC,		"arc",		"ARC",		},
88 	{	IH_ARCH_X86_64,		"x86_64",	"AMD x86_64",	},
89 	{	-1,			"",		"",		},
90 };
91 
92 static const table_entry_t uimage_os[] = {
93 	{	IH_OS_INVALID,	NULL,		"Invalid OS",		},
94 	{	IH_OS_LINUX,	"linux",	"Linux",		},
95 #if defined(CONFIG_LYNXKDI) || defined(USE_HOSTCC)
96 	{	IH_OS_LYNXOS,	"lynxos",	"LynxOS",		},
97 #endif
98 	{	IH_OS_NETBSD,	"netbsd",	"NetBSD",		},
99 	{	IH_OS_OSE,	"ose",		"Enea OSE",		},
100 	{	IH_OS_PLAN9,	"plan9",	"Plan 9",		},
101 	{	IH_OS_RTEMS,	"rtems",	"RTEMS",		},
102 	{	IH_OS_U_BOOT,	"u-boot",	"U-Boot",		},
103 	{	IH_OS_VXWORKS,	"vxworks",	"VxWorks",		},
104 #if defined(CONFIG_CMD_ELF) || defined(USE_HOSTCC)
105 	{	IH_OS_QNX,	"qnx",		"QNX",			},
106 #endif
107 #if defined(CONFIG_INTEGRITY) || defined(USE_HOSTCC)
108 	{	IH_OS_INTEGRITY,"integrity",	"INTEGRITY",		},
109 #endif
110 #ifdef USE_HOSTCC
111 	{	IH_OS_4_4BSD,	"4_4bsd",	"4_4BSD",		},
112 	{	IH_OS_DELL,	"dell",		"Dell",			},
113 	{	IH_OS_ESIX,	"esix",		"Esix",			},
114 	{	IH_OS_FREEBSD,	"freebsd",	"FreeBSD",		},
115 	{	IH_OS_IRIX,	"irix",		"Irix",			},
116 	{	IH_OS_NCR,	"ncr",		"NCR",			},
117 	{	IH_OS_OPENBSD,	"openbsd",	"OpenBSD",		},
118 	{	IH_OS_PSOS,	"psos",		"pSOS",			},
119 	{	IH_OS_SCO,	"sco",		"SCO",			},
120 	{	IH_OS_SOLARIS,	"solaris",	"Solaris",		},
121 	{	IH_OS_SVR4,	"svr4",		"SVR4",			},
122 #endif
123 	{	-1,		"",		"",			},
124 };
125 
126 static const table_entry_t uimage_type[] = {
127 	{	IH_TYPE_AISIMAGE,   "aisimage",   "Davinci AIS image",},
128 	{	IH_TYPE_FILESYSTEM, "filesystem", "Filesystem Image",	},
129 	{	IH_TYPE_FIRMWARE,   "firmware",	  "Firmware",		},
130 	{	IH_TYPE_FLATDT,     "flat_dt",    "Flat Device Tree",	},
131 	{	IH_TYPE_GPIMAGE,    "gpimage",    "TI Keystone SPL Image",},
132 	{	IH_TYPE_KERNEL,	    "kernel",	  "Kernel Image",	},
133 	{	IH_TYPE_KERNEL_NOLOAD, "kernel_noload",  "Kernel Image (no loading done)", },
134 	{	IH_TYPE_KWBIMAGE,   "kwbimage",   "Kirkwood Boot Image",},
135 	{	IH_TYPE_IMXIMAGE,   "imximage",   "Freescale i.MX Boot Image",},
136 	{	IH_TYPE_INVALID,    NULL,	  "Invalid Image",	},
137 	{	IH_TYPE_MULTI,	    "multi",	  "Multi-File Image",	},
138 	{	IH_TYPE_OMAPIMAGE,  "omapimage",  "TI OMAP SPL With GP CH",},
139 	{	IH_TYPE_PBLIMAGE,   "pblimage",   "Freescale PBL Boot Image",},
140 	{	IH_TYPE_RAMDISK,    "ramdisk",	  "RAMDisk Image",	},
141 	{	IH_TYPE_SCRIPT,     "script",	  "Script",		},
142 	{	IH_TYPE_SOCFPGAIMAGE, "socfpgaimage", "Altera SOCFPGA preloader",},
143 	{	IH_TYPE_STANDALONE, "standalone", "Standalone Program", },
144 	{	IH_TYPE_UBLIMAGE,   "ublimage",   "Davinci UBL image",},
145 	{	IH_TYPE_MXSIMAGE,   "mxsimage",   "Freescale MXS Boot Image",},
146 	{	IH_TYPE_ATMELIMAGE, "atmelimage", "ATMEL ROM-Boot Image",},
147 	{	IH_TYPE_X86_SETUP,  "x86_setup",  "x86 setup.bin",    },
148 	{	-1,		    "",		  "",			},
149 };
150 
151 static const table_entry_t uimage_comp[] = {
152 	{	IH_COMP_NONE,	"none",		"uncompressed",		},
153 	{	IH_COMP_BZIP2,	"bzip2",	"bzip2 compressed",	},
154 	{	IH_COMP_GZIP,	"gzip",		"gzip compressed",	},
155 	{	IH_COMP_LZMA,	"lzma",		"lzma compressed",	},
156 	{	IH_COMP_LZO,	"lzo",		"lzo compressed",	},
157 	{	-1,		"",		"",			},
158 };
159 
160 /*****************************************************************************/
161 /* Legacy format routines */
162 /*****************************************************************************/
163 int image_check_hcrc(const image_header_t *hdr)
164 {
165 	ulong hcrc;
166 	ulong len = image_get_header_size();
167 	image_header_t header;
168 
169 	/* Copy header so we can blank CRC field for re-calculation */
170 	memmove(&header, (char *)hdr, image_get_header_size());
171 	image_set_hcrc(&header, 0);
172 
173 	hcrc = crc32(0, (unsigned char *)&header, len);
174 
175 	return (hcrc == image_get_hcrc(hdr));
176 }
177 
178 int image_check_dcrc(const image_header_t *hdr)
179 {
180 	ulong data = image_get_data(hdr);
181 	ulong len = image_get_data_size(hdr);
182 	ulong dcrc = crc32_wd(0, (unsigned char *)data, len, CHUNKSZ_CRC32);
183 
184 	return (dcrc == image_get_dcrc(hdr));
185 }
186 
187 /**
188  * image_multi_count - get component (sub-image) count
189  * @hdr: pointer to the header of the multi component image
190  *
191  * image_multi_count() returns number of components in a multi
192  * component image.
193  *
194  * Note: no checking of the image type is done, caller must pass
195  * a valid multi component image.
196  *
197  * returns:
198  *     number of components
199  */
200 ulong image_multi_count(const image_header_t *hdr)
201 {
202 	ulong i, count = 0;
203 	uint32_t *size;
204 
205 	/* get start of the image payload, which in case of multi
206 	 * component images that points to a table of component sizes */
207 	size = (uint32_t *)image_get_data(hdr);
208 
209 	/* count non empty slots */
210 	for (i = 0; size[i]; ++i)
211 		count++;
212 
213 	return count;
214 }
215 
216 /**
217  * image_multi_getimg - get component data address and size
218  * @hdr: pointer to the header of the multi component image
219  * @idx: index of the requested component
220  * @data: pointer to a ulong variable, will hold component data address
221  * @len: pointer to a ulong variable, will hold component size
222  *
223  * image_multi_getimg() returns size and data address for the requested
224  * component in a multi component image.
225  *
226  * Note: no checking of the image type is done, caller must pass
227  * a valid multi component image.
228  *
229  * returns:
230  *     data address and size of the component, if idx is valid
231  *     0 in data and len, if idx is out of range
232  */
233 void image_multi_getimg(const image_header_t *hdr, ulong idx,
234 			ulong *data, ulong *len)
235 {
236 	int i;
237 	uint32_t *size;
238 	ulong offset, count, img_data;
239 
240 	/* get number of component */
241 	count = image_multi_count(hdr);
242 
243 	/* get start of the image payload, which in case of multi
244 	 * component images that points to a table of component sizes */
245 	size = (uint32_t *)image_get_data(hdr);
246 
247 	/* get address of the proper component data start, which means
248 	 * skipping sizes table (add 1 for last, null entry) */
249 	img_data = image_get_data(hdr) + (count + 1) * sizeof(uint32_t);
250 
251 	if (idx < count) {
252 		*len = uimage_to_cpu(size[idx]);
253 		offset = 0;
254 
255 		/* go over all indices preceding requested component idx */
256 		for (i = 0; i < idx; i++) {
257 			/* add up i-th component size, rounding up to 4 bytes */
258 			offset += (uimage_to_cpu(size[i]) + 3) & ~3 ;
259 		}
260 
261 		/* calculate idx-th component data address */
262 		*data = img_data + offset;
263 	} else {
264 		*len = 0;
265 		*data = 0;
266 	}
267 }
268 
269 static void image_print_type(const image_header_t *hdr)
270 {
271 	const char *os, *arch, *type, *comp;
272 
273 	os = genimg_get_os_name(image_get_os(hdr));
274 	arch = genimg_get_arch_name(image_get_arch(hdr));
275 	type = genimg_get_type_name(image_get_type(hdr));
276 	comp = genimg_get_comp_name(image_get_comp(hdr));
277 
278 	printf("%s %s %s (%s)\n", arch, os, type, comp);
279 }
280 
281 /**
282  * image_print_contents - prints out the contents of the legacy format image
283  * @ptr: pointer to the legacy format image header
284  * @p: pointer to prefix string
285  *
286  * image_print_contents() formats a multi line legacy image contents description.
287  * The routine prints out all header fields followed by the size/offset data
288  * for MULTI/SCRIPT images.
289  *
290  * returns:
291  *     no returned results
292  */
293 void image_print_contents(const void *ptr)
294 {
295 	const image_header_t *hdr = (const image_header_t *)ptr;
296 	const char *p;
297 
298 	p = IMAGE_INDENT_STRING;
299 	printf("%sImage Name:   %.*s\n", p, IH_NMLEN, image_get_name(hdr));
300 	if (IMAGE_ENABLE_TIMESTAMP) {
301 		printf("%sCreated:      ", p);
302 		genimg_print_time((time_t)image_get_time(hdr));
303 	}
304 	printf("%sImage Type:   ", p);
305 	image_print_type(hdr);
306 	printf("%sData Size:    ", p);
307 	genimg_print_size(image_get_data_size(hdr));
308 	printf("%sLoad Address: %08x\n", p, image_get_load(hdr));
309 	printf("%sEntry Point:  %08x\n", p, image_get_ep(hdr));
310 
311 	if (image_check_type(hdr, IH_TYPE_MULTI) ||
312 			image_check_type(hdr, IH_TYPE_SCRIPT)) {
313 		int i;
314 		ulong data, len;
315 		ulong count = image_multi_count(hdr);
316 
317 		printf("%sContents:\n", p);
318 		for (i = 0; i < count; i++) {
319 			image_multi_getimg(hdr, i, &data, &len);
320 
321 			printf("%s   Image %d: ", p, i);
322 			genimg_print_size(len);
323 
324 			if (image_check_type(hdr, IH_TYPE_SCRIPT) && i > 0) {
325 				/*
326 				 * the user may need to know offsets
327 				 * if planning to do something with
328 				 * multiple files
329 				 */
330 				printf("%s    Offset = 0x%08lx\n", p, data);
331 			}
332 		}
333 	}
334 }
335 
336 
337 #ifndef USE_HOSTCC
338 #if defined(CONFIG_IMAGE_FORMAT_LEGACY)
339 /**
340  * image_get_ramdisk - get and verify ramdisk image
341  * @rd_addr: ramdisk image start address
342  * @arch: expected ramdisk architecture
343  * @verify: checksum verification flag
344  *
345  * image_get_ramdisk() returns a pointer to the verified ramdisk image
346  * header. Routine receives image start address and expected architecture
347  * flag. Verification done covers data and header integrity and os/type/arch
348  * fields checking.
349  *
350  * If dataflash support is enabled routine checks for dataflash addresses
351  * and handles required dataflash reads.
352  *
353  * returns:
354  *     pointer to a ramdisk image header, if image was found and valid
355  *     otherwise, return NULL
356  */
357 static const image_header_t *image_get_ramdisk(ulong rd_addr, uint8_t arch,
358 						int verify)
359 {
360 	const image_header_t *rd_hdr = (const image_header_t *)rd_addr;
361 
362 	if (!image_check_magic(rd_hdr)) {
363 		puts("Bad Magic Number\n");
364 		bootstage_error(BOOTSTAGE_ID_RD_MAGIC);
365 		return NULL;
366 	}
367 
368 	if (!image_check_hcrc(rd_hdr)) {
369 		puts("Bad Header Checksum\n");
370 		bootstage_error(BOOTSTAGE_ID_RD_HDR_CHECKSUM);
371 		return NULL;
372 	}
373 
374 	bootstage_mark(BOOTSTAGE_ID_RD_MAGIC);
375 	image_print_contents(rd_hdr);
376 
377 	if (verify) {
378 		puts("   Verifying Checksum ... ");
379 		if (!image_check_dcrc(rd_hdr)) {
380 			puts("Bad Data CRC\n");
381 			bootstage_error(BOOTSTAGE_ID_RD_CHECKSUM);
382 			return NULL;
383 		}
384 		puts("OK\n");
385 	}
386 
387 	bootstage_mark(BOOTSTAGE_ID_RD_HDR_CHECKSUM);
388 
389 	if (!image_check_os(rd_hdr, IH_OS_LINUX) ||
390 	    !image_check_arch(rd_hdr, arch) ||
391 	    !image_check_type(rd_hdr, IH_TYPE_RAMDISK)) {
392 		printf("No Linux %s Ramdisk Image\n",
393 				genimg_get_arch_name(arch));
394 		bootstage_error(BOOTSTAGE_ID_RAMDISK);
395 		return NULL;
396 	}
397 
398 	return rd_hdr;
399 }
400 #endif
401 #endif /* !USE_HOSTCC */
402 
403 /*****************************************************************************/
404 /* Shared dual-format routines */
405 /*****************************************************************************/
406 #ifndef USE_HOSTCC
407 ulong load_addr = CONFIG_SYS_LOAD_ADDR;	/* Default Load Address */
408 ulong save_addr;			/* Default Save Address */
409 ulong save_size;			/* Default Save Size (in bytes) */
410 
411 static int on_loadaddr(const char *name, const char *value, enum env_op op,
412 	int flags)
413 {
414 	switch (op) {
415 	case env_op_create:
416 	case env_op_overwrite:
417 		load_addr = simple_strtoul(value, NULL, 16);
418 		break;
419 	default:
420 		break;
421 	}
422 
423 	return 0;
424 }
425 U_BOOT_ENV_CALLBACK(loadaddr, on_loadaddr);
426 
427 ulong getenv_bootm_low(void)
428 {
429 	char *s = getenv("bootm_low");
430 	if (s) {
431 		ulong tmp = simple_strtoul(s, NULL, 16);
432 		return tmp;
433 	}
434 
435 #if defined(CONFIG_SYS_SDRAM_BASE)
436 	return CONFIG_SYS_SDRAM_BASE;
437 #elif defined(CONFIG_ARM)
438 	return gd->bd->bi_dram[0].start;
439 #else
440 	return 0;
441 #endif
442 }
443 
444 phys_size_t getenv_bootm_size(void)
445 {
446 	phys_size_t tmp;
447 	char *s = getenv("bootm_size");
448 	if (s) {
449 		tmp = (phys_size_t)simple_strtoull(s, NULL, 16);
450 		return tmp;
451 	}
452 	s = getenv("bootm_low");
453 	if (s)
454 		tmp = (phys_size_t)simple_strtoull(s, NULL, 16);
455 	else
456 		tmp = 0;
457 
458 
459 #if defined(CONFIG_ARM)
460 	return gd->bd->bi_dram[0].size - tmp;
461 #else
462 	return gd->bd->bi_memsize - tmp;
463 #endif
464 }
465 
466 phys_size_t getenv_bootm_mapsize(void)
467 {
468 	phys_size_t tmp;
469 	char *s = getenv("bootm_mapsize");
470 	if (s) {
471 		tmp = (phys_size_t)simple_strtoull(s, NULL, 16);
472 		return tmp;
473 	}
474 
475 #if defined(CONFIG_SYS_BOOTMAPSZ)
476 	return CONFIG_SYS_BOOTMAPSZ;
477 #else
478 	return getenv_bootm_size();
479 #endif
480 }
481 
482 void memmove_wd(void *to, void *from, size_t len, ulong chunksz)
483 {
484 	if (to == from)
485 		return;
486 
487 #if defined(CONFIG_HW_WATCHDOG) || defined(CONFIG_WATCHDOG)
488 	if (to > from) {
489 		from += len;
490 		to += len;
491 	}
492 	while (len > 0) {
493 		size_t tail = (len > chunksz) ? chunksz : len;
494 		WATCHDOG_RESET();
495 		if (to > from) {
496 			to -= tail;
497 			from -= tail;
498 		}
499 		memmove(to, from, tail);
500 		if (to < from) {
501 			to += tail;
502 			from += tail;
503 		}
504 		len -= tail;
505 	}
506 #else	/* !(CONFIG_HW_WATCHDOG || CONFIG_WATCHDOG) */
507 	memmove(to, from, len);
508 #endif	/* CONFIG_HW_WATCHDOG || CONFIG_WATCHDOG */
509 }
510 #endif /* !USE_HOSTCC */
511 
512 void genimg_print_size(uint32_t size)
513 {
514 #ifndef USE_HOSTCC
515 	printf("%d Bytes = ", size);
516 	print_size(size, "\n");
517 #else
518 	printf("%d Bytes = %.2f kB = %.2f MB\n",
519 			size, (double)size / 1.024e3,
520 			(double)size / 1.048576e6);
521 #endif
522 }
523 
524 #if IMAGE_ENABLE_TIMESTAMP
525 void genimg_print_time(time_t timestamp)
526 {
527 #ifndef USE_HOSTCC
528 	struct rtc_time tm;
529 
530 	to_tm(timestamp, &tm);
531 	printf("%4d-%02d-%02d  %2d:%02d:%02d UTC\n",
532 			tm.tm_year, tm.tm_mon, tm.tm_mday,
533 			tm.tm_hour, tm.tm_min, tm.tm_sec);
534 #else
535 	printf("%s", ctime(&timestamp));
536 #endif
537 }
538 #endif
539 
540 /**
541  * get_table_entry_name - translate entry id to long name
542  * @table: pointer to a translation table for entries of a specific type
543  * @msg: message to be returned when translation fails
544  * @id: entry id to be translated
545  *
546  * get_table_entry_name() will go over translation table trying to find
547  * entry that matches given id. If matching entry is found, its long
548  * name is returned to the caller.
549  *
550  * returns:
551  *     long entry name if translation succeeds
552  *     msg otherwise
553  */
554 char *get_table_entry_name(const table_entry_t *table, char *msg, int id)
555 {
556 	for (; table->id >= 0; ++table) {
557 		if (table->id == id)
558 #if defined(USE_HOSTCC) || !defined(CONFIG_NEEDS_MANUAL_RELOC)
559 			return table->lname;
560 #else
561 			return table->lname + gd->reloc_off;
562 #endif
563 	}
564 	return (msg);
565 }
566 
567 const char *genimg_get_os_name(uint8_t os)
568 {
569 	return (get_table_entry_name(uimage_os, "Unknown OS", os));
570 }
571 
572 const char *genimg_get_arch_name(uint8_t arch)
573 {
574 	return (get_table_entry_name(uimage_arch, "Unknown Architecture",
575 					arch));
576 }
577 
578 const char *genimg_get_type_name(uint8_t type)
579 {
580 	return (get_table_entry_name(uimage_type, "Unknown Image", type));
581 }
582 
583 const char *genimg_get_comp_name(uint8_t comp)
584 {
585 	return (get_table_entry_name(uimage_comp, "Unknown Compression",
586 					comp));
587 }
588 
589 /**
590  * get_table_entry_id - translate short entry name to id
591  * @table: pointer to a translation table for entries of a specific type
592  * @table_name: to be used in case of error
593  * @name: entry short name to be translated
594  *
595  * get_table_entry_id() will go over translation table trying to find
596  * entry that matches given short name. If matching entry is found,
597  * its id returned to the caller.
598  *
599  * returns:
600  *     entry id if translation succeeds
601  *     -1 otherwise
602  */
603 int get_table_entry_id(const table_entry_t *table,
604 		const char *table_name, const char *name)
605 {
606 	const table_entry_t *t;
607 #ifdef USE_HOSTCC
608 	int first = 1;
609 
610 	for (t = table; t->id >= 0; ++t) {
611 		if (t->sname && strcasecmp(t->sname, name) == 0)
612 			return(t->id);
613 	}
614 
615 	fprintf(stderr, "\nInvalid %s Type - valid names are", table_name);
616 	for (t = table; t->id >= 0; ++t) {
617 		if (t->sname == NULL)
618 			continue;
619 		fprintf(stderr, "%c %s", (first) ? ':' : ',', t->sname);
620 		first = 0;
621 	}
622 	fprintf(stderr, "\n");
623 #else
624 	for (t = table; t->id >= 0; ++t) {
625 #ifdef CONFIG_NEEDS_MANUAL_RELOC
626 		if (t->sname && strcmp(t->sname + gd->reloc_off, name) == 0)
627 #else
628 		if (t->sname && strcmp(t->sname, name) == 0)
629 #endif
630 			return (t->id);
631 	}
632 	debug("Invalid %s Type: %s\n", table_name, name);
633 #endif /* USE_HOSTCC */
634 	return (-1);
635 }
636 
637 int genimg_get_os_id(const char *name)
638 {
639 	return (get_table_entry_id(uimage_os, "OS", name));
640 }
641 
642 int genimg_get_arch_id(const char *name)
643 {
644 	return (get_table_entry_id(uimage_arch, "CPU", name));
645 }
646 
647 int genimg_get_type_id(const char *name)
648 {
649 	return (get_table_entry_id(uimage_type, "Image", name));
650 }
651 
652 int genimg_get_comp_id(const char *name)
653 {
654 	return (get_table_entry_id(uimage_comp, "Compression", name));
655 }
656 
657 #ifndef USE_HOSTCC
658 /**
659  * genimg_get_kernel_addr_fit - get the real kernel address and return 2
660  *                              FIT strings
661  * @img_addr: a string might contain real image address
662  * @fit_uname_config: double pointer to a char, will hold pointer to a
663  *                    configuration unit name
664  * @fit_uname_kernel: double pointer to a char, will hold pointer to a subimage
665  *                    name
666  *
667  * genimg_get_kernel_addr_fit get the real kernel start address from a string
668  * which is normally the first argv of bootm/bootz
669  *
670  * returns:
671  *     kernel start address
672  */
673 ulong genimg_get_kernel_addr_fit(char * const img_addr,
674 			     const char **fit_uname_config,
675 			     const char **fit_uname_kernel)
676 {
677 	ulong kernel_addr;
678 
679 	/* find out kernel image address */
680 	if (!img_addr) {
681 		kernel_addr = load_addr;
682 		debug("*  kernel: default image load address = 0x%08lx\n",
683 		      load_addr);
684 #if defined(CONFIG_FIT)
685 	} else if (fit_parse_conf(img_addr, load_addr, &kernel_addr,
686 				  fit_uname_config)) {
687 		debug("*  kernel: config '%s' from image at 0x%08lx\n",
688 		      *fit_uname_config, kernel_addr);
689 	} else if (fit_parse_subimage(img_addr, load_addr, &kernel_addr,
690 				     fit_uname_kernel)) {
691 		debug("*  kernel: subimage '%s' from image at 0x%08lx\n",
692 		      *fit_uname_kernel, kernel_addr);
693 #endif
694 	} else {
695 		kernel_addr = simple_strtoul(img_addr, NULL, 16);
696 		debug("*  kernel: cmdline image address = 0x%08lx\n",
697 		      kernel_addr);
698 	}
699 
700 	return kernel_addr;
701 }
702 
703 /**
704  * genimg_get_kernel_addr() is the simple version of
705  * genimg_get_kernel_addr_fit(). It ignores those return FIT strings
706  */
707 ulong genimg_get_kernel_addr(char * const img_addr)
708 {
709 	const char *fit_uname_config = NULL;
710 	const char *fit_uname_kernel = NULL;
711 
712 	return genimg_get_kernel_addr_fit(img_addr, &fit_uname_config,
713 					  &fit_uname_kernel);
714 }
715 
716 /**
717  * genimg_get_format - get image format type
718  * @img_addr: image start address
719  *
720  * genimg_get_format() checks whether provided address points to a valid
721  * legacy or FIT image.
722  *
723  * New uImage format and FDT blob are based on a libfdt. FDT blob
724  * may be passed directly or embedded in a FIT image. In both situations
725  * genimg_get_format() must be able to dectect libfdt header.
726  *
727  * returns:
728  *     image format type or IMAGE_FORMAT_INVALID if no image is present
729  */
730 int genimg_get_format(const void *img_addr)
731 {
732 #if defined(CONFIG_IMAGE_FORMAT_LEGACY)
733 	const image_header_t *hdr;
734 
735 	hdr = (const image_header_t *)img_addr;
736 	if (image_check_magic(hdr))
737 		return IMAGE_FORMAT_LEGACY;
738 #endif
739 #if defined(CONFIG_FIT) || defined(CONFIG_OF_LIBFDT)
740 	if (fdt_check_header(img_addr) == 0)
741 		return IMAGE_FORMAT_FIT;
742 #endif
743 #ifdef CONFIG_ANDROID_BOOT_IMAGE
744 	if (android_image_check_header(img_addr) == 0)
745 		return IMAGE_FORMAT_ANDROID;
746 #endif
747 
748 	return IMAGE_FORMAT_INVALID;
749 }
750 
751 /**
752  * genimg_get_image - get image from special storage (if necessary)
753  * @img_addr: image start address
754  *
755  * genimg_get_image() checks if provided image start adddress is located
756  * in a dataflash storage. If so, image is moved to a system RAM memory.
757  *
758  * returns:
759  *     image start address after possible relocation from special storage
760  */
761 ulong genimg_get_image(ulong img_addr)
762 {
763 	ulong ram_addr = img_addr;
764 
765 #ifdef CONFIG_HAS_DATAFLASH
766 	ulong h_size, d_size;
767 
768 	if (addr_dataflash(img_addr)) {
769 		void *buf;
770 
771 		/* ger RAM address */
772 		ram_addr = CONFIG_SYS_LOAD_ADDR;
773 
774 		/* get header size */
775 		h_size = image_get_header_size();
776 #if defined(CONFIG_FIT)
777 		if (sizeof(struct fdt_header) > h_size)
778 			h_size = sizeof(struct fdt_header);
779 #endif
780 
781 		/* read in header */
782 		debug("   Reading image header from dataflash address "
783 			"%08lx to RAM address %08lx\n", img_addr, ram_addr);
784 
785 		buf = map_sysmem(ram_addr, 0);
786 		read_dataflash(img_addr, h_size, buf);
787 
788 		/* get data size */
789 		switch (genimg_get_format(buf)) {
790 #if defined(CONFIG_IMAGE_FORMAT_LEGACY)
791 		case IMAGE_FORMAT_LEGACY:
792 			d_size = image_get_data_size(buf);
793 			debug("   Legacy format image found at 0x%08lx, "
794 					"size 0x%08lx\n",
795 					ram_addr, d_size);
796 			break;
797 #endif
798 #if defined(CONFIG_FIT)
799 		case IMAGE_FORMAT_FIT:
800 			d_size = fit_get_size(buf) - h_size;
801 			debug("   FIT/FDT format image found at 0x%08lx, "
802 					"size 0x%08lx\n",
803 					ram_addr, d_size);
804 			break;
805 #endif
806 		default:
807 			printf("   No valid image found at 0x%08lx\n",
808 				img_addr);
809 			return ram_addr;
810 		}
811 
812 		/* read in image data */
813 		debug("   Reading image remaining data from dataflash address "
814 			"%08lx to RAM address %08lx\n", img_addr + h_size,
815 			ram_addr + h_size);
816 
817 		read_dataflash(img_addr + h_size, d_size,
818 				(char *)(buf + h_size));
819 
820 	}
821 #endif /* CONFIG_HAS_DATAFLASH */
822 
823 	return ram_addr;
824 }
825 
826 /**
827  * fit_has_config - check if there is a valid FIT configuration
828  * @images: pointer to the bootm command headers structure
829  *
830  * fit_has_config() checks if there is a FIT configuration in use
831  * (if FTI support is present).
832  *
833  * returns:
834  *     0, no FIT support or no configuration found
835  *     1, configuration found
836  */
837 int genimg_has_config(bootm_headers_t *images)
838 {
839 #if defined(CONFIG_FIT)
840 	if (images->fit_uname_cfg)
841 		return 1;
842 #endif
843 	return 0;
844 }
845 
846 /**
847  * boot_get_ramdisk - main ramdisk handling routine
848  * @argc: command argument count
849  * @argv: command argument list
850  * @images: pointer to the bootm images structure
851  * @arch: expected ramdisk architecture
852  * @rd_start: pointer to a ulong variable, will hold ramdisk start address
853  * @rd_end: pointer to a ulong variable, will hold ramdisk end
854  *
855  * boot_get_ramdisk() is responsible for finding a valid ramdisk image.
856  * Curently supported are the following ramdisk sources:
857  *      - multicomponent kernel/ramdisk image,
858  *      - commandline provided address of decicated ramdisk image.
859  *
860  * returns:
861  *     0, if ramdisk image was found and valid, or skiped
862  *     rd_start and rd_end are set to ramdisk start/end addresses if
863  *     ramdisk image is found and valid
864  *
865  *     1, if ramdisk image is found but corrupted, or invalid
866  *     rd_start and rd_end are set to 0 if no ramdisk exists
867  */
868 int boot_get_ramdisk(int argc, char * const argv[], bootm_headers_t *images,
869 		uint8_t arch, ulong *rd_start, ulong *rd_end)
870 {
871 	ulong rd_addr, rd_load;
872 	ulong rd_data, rd_len;
873 #if defined(CONFIG_IMAGE_FORMAT_LEGACY)
874 	const image_header_t *rd_hdr;
875 #endif
876 	void *buf;
877 #ifdef CONFIG_SUPPORT_RAW_INITRD
878 	char *end;
879 #endif
880 #if defined(CONFIG_FIT)
881 	const char	*fit_uname_config = images->fit_uname_cfg;
882 	const char	*fit_uname_ramdisk = NULL;
883 	ulong		default_addr;
884 	int		rd_noffset;
885 #endif
886 	const char *select = NULL;
887 
888 	*rd_start = 0;
889 	*rd_end = 0;
890 
891 	if (argc >= 2)
892 		select = argv[1];
893 	/*
894 	 * Look for a '-' which indicates to ignore the
895 	 * ramdisk argument
896 	 */
897 	if (select && strcmp(select, "-") ==  0) {
898 		debug("## Skipping init Ramdisk\n");
899 		rd_len = rd_data = 0;
900 	} else if (select || genimg_has_config(images)) {
901 #if defined(CONFIG_FIT)
902 		if (select) {
903 			/*
904 			 * If the init ramdisk comes from the FIT image and
905 			 * the FIT image address is omitted in the command
906 			 * line argument, try to use os FIT image address or
907 			 * default load address.
908 			 */
909 			if (images->fit_uname_os)
910 				default_addr = (ulong)images->fit_hdr_os;
911 			else
912 				default_addr = load_addr;
913 
914 			if (fit_parse_conf(select, default_addr,
915 					   &rd_addr, &fit_uname_config)) {
916 				debug("*  ramdisk: config '%s' from image at "
917 						"0x%08lx\n",
918 						fit_uname_config, rd_addr);
919 			} else if (fit_parse_subimage(select, default_addr,
920 						&rd_addr, &fit_uname_ramdisk)) {
921 				debug("*  ramdisk: subimage '%s' from image at "
922 						"0x%08lx\n",
923 						fit_uname_ramdisk, rd_addr);
924 			} else
925 #endif
926 			{
927 				rd_addr = simple_strtoul(select, NULL, 16);
928 				debug("*  ramdisk: cmdline image address = "
929 						"0x%08lx\n",
930 						rd_addr);
931 			}
932 #if defined(CONFIG_FIT)
933 		} else {
934 			/* use FIT configuration provided in first bootm
935 			 * command argument. If the property is not defined,
936 			 * quit silently.
937 			 */
938 			rd_addr = map_to_sysmem(images->fit_hdr_os);
939 			rd_noffset = fit_get_node_from_config(images,
940 					FIT_RAMDISK_PROP, rd_addr);
941 			if (rd_noffset == -ENOLINK)
942 				return 0;
943 			else if (rd_noffset < 0)
944 				return 1;
945 		}
946 #endif
947 
948 		/* copy from dataflash if needed */
949 		rd_addr = genimg_get_image(rd_addr);
950 
951 		/*
952 		 * Check if there is an initrd image at the
953 		 * address provided in the second bootm argument
954 		 * check image type, for FIT images get FIT node.
955 		 */
956 		buf = map_sysmem(rd_addr, 0);
957 		switch (genimg_get_format(buf)) {
958 #if defined(CONFIG_IMAGE_FORMAT_LEGACY)
959 		case IMAGE_FORMAT_LEGACY:
960 			printf("## Loading init Ramdisk from Legacy "
961 					"Image at %08lx ...\n", rd_addr);
962 
963 			bootstage_mark(BOOTSTAGE_ID_CHECK_RAMDISK);
964 			rd_hdr = image_get_ramdisk(rd_addr, arch,
965 							images->verify);
966 
967 			if (rd_hdr == NULL)
968 				return 1;
969 
970 			rd_data = image_get_data(rd_hdr);
971 			rd_len = image_get_data_size(rd_hdr);
972 			rd_load = image_get_load(rd_hdr);
973 			break;
974 #endif
975 #if defined(CONFIG_FIT)
976 		case IMAGE_FORMAT_FIT:
977 			rd_noffset = fit_image_load(images,
978 					rd_addr, &fit_uname_ramdisk,
979 					&fit_uname_config, arch,
980 					IH_TYPE_RAMDISK,
981 					BOOTSTAGE_ID_FIT_RD_START,
982 					FIT_LOAD_OPTIONAL_NON_ZERO,
983 					&rd_data, &rd_len);
984 			if (rd_noffset < 0)
985 				return 1;
986 
987 			images->fit_hdr_rd = map_sysmem(rd_addr, 0);
988 			images->fit_uname_rd = fit_uname_ramdisk;
989 			images->fit_noffset_rd = rd_noffset;
990 			break;
991 #endif
992 		default:
993 #ifdef CONFIG_SUPPORT_RAW_INITRD
994 			end = NULL;
995 			if (select)
996 				end = strchr(select, ':');
997 			if (end) {
998 				rd_len = simple_strtoul(++end, NULL, 16);
999 				rd_data = rd_addr;
1000 			} else
1001 #endif
1002 			{
1003 				puts("Wrong Ramdisk Image Format\n");
1004 				rd_data = rd_len = rd_load = 0;
1005 				return 1;
1006 			}
1007 		}
1008 	} else if (images->legacy_hdr_valid &&
1009 			image_check_type(&images->legacy_hdr_os_copy,
1010 						IH_TYPE_MULTI)) {
1011 
1012 		/*
1013 		 * Now check if we have a legacy mult-component image,
1014 		 * get second entry data start address and len.
1015 		 */
1016 		bootstage_mark(BOOTSTAGE_ID_RAMDISK);
1017 		printf("## Loading init Ramdisk from multi component "
1018 				"Legacy Image at %08lx ...\n",
1019 				(ulong)images->legacy_hdr_os);
1020 
1021 		image_multi_getimg(images->legacy_hdr_os, 1, &rd_data, &rd_len);
1022 	}
1023 #ifdef CONFIG_ANDROID_BOOT_IMAGE
1024 	else if ((genimg_get_format((void *)images->os.start)
1025 			== IMAGE_FORMAT_ANDROID) &&
1026 		 (!android_image_get_ramdisk((void *)images->os.start,
1027 		 &rd_data, &rd_len))) {
1028 		/* empty */
1029 	}
1030 #endif
1031 	else {
1032 		/*
1033 		 * no initrd image
1034 		 */
1035 		bootstage_mark(BOOTSTAGE_ID_NO_RAMDISK);
1036 		rd_len = rd_data = 0;
1037 	}
1038 
1039 	if (!rd_data) {
1040 		debug("## No init Ramdisk\n");
1041 	} else {
1042 		*rd_start = rd_data;
1043 		*rd_end = rd_data + rd_len;
1044 	}
1045 	debug("   ramdisk start = 0x%08lx, ramdisk end = 0x%08lx\n",
1046 			*rd_start, *rd_end);
1047 
1048 	return 0;
1049 }
1050 
1051 #ifdef CONFIG_SYS_BOOT_RAMDISK_HIGH
1052 /**
1053  * boot_ramdisk_high - relocate init ramdisk
1054  * @lmb: pointer to lmb handle, will be used for memory mgmt
1055  * @rd_data: ramdisk data start address
1056  * @rd_len: ramdisk data length
1057  * @initrd_start: pointer to a ulong variable, will hold final init ramdisk
1058  *      start address (after possible relocation)
1059  * @initrd_end: pointer to a ulong variable, will hold final init ramdisk
1060  *      end address (after possible relocation)
1061  *
1062  * boot_ramdisk_high() takes a relocation hint from "initrd_high" environment
1063  * variable and if requested ramdisk data is moved to a specified location.
1064  *
1065  * Initrd_start and initrd_end are set to final (after relocation) ramdisk
1066  * start/end addresses if ramdisk image start and len were provided,
1067  * otherwise set initrd_start and initrd_end set to zeros.
1068  *
1069  * returns:
1070  *      0 - success
1071  *     -1 - failure
1072  */
1073 int boot_ramdisk_high(struct lmb *lmb, ulong rd_data, ulong rd_len,
1074 		  ulong *initrd_start, ulong *initrd_end)
1075 {
1076 	char	*s;
1077 	ulong	initrd_high;
1078 	int	initrd_copy_to_ram = 1;
1079 
1080 	if ((s = getenv("initrd_high")) != NULL) {
1081 		/* a value of "no" or a similar string will act like 0,
1082 		 * turning the "load high" feature off. This is intentional.
1083 		 */
1084 		initrd_high = simple_strtoul(s, NULL, 16);
1085 		if (initrd_high == ~0)
1086 			initrd_copy_to_ram = 0;
1087 	} else {
1088 		/* not set, no restrictions to load high */
1089 		initrd_high = ~0;
1090 	}
1091 
1092 
1093 #ifdef CONFIG_LOGBUFFER
1094 	/* Prevent initrd from overwriting logbuffer */
1095 	lmb_reserve(lmb, logbuffer_base() - LOGBUFF_OVERHEAD, LOGBUFF_RESERVE);
1096 #endif
1097 
1098 	debug("## initrd_high = 0x%08lx, copy_to_ram = %d\n",
1099 			initrd_high, initrd_copy_to_ram);
1100 
1101 	if (rd_data) {
1102 		if (!initrd_copy_to_ram) {	/* zero-copy ramdisk support */
1103 			debug("   in-place initrd\n");
1104 			*initrd_start = rd_data;
1105 			*initrd_end = rd_data + rd_len;
1106 			lmb_reserve(lmb, rd_data, rd_len);
1107 		} else {
1108 			if (initrd_high)
1109 				*initrd_start = (ulong)lmb_alloc_base(lmb,
1110 						rd_len, 0x1000, initrd_high);
1111 			else
1112 				*initrd_start = (ulong)lmb_alloc(lmb, rd_len,
1113 								 0x1000);
1114 
1115 			if (*initrd_start == 0) {
1116 				puts("ramdisk - allocation error\n");
1117 				goto error;
1118 			}
1119 			bootstage_mark(BOOTSTAGE_ID_COPY_RAMDISK);
1120 
1121 			*initrd_end = *initrd_start + rd_len;
1122 			printf("   Loading Ramdisk to %08lx, end %08lx ... ",
1123 					*initrd_start, *initrd_end);
1124 
1125 			memmove_wd((void *)*initrd_start,
1126 					(void *)rd_data, rd_len, CHUNKSZ);
1127 
1128 #ifdef CONFIG_MP
1129 			/*
1130 			 * Ensure the image is flushed to memory to handle
1131 			 * AMP boot scenarios in which we might not be
1132 			 * HW cache coherent
1133 			 */
1134 			flush_cache((unsigned long)*initrd_start, rd_len);
1135 #endif
1136 			puts("OK\n");
1137 		}
1138 	} else {
1139 		*initrd_start = 0;
1140 		*initrd_end = 0;
1141 	}
1142 	debug("   ramdisk load start = 0x%08lx, ramdisk load end = 0x%08lx\n",
1143 			*initrd_start, *initrd_end);
1144 
1145 	return 0;
1146 
1147 error:
1148 	return -1;
1149 }
1150 #endif /* CONFIG_SYS_BOOT_RAMDISK_HIGH */
1151 
1152 int boot_get_setup(bootm_headers_t *images, uint8_t arch,
1153 		   ulong *setup_start, ulong *setup_len)
1154 {
1155 #if defined(CONFIG_FIT)
1156 	return boot_get_setup_fit(images, arch, setup_start, setup_len);
1157 #else
1158 	return -ENOENT;
1159 #endif
1160 }
1161 
1162 #ifdef CONFIG_SYS_BOOT_GET_CMDLINE
1163 /**
1164  * boot_get_cmdline - allocate and initialize kernel cmdline
1165  * @lmb: pointer to lmb handle, will be used for memory mgmt
1166  * @cmd_start: pointer to a ulong variable, will hold cmdline start
1167  * @cmd_end: pointer to a ulong variable, will hold cmdline end
1168  *
1169  * boot_get_cmdline() allocates space for kernel command line below
1170  * BOOTMAPSZ + getenv_bootm_low() address. If "bootargs" U-boot environemnt
1171  * variable is present its contents is copied to allocated kernel
1172  * command line.
1173  *
1174  * returns:
1175  *      0 - success
1176  *     -1 - failure
1177  */
1178 int boot_get_cmdline(struct lmb *lmb, ulong *cmd_start, ulong *cmd_end)
1179 {
1180 	char *cmdline;
1181 	char *s;
1182 
1183 	cmdline = (char *)(ulong)lmb_alloc_base(lmb, CONFIG_SYS_BARGSIZE, 0xf,
1184 				getenv_bootm_mapsize() + getenv_bootm_low());
1185 
1186 	if (cmdline == NULL)
1187 		return -1;
1188 
1189 	if ((s = getenv("bootargs")) == NULL)
1190 		s = "";
1191 
1192 	strcpy(cmdline, s);
1193 
1194 	*cmd_start = (ulong) & cmdline[0];
1195 	*cmd_end = *cmd_start + strlen(cmdline);
1196 
1197 	debug("## cmdline at 0x%08lx ... 0x%08lx\n", *cmd_start, *cmd_end);
1198 
1199 	return 0;
1200 }
1201 #endif /* CONFIG_SYS_BOOT_GET_CMDLINE */
1202 
1203 #ifdef CONFIG_SYS_BOOT_GET_KBD
1204 /**
1205  * boot_get_kbd - allocate and initialize kernel copy of board info
1206  * @lmb: pointer to lmb handle, will be used for memory mgmt
1207  * @kbd: double pointer to board info data
1208  *
1209  * boot_get_kbd() allocates space for kernel copy of board info data below
1210  * BOOTMAPSZ + getenv_bootm_low() address and kernel board info is initialized
1211  * with the current u-boot board info data.
1212  *
1213  * returns:
1214  *      0 - success
1215  *     -1 - failure
1216  */
1217 int boot_get_kbd(struct lmb *lmb, bd_t **kbd)
1218 {
1219 	*kbd = (bd_t *)(ulong)lmb_alloc_base(lmb, sizeof(bd_t), 0xf,
1220 				getenv_bootm_mapsize() + getenv_bootm_low());
1221 	if (*kbd == NULL)
1222 		return -1;
1223 
1224 	**kbd = *(gd->bd);
1225 
1226 	debug("## kernel board info at 0x%08lx\n", (ulong)*kbd);
1227 
1228 #if defined(DEBUG) && defined(CONFIG_CMD_BDI)
1229 	do_bdinfo(NULL, 0, 0, NULL);
1230 #endif
1231 
1232 	return 0;
1233 }
1234 #endif /* CONFIG_SYS_BOOT_GET_KBD */
1235 
1236 #ifdef CONFIG_LMB
1237 int image_setup_linux(bootm_headers_t *images)
1238 {
1239 	ulong of_size = images->ft_len;
1240 	char **of_flat_tree = &images->ft_addr;
1241 	ulong *initrd_start = &images->initrd_start;
1242 	ulong *initrd_end = &images->initrd_end;
1243 	struct lmb *lmb = &images->lmb;
1244 	ulong rd_len;
1245 	int ret;
1246 
1247 	if (IMAGE_ENABLE_OF_LIBFDT)
1248 		boot_fdt_add_mem_rsv_regions(lmb, *of_flat_tree);
1249 
1250 	if (IMAGE_BOOT_GET_CMDLINE) {
1251 		ret = boot_get_cmdline(lmb, &images->cmdline_start,
1252 				&images->cmdline_end);
1253 		if (ret) {
1254 			puts("ERROR with allocation of cmdline\n");
1255 			return ret;
1256 		}
1257 	}
1258 	if (IMAGE_ENABLE_RAMDISK_HIGH) {
1259 		rd_len = images->rd_end - images->rd_start;
1260 		ret = boot_ramdisk_high(lmb, images->rd_start, rd_len,
1261 				initrd_start, initrd_end);
1262 		if (ret)
1263 			return ret;
1264 	}
1265 
1266 	if (IMAGE_ENABLE_OF_LIBFDT) {
1267 		ret = boot_relocate_fdt(lmb, of_flat_tree, &of_size);
1268 		if (ret)
1269 			return ret;
1270 	}
1271 
1272 	if (IMAGE_ENABLE_OF_LIBFDT && of_size) {
1273 		ret = image_setup_libfdt(images, *of_flat_tree, of_size, lmb);
1274 		if (ret)
1275 			return ret;
1276 	}
1277 
1278 	return 0;
1279 }
1280 #endif /* CONFIG_LMB */
1281 #endif /* !USE_HOSTCC */
1282