xref: /openbmc/u-boot/common/image-fit.c (revision b7d9107f)
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * Copyright (c) 2013, Google Inc.
4  *
5  * (C) Copyright 2008 Semihalf
6  *
7  * (C) Copyright 2000-2006
8  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
9  */
10 
11 #ifdef USE_HOSTCC
12 #include "mkimage.h"
13 #include <time.h>
14 #else
15 #include <linux/compiler.h>
16 #include <linux/kconfig.h>
17 #include <common.h>
18 #include <errno.h>
19 #include <mapmem.h>
20 #include <asm/io.h>
21 #include <malloc.h>
22 DECLARE_GLOBAL_DATA_PTR;
23 #endif /* !USE_HOSTCC*/
24 
25 #include <image.h>
26 #include <bootstage.h>
27 #include <u-boot/crc.h>
28 #include <u-boot/md5.h>
29 #include <u-boot/sha1.h>
30 #include <u-boot/sha256.h>
31 #include <u-boot/sha512.h>
32 
33 /*****************************************************************************/
34 /* New uImage format routines */
35 /*****************************************************************************/
36 #ifndef USE_HOSTCC
fit_parse_spec(const char * spec,char sepc,ulong addr_curr,ulong * addr,const char ** name)37 static int fit_parse_spec(const char *spec, char sepc, ulong addr_curr,
38 		ulong *addr, const char **name)
39 {
40 	const char *sep;
41 
42 	*addr = addr_curr;
43 	*name = NULL;
44 
45 	sep = strchr(spec, sepc);
46 	if (sep) {
47 		if (sep - spec > 0)
48 			*addr = simple_strtoul(spec, NULL, 16);
49 
50 		*name = sep + 1;
51 		return 1;
52 	}
53 
54 	return 0;
55 }
56 
57 /**
58  * fit_parse_conf - parse FIT configuration spec
59  * @spec: input string, containing configuration spec
60  * @add_curr: current image address (to be used as a possible default)
61  * @addr: pointer to a ulong variable, will hold FIT image address of a given
62  * configuration
63  * @conf_name double pointer to a char, will hold pointer to a configuration
64  * unit name
65  *
66  * fit_parse_conf() expects configuration spec in the form of [<addr>]#<conf>,
67  * where <addr> is a FIT image address that contains configuration
68  * with a <conf> unit name.
69  *
70  * Address part is optional, and if omitted default add_curr will
71  * be used instead.
72  *
73  * returns:
74  *     1 if spec is a valid configuration string,
75  *     addr and conf_name are set accordingly
76  *     0 otherwise
77  */
fit_parse_conf(const char * spec,ulong addr_curr,ulong * addr,const char ** conf_name)78 int fit_parse_conf(const char *spec, ulong addr_curr,
79 		ulong *addr, const char **conf_name)
80 {
81 	return fit_parse_spec(spec, '#', addr_curr, addr, conf_name);
82 }
83 
84 /**
85  * fit_parse_subimage - parse FIT subimage spec
86  * @spec: input string, containing subimage spec
87  * @add_curr: current image address (to be used as a possible default)
88  * @addr: pointer to a ulong variable, will hold FIT image address of a given
89  * subimage
90  * @image_name: double pointer to a char, will hold pointer to a subimage name
91  *
92  * fit_parse_subimage() expects subimage spec in the form of
93  * [<addr>]:<subimage>, where <addr> is a FIT image address that contains
94  * subimage with a <subimg> unit name.
95  *
96  * Address part is optional, and if omitted default add_curr will
97  * be used instead.
98  *
99  * returns:
100  *     1 if spec is a valid subimage string,
101  *     addr and image_name are set accordingly
102  *     0 otherwise
103  */
fit_parse_subimage(const char * spec,ulong addr_curr,ulong * addr,const char ** image_name)104 int fit_parse_subimage(const char *spec, ulong addr_curr,
105 		ulong *addr, const char **image_name)
106 {
107 	return fit_parse_spec(spec, ':', addr_curr, addr, image_name);
108 }
109 #endif /* !USE_HOSTCC */
110 
fit_get_debug(const void * fit,int noffset,char * prop_name,int err)111 static void fit_get_debug(const void *fit, int noffset,
112 		char *prop_name, int err)
113 {
114 	debug("Can't get '%s' property from FIT 0x%08lx, node: offset %d, name %s (%s)\n",
115 	      prop_name, (ulong)fit, noffset, fit_get_name(fit, noffset, NULL),
116 	      fdt_strerror(err));
117 }
118 
119 /**
120  * fit_get_subimage_count - get component (sub-image) count
121  * @fit: pointer to the FIT format image header
122  * @images_noffset: offset of images node
123  *
124  * returns:
125  *     number of image components
126  */
fit_get_subimage_count(const void * fit,int images_noffset)127 int fit_get_subimage_count(const void *fit, int images_noffset)
128 {
129 	int noffset;
130 	int ndepth;
131 	int count = 0;
132 
133 	/* Process its subnodes, print out component images details */
134 	for (ndepth = 0, count = 0,
135 		noffset = fdt_next_node(fit, images_noffset, &ndepth);
136 	     (noffset >= 0) && (ndepth > 0);
137 	     noffset = fdt_next_node(fit, noffset, &ndepth)) {
138 		if (ndepth == 1) {
139 			count++;
140 		}
141 	}
142 
143 	return count;
144 }
145 
146 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_FIT_PRINT)
147 /**
148  * fit_image_print_data() - prints out the hash node details
149  * @fit: pointer to the FIT format image header
150  * @noffset: offset of the hash node
151  * @p: pointer to prefix string
152  * @type: Type of information to print ("hash" or "sign")
153  *
154  * fit_image_print_data() lists properties for the processed hash node
155  *
156  * This function avoid using puts() since it prints a newline on the host
157  * but does not in U-Boot.
158  *
159  * returns:
160  *     no returned results
161  */
fit_image_print_data(const void * fit,int noffset,const char * p,const char * type)162 static void fit_image_print_data(const void *fit, int noffset, const char *p,
163 				 const char *type)
164 {
165 	const char *keyname;
166 	uint8_t *value;
167 	int value_len;
168 	char *algo;
169 	const char *padding;
170 	int required;
171 	int ret, i;
172 
173 	debug("%s  %s node:    '%s'\n", p, type,
174 	      fit_get_name(fit, noffset, NULL));
175 	printf("%s  %s algo:    ", p, type);
176 	if (fit_image_hash_get_algo(fit, noffset, &algo)) {
177 		printf("invalid/unsupported\n");
178 		return;
179 	}
180 	printf("%s", algo);
181 	keyname = fdt_getprop(fit, noffset, "key-name-hint", NULL);
182 	required = fdt_getprop(fit, noffset, "required", NULL) != NULL;
183 	if (keyname)
184 		printf(":%s", keyname);
185 	if (required)
186 		printf(" (required)");
187 	printf("\n");
188 
189 	padding = fdt_getprop(fit, noffset, "padding", NULL);
190 	if (padding)
191 		printf("%s  %s padding: %s\n", p, type, padding);
192 
193 	ret = fit_image_hash_get_value(fit, noffset, &value,
194 				       &value_len);
195 	printf("%s  %s value:   ", p, type);
196 	if (ret) {
197 		printf("unavailable\n");
198 	} else {
199 		for (i = 0; i < value_len; i++)
200 			printf("%02x", value[i]);
201 		printf("\n");
202 	}
203 
204 	debug("%s  %s len:     %d\n", p, type, value_len);
205 
206 	/* Signatures have a time stamp */
207 	if (IMAGE_ENABLE_TIMESTAMP && keyname) {
208 		time_t timestamp;
209 
210 		printf("%s  Timestamp:    ", p);
211 		if (fit_get_timestamp(fit, noffset, &timestamp))
212 			printf("unavailable\n");
213 		else
214 			genimg_print_time(timestamp);
215 	}
216 }
217 
218 /**
219  * fit_image_print_verification_data() - prints out the hash/signature details
220  * @fit: pointer to the FIT format image header
221  * @noffset: offset of the hash or signature node
222  * @p: pointer to prefix string
223  *
224  * This lists properties for the processed hash node
225  *
226  * returns:
227  *     no returned results
228  */
fit_image_print_verification_data(const void * fit,int noffset,const char * p)229 static void fit_image_print_verification_data(const void *fit, int noffset,
230 					      const char *p)
231 {
232 	const char *name;
233 
234 	/*
235 	 * Check subnode name, must be equal to "hash" or "signature".
236 	 * Multiple hash/signature nodes require unique unit node
237 	 * names, e.g. hash-1, hash-2, signature-1, signature-2, etc.
238 	 */
239 	name = fit_get_name(fit, noffset, NULL);
240 	if (!strncmp(name, FIT_HASH_NODENAME, strlen(FIT_HASH_NODENAME))) {
241 		fit_image_print_data(fit, noffset, p, "Hash");
242 	} else if (!strncmp(name, FIT_SIG_NODENAME,
243 				strlen(FIT_SIG_NODENAME))) {
244 		fit_image_print_data(fit, noffset, p, "Sign");
245 	}
246 }
247 
248 /**
249  * fit_conf_print - prints out the FIT configuration details
250  * @fit: pointer to the FIT format image header
251  * @noffset: offset of the configuration node
252  * @p: pointer to prefix string
253  *
254  * fit_conf_print() lists all mandatory properties for the processed
255  * configuration node.
256  *
257  * returns:
258  *     no returned results
259  */
fit_conf_print(const void * fit,int noffset,const char * p)260 static void fit_conf_print(const void *fit, int noffset, const char *p)
261 {
262 	char *desc;
263 	const char *uname;
264 	int ret;
265 	int fdt_index, loadables_index;
266 	int ndepth;
267 
268 	/* Mandatory properties */
269 	ret = fit_get_desc(fit, noffset, &desc);
270 	printf("%s  Description:  ", p);
271 	if (ret)
272 		printf("unavailable\n");
273 	else
274 		printf("%s\n", desc);
275 
276 	uname = fdt_getprop(fit, noffset, FIT_KERNEL_PROP, NULL);
277 	printf("%s  Kernel:       ", p);
278 	if (!uname)
279 		printf("unavailable\n");
280 	else
281 		printf("%s\n", uname);
282 
283 	/* Optional properties */
284 	uname = fdt_getprop(fit, noffset, FIT_RAMDISK_PROP, NULL);
285 	if (uname)
286 		printf("%s  Init Ramdisk: %s\n", p, uname);
287 
288 	uname = fdt_getprop(fit, noffset, FIT_FIRMWARE_PROP, NULL);
289 	if (uname)
290 		printf("%s  Firmware:     %s\n", p, uname);
291 
292 	for (fdt_index = 0;
293 	     uname = fdt_stringlist_get(fit, noffset, FIT_FDT_PROP,
294 					fdt_index, NULL), uname;
295 	     fdt_index++) {
296 		if (fdt_index == 0)
297 			printf("%s  FDT:          ", p);
298 		else
299 			printf("%s                ", p);
300 		printf("%s\n", uname);
301 	}
302 
303 	uname = fdt_getprop(fit, noffset, FIT_FPGA_PROP, NULL);
304 	if (uname)
305 		printf("%s  FPGA:         %s\n", p, uname);
306 
307 	/* Print out all of the specified loadables */
308 	for (loadables_index = 0;
309 	     uname = fdt_stringlist_get(fit, noffset, FIT_LOADABLE_PROP,
310 					loadables_index, NULL), uname;
311 	     loadables_index++) {
312 		if (loadables_index == 0) {
313 			printf("%s  Loadables:    ", p);
314 		} else {
315 			printf("%s                ", p);
316 		}
317 		printf("%s\n", uname);
318 	}
319 
320 	/* Process all hash subnodes of the component configuration node */
321 	for (ndepth = 0, noffset = fdt_next_node(fit, noffset, &ndepth);
322 	     (noffset >= 0) && (ndepth > 0);
323 	     noffset = fdt_next_node(fit, noffset, &ndepth)) {
324 		if (ndepth == 1) {
325 			/* Direct child node of the component configuration node */
326 			fit_image_print_verification_data(fit, noffset, p);
327 		}
328 	}
329 }
330 
331 /**
332  * fit_print_contents - prints out the contents of the FIT format image
333  * @fit: pointer to the FIT format image header
334  * @p: pointer to prefix string
335  *
336  * fit_print_contents() formats a multi line FIT image contents description.
337  * The routine prints out FIT image properties (root node level) followed by
338  * the details of each component image.
339  *
340  * returns:
341  *     no returned results
342  */
fit_print_contents(const void * fit)343 void fit_print_contents(const void *fit)
344 {
345 	char *desc;
346 	char *uname;
347 	int images_noffset;
348 	int confs_noffset;
349 	int noffset;
350 	int ndepth;
351 	int count = 0;
352 	int ret;
353 	const char *p;
354 	time_t timestamp;
355 
356 	/* Indent string is defined in header image.h */
357 	p = IMAGE_INDENT_STRING;
358 
359 	/* Root node properties */
360 	ret = fit_get_desc(fit, 0, &desc);
361 	printf("%sFIT description: ", p);
362 	if (ret)
363 		printf("unavailable\n");
364 	else
365 		printf("%s\n", desc);
366 
367 	if (IMAGE_ENABLE_TIMESTAMP) {
368 		ret = fit_get_timestamp(fit, 0, &timestamp);
369 		printf("%sCreated:         ", p);
370 		if (ret)
371 			printf("unavailable\n");
372 		else
373 			genimg_print_time(timestamp);
374 	}
375 
376 	/* Find images parent node offset */
377 	images_noffset = fdt_path_offset(fit, FIT_IMAGES_PATH);
378 	if (images_noffset < 0) {
379 		printf("Can't find images parent node '%s' (%s)\n",
380 		       FIT_IMAGES_PATH, fdt_strerror(images_noffset));
381 		return;
382 	}
383 
384 	/* Process its subnodes, print out component images details */
385 	for (ndepth = 0, count = 0,
386 		noffset = fdt_next_node(fit, images_noffset, &ndepth);
387 	     (noffset >= 0) && (ndepth > 0);
388 	     noffset = fdt_next_node(fit, noffset, &ndepth)) {
389 		if (ndepth == 1) {
390 			/*
391 			 * Direct child node of the images parent node,
392 			 * i.e. component image node.
393 			 */
394 			printf("%s Image %u (%s)\n", p, count++,
395 			       fit_get_name(fit, noffset, NULL));
396 
397 			fit_image_print(fit, noffset, p);
398 		}
399 	}
400 
401 	/* Find configurations parent node offset */
402 	confs_noffset = fdt_path_offset(fit, FIT_CONFS_PATH);
403 	if (confs_noffset < 0) {
404 		debug("Can't get configurations parent node '%s' (%s)\n",
405 		      FIT_CONFS_PATH, fdt_strerror(confs_noffset));
406 		return;
407 	}
408 
409 	/* get default configuration unit name from default property */
410 	uname = (char *)fdt_getprop(fit, noffset, FIT_DEFAULT_PROP, NULL);
411 	if (uname)
412 		printf("%s Default Configuration: '%s'\n", p, uname);
413 
414 	/* Process its subnodes, print out configurations details */
415 	for (ndepth = 0, count = 0,
416 		noffset = fdt_next_node(fit, confs_noffset, &ndepth);
417 	     (noffset >= 0) && (ndepth > 0);
418 	     noffset = fdt_next_node(fit, noffset, &ndepth)) {
419 		if (ndepth == 1) {
420 			/*
421 			 * Direct child node of the configurations parent node,
422 			 * i.e. configuration node.
423 			 */
424 			printf("%s Configuration %u (%s)\n", p, count++,
425 			       fit_get_name(fit, noffset, NULL));
426 
427 			fit_conf_print(fit, noffset, p);
428 		}
429 	}
430 }
431 
432 /**
433  * fit_image_print - prints out the FIT component image details
434  * @fit: pointer to the FIT format image header
435  * @image_noffset: offset of the component image node
436  * @p: pointer to prefix string
437  *
438  * fit_image_print() lists all mandatory properties for the processed component
439  * image. If present, hash nodes are printed out as well. Load
440  * address for images of type firmware is also printed out. Since the load
441  * address is not mandatory for firmware images, it will be output as
442  * "unavailable" when not present.
443  *
444  * returns:
445  *     no returned results
446  */
fit_image_print(const void * fit,int image_noffset,const char * p)447 void fit_image_print(const void *fit, int image_noffset, const char *p)
448 {
449 	char *desc;
450 	uint8_t type, arch, os, comp;
451 	size_t size;
452 	ulong load, entry;
453 	const void *data;
454 	int noffset;
455 	int ndepth;
456 	int ret;
457 
458 	/* Mandatory properties */
459 	ret = fit_get_desc(fit, image_noffset, &desc);
460 	printf("%s  Description:  ", p);
461 	if (ret)
462 		printf("unavailable\n");
463 	else
464 		printf("%s\n", desc);
465 
466 	if (IMAGE_ENABLE_TIMESTAMP) {
467 		time_t timestamp;
468 
469 		ret = fit_get_timestamp(fit, 0, &timestamp);
470 		printf("%s  Created:      ", p);
471 		if (ret)
472 			printf("unavailable\n");
473 		else
474 			genimg_print_time(timestamp);
475 	}
476 
477 	fit_image_get_type(fit, image_noffset, &type);
478 	printf("%s  Type:         %s\n", p, genimg_get_type_name(type));
479 
480 	fit_image_get_comp(fit, image_noffset, &comp);
481 	printf("%s  Compression:  %s\n", p, genimg_get_comp_name(comp));
482 
483 	ret = fit_image_get_data_and_size(fit, image_noffset, &data, &size);
484 
485 #ifndef USE_HOSTCC
486 	printf("%s  Data Start:   ", p);
487 	if (ret) {
488 		printf("unavailable\n");
489 	} else {
490 		void *vdata = (void *)data;
491 
492 		printf("0x%08lx\n", (ulong)map_to_sysmem(vdata));
493 	}
494 #endif
495 
496 	printf("%s  Data Size:    ", p);
497 	if (ret)
498 		printf("unavailable\n");
499 	else
500 		genimg_print_size(size);
501 
502 	/* Remaining, type dependent properties */
503 	if ((type == IH_TYPE_KERNEL) || (type == IH_TYPE_STANDALONE) ||
504 	    (type == IH_TYPE_RAMDISK) || (type == IH_TYPE_FIRMWARE) ||
505 	    (type == IH_TYPE_FLATDT)) {
506 		fit_image_get_arch(fit, image_noffset, &arch);
507 		printf("%s  Architecture: %s\n", p, genimg_get_arch_name(arch));
508 	}
509 
510 	if ((type == IH_TYPE_KERNEL) || (type == IH_TYPE_RAMDISK) ||
511 	    (type == IH_TYPE_FIRMWARE)) {
512 		fit_image_get_os(fit, image_noffset, &os);
513 		printf("%s  OS:           %s\n", p, genimg_get_os_name(os));
514 	}
515 
516 	if ((type == IH_TYPE_KERNEL) || (type == IH_TYPE_STANDALONE) ||
517 	    (type == IH_TYPE_FIRMWARE) || (type == IH_TYPE_RAMDISK) ||
518 	    (type == IH_TYPE_FPGA)) {
519 		ret = fit_image_get_load(fit, image_noffset, &load);
520 		printf("%s  Load Address: ", p);
521 		if (ret)
522 			printf("unavailable\n");
523 		else
524 			printf("0x%08lx\n", load);
525 	}
526 
527 	/* optional load address for FDT */
528 	if (type == IH_TYPE_FLATDT && !fit_image_get_load(fit, image_noffset, &load))
529 		printf("%s  Load Address: 0x%08lx\n", p, load);
530 
531 	if ((type == IH_TYPE_KERNEL) || (type == IH_TYPE_STANDALONE) ||
532 	    (type == IH_TYPE_RAMDISK)) {
533 		ret = fit_image_get_entry(fit, image_noffset, &entry);
534 		printf("%s  Entry Point:  ", p);
535 		if (ret)
536 			printf("unavailable\n");
537 		else
538 			printf("0x%08lx\n", entry);
539 	}
540 
541 	/* Process all hash subnodes of the component image node */
542 	for (ndepth = 0, noffset = fdt_next_node(fit, image_noffset, &ndepth);
543 	     (noffset >= 0) && (ndepth > 0);
544 	     noffset = fdt_next_node(fit, noffset, &ndepth)) {
545 		if (ndepth == 1) {
546 			/* Direct child node of the component image node */
547 			fit_image_print_verification_data(fit, noffset, p);
548 		}
549 	}
550 }
551 #else
fit_print_contents(const void * fit)552 void fit_print_contents(const void *fit) { }
fit_image_print(const void * fit,int image_noffset,const char * p)553 void fit_image_print(const void *fit, int image_noffset, const char *p) { }
554 #endif /* !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_FIT_PRINT) */
555 
556 /**
557  * fit_get_desc - get node description property
558  * @fit: pointer to the FIT format image header
559  * @noffset: node offset
560  * @desc: double pointer to the char, will hold pointer to the description
561  *
562  * fit_get_desc() reads description property from a given node, if
563  * description is found pointer to it is returned in third call argument.
564  *
565  * returns:
566  *     0, on success
567  *     -1, on failure
568  */
fit_get_desc(const void * fit,int noffset,char ** desc)569 int fit_get_desc(const void *fit, int noffset, char **desc)
570 {
571 	int len;
572 
573 	*desc = (char *)fdt_getprop(fit, noffset, FIT_DESC_PROP, &len);
574 	if (*desc == NULL) {
575 		fit_get_debug(fit, noffset, FIT_DESC_PROP, len);
576 		return -1;
577 	}
578 
579 	return 0;
580 }
581 
582 /**
583  * fit_get_timestamp - get node timestamp property
584  * @fit: pointer to the FIT format image header
585  * @noffset: node offset
586  * @timestamp: pointer to the time_t, will hold read timestamp
587  *
588  * fit_get_timestamp() reads timestamp property from given node, if timestamp
589  * is found and has a correct size its value is returned in third call
590  * argument.
591  *
592  * returns:
593  *     0, on success
594  *     -1, on property read failure
595  *     -2, on wrong timestamp size
596  */
fit_get_timestamp(const void * fit,int noffset,time_t * timestamp)597 int fit_get_timestamp(const void *fit, int noffset, time_t *timestamp)
598 {
599 	int len;
600 	const void *data;
601 
602 	data = fdt_getprop(fit, noffset, FIT_TIMESTAMP_PROP, &len);
603 	if (data == NULL) {
604 		fit_get_debug(fit, noffset, FIT_TIMESTAMP_PROP, len);
605 		return -1;
606 	}
607 	if (len != sizeof(uint32_t)) {
608 		debug("FIT timestamp with incorrect size of (%u)\n", len);
609 		return -2;
610 	}
611 
612 	*timestamp = uimage_to_cpu(*((uint32_t *)data));
613 	return 0;
614 }
615 
616 /**
617  * fit_image_get_node - get node offset for component image of a given unit name
618  * @fit: pointer to the FIT format image header
619  * @image_uname: component image node unit name
620  *
621  * fit_image_get_node() finds a component image (within the '/images'
622  * node) of a provided unit name. If image is found its node offset is
623  * returned to the caller.
624  *
625  * returns:
626  *     image node offset when found (>=0)
627  *     negative number on failure (FDT_ERR_* code)
628  */
fit_image_get_node(const void * fit,const char * image_uname)629 int fit_image_get_node(const void *fit, const char *image_uname)
630 {
631 	int noffset, images_noffset;
632 
633 	images_noffset = fdt_path_offset(fit, FIT_IMAGES_PATH);
634 	if (images_noffset < 0) {
635 		debug("Can't find images parent node '%s' (%s)\n",
636 		      FIT_IMAGES_PATH, fdt_strerror(images_noffset));
637 		return images_noffset;
638 	}
639 
640 	noffset = fdt_subnode_offset(fit, images_noffset, image_uname);
641 	if (noffset < 0) {
642 		debug("Can't get node offset for image unit name: '%s' (%s)\n",
643 		      image_uname, fdt_strerror(noffset));
644 	}
645 
646 	return noffset;
647 }
648 
649 /**
650  * fit_image_get_os - get os id for a given component image node
651  * @fit: pointer to the FIT format image header
652  * @noffset: component image node offset
653  * @os: pointer to the uint8_t, will hold os numeric id
654  *
655  * fit_image_get_os() finds os property in a given component image node.
656  * If the property is found, its (string) value is translated to the numeric
657  * id which is returned to the caller.
658  *
659  * returns:
660  *     0, on success
661  *     -1, on failure
662  */
fit_image_get_os(const void * fit,int noffset,uint8_t * os)663 int fit_image_get_os(const void *fit, int noffset, uint8_t *os)
664 {
665 	int len;
666 	const void *data;
667 
668 	/* Get OS name from property data */
669 	data = fdt_getprop(fit, noffset, FIT_OS_PROP, &len);
670 	if (data == NULL) {
671 		fit_get_debug(fit, noffset, FIT_OS_PROP, len);
672 		*os = -1;
673 		return -1;
674 	}
675 
676 	/* Translate OS name to id */
677 	*os = genimg_get_os_id(data);
678 	return 0;
679 }
680 
681 /**
682  * fit_image_get_arch - get arch id for a given component image node
683  * @fit: pointer to the FIT format image header
684  * @noffset: component image node offset
685  * @arch: pointer to the uint8_t, will hold arch numeric id
686  *
687  * fit_image_get_arch() finds arch property in a given component image node.
688  * If the property is found, its (string) value is translated to the numeric
689  * id which is returned to the caller.
690  *
691  * returns:
692  *     0, on success
693  *     -1, on failure
694  */
fit_image_get_arch(const void * fit,int noffset,uint8_t * arch)695 int fit_image_get_arch(const void *fit, int noffset, uint8_t *arch)
696 {
697 	int len;
698 	const void *data;
699 
700 	/* Get architecture name from property data */
701 	data = fdt_getprop(fit, noffset, FIT_ARCH_PROP, &len);
702 	if (data == NULL) {
703 		fit_get_debug(fit, noffset, FIT_ARCH_PROP, len);
704 		*arch = -1;
705 		return -1;
706 	}
707 
708 	/* Translate architecture name to id */
709 	*arch = genimg_get_arch_id(data);
710 	return 0;
711 }
712 
713 /**
714  * fit_image_get_type - get type id for a given component image node
715  * @fit: pointer to the FIT format image header
716  * @noffset: component image node offset
717  * @type: pointer to the uint8_t, will hold type numeric id
718  *
719  * fit_image_get_type() finds type property in a given component image node.
720  * If the property is found, its (string) value is translated to the numeric
721  * id which is returned to the caller.
722  *
723  * returns:
724  *     0, on success
725  *     -1, on failure
726  */
fit_image_get_type(const void * fit,int noffset,uint8_t * type)727 int fit_image_get_type(const void *fit, int noffset, uint8_t *type)
728 {
729 	int len;
730 	const void *data;
731 
732 	/* Get image type name from property data */
733 	data = fdt_getprop(fit, noffset, FIT_TYPE_PROP, &len);
734 	if (data == NULL) {
735 		fit_get_debug(fit, noffset, FIT_TYPE_PROP, len);
736 		*type = -1;
737 		return -1;
738 	}
739 
740 	/* Translate image type name to id */
741 	*type = genimg_get_type_id(data);
742 	return 0;
743 }
744 
745 /**
746  * fit_image_get_comp - get comp id for a given component image node
747  * @fit: pointer to the FIT format image header
748  * @noffset: component image node offset
749  * @comp: pointer to the uint8_t, will hold comp numeric id
750  *
751  * fit_image_get_comp() finds comp property in a given component image node.
752  * If the property is found, its (string) value is translated to the numeric
753  * id which is returned to the caller.
754  *
755  * returns:
756  *     0, on success
757  *     -1, on failure
758  */
fit_image_get_comp(const void * fit,int noffset,uint8_t * comp)759 int fit_image_get_comp(const void *fit, int noffset, uint8_t *comp)
760 {
761 	int len;
762 	const void *data;
763 
764 	/* Get compression name from property data */
765 	data = fdt_getprop(fit, noffset, FIT_COMP_PROP, &len);
766 	if (data == NULL) {
767 		fit_get_debug(fit, noffset, FIT_COMP_PROP, len);
768 		*comp = -1;
769 		return -1;
770 	}
771 
772 	/* Translate compression name to id */
773 	*comp = genimg_get_comp_id(data);
774 	return 0;
775 }
776 
fit_image_get_address(const void * fit,int noffset,char * name,ulong * load)777 static int fit_image_get_address(const void *fit, int noffset, char *name,
778 			  ulong *load)
779 {
780 	int len, cell_len;
781 	const fdt32_t *cell;
782 	uint64_t load64 = 0;
783 
784 	cell = fdt_getprop(fit, noffset, name, &len);
785 	if (cell == NULL) {
786 		fit_get_debug(fit, noffset, name, len);
787 		return -1;
788 	}
789 
790 	if (len > sizeof(ulong)) {
791 		printf("Unsupported %s address size\n", name);
792 		return -1;
793 	}
794 
795 	cell_len = len >> 2;
796 	/* Use load64 to avoid compiling warning for 32-bit target */
797 	while (cell_len--) {
798 		load64 = (load64 << 32) | uimage_to_cpu(*cell);
799 		cell++;
800 	}
801 	*load = (ulong)load64;
802 
803 	return 0;
804 }
805 /**
806  * fit_image_get_load() - get load addr property for given component image node
807  * @fit: pointer to the FIT format image header
808  * @noffset: component image node offset
809  * @load: pointer to the uint32_t, will hold load address
810  *
811  * fit_image_get_load() finds load address property in a given component
812  * image node. If the property is found, its value is returned to the caller.
813  *
814  * returns:
815  *     0, on success
816  *     -1, on failure
817  */
fit_image_get_load(const void * fit,int noffset,ulong * load)818 int fit_image_get_load(const void *fit, int noffset, ulong *load)
819 {
820 	return fit_image_get_address(fit, noffset, FIT_LOAD_PROP, load);
821 }
822 
823 /**
824  * fit_image_get_entry() - get entry point address property
825  * @fit: pointer to the FIT format image header
826  * @noffset: component image node offset
827  * @entry: pointer to the uint32_t, will hold entry point address
828  *
829  * This gets the entry point address property for a given component image
830  * node.
831  *
832  * fit_image_get_entry() finds entry point address property in a given
833  * component image node.  If the property is found, its value is returned
834  * to the caller.
835  *
836  * returns:
837  *     0, on success
838  *     -1, on failure
839  */
fit_image_get_entry(const void * fit,int noffset,ulong * entry)840 int fit_image_get_entry(const void *fit, int noffset, ulong *entry)
841 {
842 	return fit_image_get_address(fit, noffset, FIT_ENTRY_PROP, entry);
843 }
844 
845 /**
846  * fit_image_get_data - get data property and its size for a given component image node
847  * @fit: pointer to the FIT format image header
848  * @noffset: component image node offset
849  * @data: double pointer to void, will hold data property's data address
850  * @size: pointer to size_t, will hold data property's data size
851  *
852  * fit_image_get_data() finds data property in a given component image node.
853  * If the property is found its data start address and size are returned to
854  * the caller.
855  *
856  * returns:
857  *     0, on success
858  *     -1, on failure
859  */
fit_image_get_data(const void * fit,int noffset,const void ** data,size_t * size)860 int fit_image_get_data(const void *fit, int noffset,
861 		const void **data, size_t *size)
862 {
863 	int len;
864 
865 	*data = fdt_getprop(fit, noffset, FIT_DATA_PROP, &len);
866 	if (*data == NULL) {
867 		fit_get_debug(fit, noffset, FIT_DATA_PROP, len);
868 		*size = 0;
869 		return -1;
870 	}
871 
872 	*size = len;
873 	return 0;
874 }
875 
876 /**
877  * Get 'data-offset' property from a given image node.
878  *
879  * @fit: pointer to the FIT image header
880  * @noffset: component image node offset
881  * @data_offset: holds the data-offset property
882  *
883  * returns:
884  *     0, on success
885  *     -ENOENT if the property could not be found
886  */
fit_image_get_data_offset(const void * fit,int noffset,int * data_offset)887 int fit_image_get_data_offset(const void *fit, int noffset, int *data_offset)
888 {
889 	const fdt32_t *val;
890 
891 	val = fdt_getprop(fit, noffset, FIT_DATA_OFFSET_PROP, NULL);
892 	if (!val)
893 		return -ENOENT;
894 
895 	*data_offset = fdt32_to_cpu(*val);
896 
897 	return 0;
898 }
899 
900 /**
901  * Get 'data-position' property from a given image node.
902  *
903  * @fit: pointer to the FIT image header
904  * @noffset: component image node offset
905  * @data_position: holds the data-position property
906  *
907  * returns:
908  *     0, on success
909  *     -ENOENT if the property could not be found
910  */
fit_image_get_data_position(const void * fit,int noffset,int * data_position)911 int fit_image_get_data_position(const void *fit, int noffset,
912 				int *data_position)
913 {
914 	const fdt32_t *val;
915 
916 	val = fdt_getprop(fit, noffset, FIT_DATA_POSITION_PROP, NULL);
917 	if (!val)
918 		return -ENOENT;
919 
920 	*data_position = fdt32_to_cpu(*val);
921 
922 	return 0;
923 }
924 
925 /**
926  * Get 'data-size' property from a given image node.
927  *
928  * @fit: pointer to the FIT image header
929  * @noffset: component image node offset
930  * @data_size: holds the data-size property
931  *
932  * returns:
933  *     0, on success
934  *     -ENOENT if the property could not be found
935  */
fit_image_get_data_size(const void * fit,int noffset,int * data_size)936 int fit_image_get_data_size(const void *fit, int noffset, int *data_size)
937 {
938 	const fdt32_t *val;
939 
940 	val = fdt_getprop(fit, noffset, FIT_DATA_SIZE_PROP, NULL);
941 	if (!val)
942 		return -ENOENT;
943 
944 	*data_size = fdt32_to_cpu(*val);
945 
946 	return 0;
947 }
948 
949 /**
950  * fit_image_get_data_and_size - get data and its size including
951  *				 both embedded and external data
952  * @fit: pointer to the FIT format image header
953  * @noffset: component image node offset
954  * @data: double pointer to void, will hold data property's data address
955  * @size: pointer to size_t, will hold data property's data size
956  *
957  * fit_image_get_data_and_size() finds data and its size including
958  * both embedded and external data. If the property is found
959  * its data start address and size are returned to the caller.
960  *
961  * returns:
962  *     0, on success
963  *     otherwise, on failure
964  */
fit_image_get_data_and_size(const void * fit,int noffset,const void ** data,size_t * size)965 int fit_image_get_data_and_size(const void *fit, int noffset,
966 				const void **data, size_t *size)
967 {
968 	bool external_data = false;
969 	int offset;
970 	int len;
971 	int ret;
972 
973 	if (!fit_image_get_data_position(fit, noffset, &offset)) {
974 		external_data = true;
975 	} else if (!fit_image_get_data_offset(fit, noffset, &offset)) {
976 		external_data = true;
977 		/*
978 		 * For FIT with external data, figure out where
979 		 * the external images start. This is the base
980 		 * for the data-offset properties in each image.
981 		 */
982 		offset += ((fdt_totalsize(fit) + 3) & ~3);
983 	}
984 
985 	if (external_data) {
986 		debug("External Data\n");
987 		ret = fit_image_get_data_size(fit, noffset, &len);
988 		if (!ret) {
989 			*data = fit + offset;
990 			*size = len;
991 		}
992 	} else {
993 		ret = fit_image_get_data(fit, noffset, data, size);
994 	}
995 
996 	return ret;
997 }
998 
999 /**
1000  * fit_image_hash_get_algo - get hash algorithm name
1001  * @fit: pointer to the FIT format image header
1002  * @noffset: hash node offset
1003  * @algo: double pointer to char, will hold pointer to the algorithm name
1004  *
1005  * fit_image_hash_get_algo() finds hash algorithm property in a given hash node.
1006  * If the property is found its data start address is returned to the caller.
1007  *
1008  * returns:
1009  *     0, on success
1010  *     -1, on failure
1011  */
fit_image_hash_get_algo(const void * fit,int noffset,char ** algo)1012 int fit_image_hash_get_algo(const void *fit, int noffset, char **algo)
1013 {
1014 	int len;
1015 
1016 	*algo = (char *)fdt_getprop(fit, noffset, FIT_ALGO_PROP, &len);
1017 	if (*algo == NULL) {
1018 		fit_get_debug(fit, noffset, FIT_ALGO_PROP, len);
1019 		return -1;
1020 	}
1021 
1022 	return 0;
1023 }
1024 
1025 /**
1026  * fit_image_hash_get_value - get hash value and length
1027  * @fit: pointer to the FIT format image header
1028  * @noffset: hash node offset
1029  * @value: double pointer to uint8_t, will hold address of a hash value data
1030  * @value_len: pointer to an int, will hold hash data length
1031  *
1032  * fit_image_hash_get_value() finds hash value property in a given hash node.
1033  * If the property is found its data start address and size are returned to
1034  * the caller.
1035  *
1036  * returns:
1037  *     0, on success
1038  *     -1, on failure
1039  */
fit_image_hash_get_value(const void * fit,int noffset,uint8_t ** value,int * value_len)1040 int fit_image_hash_get_value(const void *fit, int noffset, uint8_t **value,
1041 				int *value_len)
1042 {
1043 	int len;
1044 
1045 	*value = (uint8_t *)fdt_getprop(fit, noffset, FIT_VALUE_PROP, &len);
1046 	if (*value == NULL) {
1047 		fit_get_debug(fit, noffset, FIT_VALUE_PROP, len);
1048 		*value_len = 0;
1049 		return -1;
1050 	}
1051 
1052 	*value_len = len;
1053 	return 0;
1054 }
1055 
1056 /**
1057  * fit_image_hash_get_ignore - get hash ignore flag
1058  * @fit: pointer to the FIT format image header
1059  * @noffset: hash node offset
1060  * @ignore: pointer to an int, will hold hash ignore flag
1061  *
1062  * fit_image_hash_get_ignore() finds hash ignore property in a given hash node.
1063  * If the property is found and non-zero, the hash algorithm is not verified by
1064  * u-boot automatically.
1065  *
1066  * returns:
1067  *     0, on ignore not found
1068  *     value, on ignore found
1069  */
fit_image_hash_get_ignore(const void * fit,int noffset,int * ignore)1070 static int fit_image_hash_get_ignore(const void *fit, int noffset, int *ignore)
1071 {
1072 	int len;
1073 	int *value;
1074 
1075 	value = (int *)fdt_getprop(fit, noffset, FIT_IGNORE_PROP, &len);
1076 	if (value == NULL || len != sizeof(int))
1077 		*ignore = 0;
1078 	else
1079 		*ignore = *value;
1080 
1081 	return 0;
1082 }
1083 
fit_get_end(const void * fit)1084 ulong fit_get_end(const void *fit)
1085 {
1086 	return map_to_sysmem((void *)(fit + fdt_totalsize(fit)));
1087 }
1088 
1089 /**
1090  * fit_set_timestamp - set node timestamp property
1091  * @fit: pointer to the FIT format image header
1092  * @noffset: node offset
1093  * @timestamp: timestamp value to be set
1094  *
1095  * fit_set_timestamp() attempts to set timestamp property in the requested
1096  * node and returns operation status to the caller.
1097  *
1098  * returns:
1099  *     0, on success
1100  *     -ENOSPC if no space in device tree, -1 for other error
1101  */
fit_set_timestamp(void * fit,int noffset,time_t timestamp)1102 int fit_set_timestamp(void *fit, int noffset, time_t timestamp)
1103 {
1104 	uint32_t t;
1105 	int ret;
1106 
1107 	t = cpu_to_uimage(timestamp);
1108 	ret = fdt_setprop(fit, noffset, FIT_TIMESTAMP_PROP, &t,
1109 				sizeof(uint32_t));
1110 	if (ret) {
1111 		debug("Can't set '%s' property for '%s' node (%s)\n",
1112 		      FIT_TIMESTAMP_PROP, fit_get_name(fit, noffset, NULL),
1113 		      fdt_strerror(ret));
1114 		return ret == -FDT_ERR_NOSPACE ? -ENOSPC : -1;
1115 	}
1116 
1117 	return 0;
1118 }
1119 
1120 /**
1121  * calculate_hash - calculate and return hash for provided input data
1122  * @data: pointer to the input data
1123  * @data_len: data length
1124  * @algo: requested hash algorithm
1125  * @value: pointer to the char, will hold hash value data (caller must
1126  * allocate enough free space)
1127  * value_len: length of the calculated hash
1128  *
1129  * calculate_hash() computes input data hash according to the requested
1130  * algorithm.
1131  * Resulting hash value is placed in caller provided 'value' buffer, length
1132  * of the calculated hash is returned via value_len pointer argument.
1133  *
1134  * returns:
1135  *     0, on success
1136  *    -1, when algo is unsupported
1137  */
calculate_hash(const void * data,int data_len,const char * algo_name,uint8_t * value,int * value_len)1138 int calculate_hash(const void *data, int data_len, const char *algo_name,
1139 			uint8_t *value, int *value_len)
1140 {
1141 	struct hash_algo *algo;
1142 
1143 	if (hash_lookup_algo(algo_name, &algo)) {
1144 		debug("Unsupported hash alogrithm\n");
1145 		return -1;
1146 	}
1147 
1148 	algo->hash_func_ws(data, data_len, value, algo->chunk_size);
1149 	*value_len = algo->digest_size;
1150 
1151 	return 0;
1152 }
1153 
fit_image_check_hash(const void * fit,int noffset,const void * data,size_t size,char ** err_msgp)1154 static int fit_image_check_hash(const void *fit, int noffset, const void *data,
1155 				size_t size, char **err_msgp)
1156 {
1157 	uint8_t value[FIT_MAX_HASH_LEN];
1158 	int value_len;
1159 	char *algo;
1160 	uint8_t *fit_value;
1161 	int fit_value_len;
1162 	int ignore;
1163 
1164 	*err_msgp = NULL;
1165 
1166 	if (fit_image_hash_get_algo(fit, noffset, &algo)) {
1167 		*err_msgp = "Can't get hash algo property";
1168 		return -1;
1169 	}
1170 	printf("%s", algo);
1171 
1172 	if (IMAGE_ENABLE_IGNORE) {
1173 		fit_image_hash_get_ignore(fit, noffset, &ignore);
1174 		if (ignore) {
1175 			printf("-skipped ");
1176 			return 0;
1177 		}
1178 	}
1179 
1180 	if (fit_image_hash_get_value(fit, noffset, &fit_value,
1181 				     &fit_value_len)) {
1182 		*err_msgp = "Can't get hash value property";
1183 		return -1;
1184 	}
1185 
1186 	if (calculate_hash(data, size, algo, value, &value_len)) {
1187 		*err_msgp = "Unsupported hash algorithm";
1188 		return -1;
1189 	}
1190 
1191 	if (value_len != fit_value_len) {
1192 		*err_msgp = "Bad hash value len";
1193 		return -1;
1194 	} else if (memcmp(value, fit_value, value_len) != 0) {
1195 		*err_msgp = "Bad hash value";
1196 		return -1;
1197 	}
1198 
1199 	return 0;
1200 }
1201 
fit_image_verify_with_data(const void * fit,int image_noffset,const void * data,size_t size)1202 int fit_image_verify_with_data(const void *fit, int image_noffset,
1203 			       const void *data, size_t size)
1204 {
1205 	int		noffset = 0;
1206 	char		*err_msg = "";
1207 	int verify_all = 1;
1208 	int ret;
1209 
1210 	/* Verify all required signatures */
1211 	if (IMAGE_ENABLE_VERIFY &&
1212 	    fit_image_verify_required_sigs(fit, image_noffset, data, size,
1213 					   gd_fdt_blob(), &verify_all)) {
1214 		err_msg = "Unable to verify required signature";
1215 		goto error;
1216 	}
1217 
1218 	/* Process all hash subnodes of the component image node */
1219 	fdt_for_each_subnode(noffset, fit, image_noffset) {
1220 		const char *name = fit_get_name(fit, noffset, NULL);
1221 
1222 		/*
1223 		 * Check subnode name, must be equal to "hash".
1224 		 * Multiple hash nodes require unique unit node
1225 		 * names, e.g. hash-1, hash-2, etc.
1226 		 */
1227 		if (!strncmp(name, FIT_HASH_NODENAME,
1228 			     strlen(FIT_HASH_NODENAME))) {
1229 			if (fit_image_check_hash(fit, noffset, data, size,
1230 						 &err_msg))
1231 				goto error;
1232 			puts("+ ");
1233 		} else if (IMAGE_ENABLE_VERIFY && verify_all &&
1234 				!strncmp(name, FIT_SIG_NODENAME,
1235 					strlen(FIT_SIG_NODENAME))) {
1236 			ret = fit_image_check_sig(fit, noffset, data,
1237 							size, -1, &err_msg);
1238 
1239 			/*
1240 			 * Show an indication on failure, but do not return
1241 			 * an error. Only keys marked 'required' can cause
1242 			 * an image validation failure. See the call to
1243 			 * fit_image_verify_required_sigs() above.
1244 			 */
1245 			if (ret)
1246 				puts("- ");
1247 			else
1248 				puts("+ ");
1249 		}
1250 	}
1251 
1252 	if (noffset == -FDT_ERR_TRUNCATED || noffset == -FDT_ERR_BADSTRUCTURE) {
1253 		err_msg = "Corrupted or truncated tree";
1254 		goto error;
1255 	}
1256 
1257 	return 1;
1258 
1259 error:
1260 	printf(" error!\n%s for '%s' hash node in '%s' image node\n",
1261 	       err_msg, fit_get_name(fit, noffset, NULL),
1262 	       fit_get_name(fit, image_noffset, NULL));
1263 	return 0;
1264 }
1265 
1266 /**
1267  * fit_image_verify - verify data integrity
1268  * @fit: pointer to the FIT format image header
1269  * @image_noffset: component image node offset
1270  *
1271  * fit_image_verify() goes over component image hash nodes,
1272  * re-calculates each data hash and compares with the value stored in hash
1273  * node.
1274  *
1275  * returns:
1276  *     1, if all hashes are valid
1277  *     0, otherwise (or on error)
1278  */
fit_image_verify(const void * fit,int image_noffset)1279 int fit_image_verify(const void *fit, int image_noffset)
1280 {
1281 	const void	*data;
1282 	size_t		size;
1283 	int		noffset = 0;
1284 	char		*err_msg = "";
1285 
1286 	/* Get image data and data length */
1287 	if (fit_image_get_data_and_size(fit, image_noffset, &data, &size)) {
1288 		err_msg = "Can't get image data/size";
1289 		printf("error!\n%s for '%s' hash node in '%s' image node\n",
1290 		       err_msg, fit_get_name(fit, noffset, NULL),
1291 		       fit_get_name(fit, image_noffset, NULL));
1292 		return 0;
1293 	}
1294 
1295 	return fit_image_verify_with_data(fit, image_noffset, data, size);
1296 }
1297 
1298 /**
1299  * fit_all_image_verify - verify data integrity for all images
1300  * @fit: pointer to the FIT format image header
1301  *
1302  * fit_all_image_verify() goes over all images in the FIT and
1303  * for every images checks if all it's hashes are valid.
1304  *
1305  * returns:
1306  *     1, if all hashes of all images are valid
1307  *     0, otherwise (or on error)
1308  */
fit_all_image_verify(const void * fit)1309 int fit_all_image_verify(const void *fit)
1310 {
1311 	int images_noffset;
1312 	int noffset;
1313 	int ndepth;
1314 	int count;
1315 
1316 	/* Find images parent node offset */
1317 	images_noffset = fdt_path_offset(fit, FIT_IMAGES_PATH);
1318 	if (images_noffset < 0) {
1319 		printf("Can't find images parent node '%s' (%s)\n",
1320 		       FIT_IMAGES_PATH, fdt_strerror(images_noffset));
1321 		return 0;
1322 	}
1323 
1324 	/* Process all image subnodes, check hashes for each */
1325 	printf("## Checking hash(es) for FIT Image at %08lx ...\n",
1326 	       (ulong)fit);
1327 	for (ndepth = 0, count = 0,
1328 	     noffset = fdt_next_node(fit, images_noffset, &ndepth);
1329 			(noffset >= 0) && (ndepth > 0);
1330 			noffset = fdt_next_node(fit, noffset, &ndepth)) {
1331 		if (ndepth == 1) {
1332 			/*
1333 			 * Direct child node of the images parent node,
1334 			 * i.e. component image node.
1335 			 */
1336 			printf("   Hash(es) for Image %u (%s): ", count,
1337 			       fit_get_name(fit, noffset, NULL));
1338 			count++;
1339 
1340 			if (!fit_image_verify(fit, noffset))
1341 				return 0;
1342 			printf("\n");
1343 		}
1344 	}
1345 	return 1;
1346 }
1347 
1348 /**
1349  * fit_image_check_os - check whether image node is of a given os type
1350  * @fit: pointer to the FIT format image header
1351  * @noffset: component image node offset
1352  * @os: requested image os
1353  *
1354  * fit_image_check_os() reads image os property and compares its numeric
1355  * id with the requested os. Comparison result is returned to the caller.
1356  *
1357  * returns:
1358  *     1 if image is of given os type
1359  *     0 otherwise (or on error)
1360  */
fit_image_check_os(const void * fit,int noffset,uint8_t os)1361 int fit_image_check_os(const void *fit, int noffset, uint8_t os)
1362 {
1363 	uint8_t image_os;
1364 
1365 	if (fit_image_get_os(fit, noffset, &image_os))
1366 		return 0;
1367 	return (os == image_os);
1368 }
1369 
1370 /**
1371  * fit_image_check_arch - check whether image node is of a given arch
1372  * @fit: pointer to the FIT format image header
1373  * @noffset: component image node offset
1374  * @arch: requested imagearch
1375  *
1376  * fit_image_check_arch() reads image arch property and compares its numeric
1377  * id with the requested arch. Comparison result is returned to the caller.
1378  *
1379  * returns:
1380  *     1 if image is of given arch
1381  *     0 otherwise (or on error)
1382  */
fit_image_check_arch(const void * fit,int noffset,uint8_t arch)1383 int fit_image_check_arch(const void *fit, int noffset, uint8_t arch)
1384 {
1385 	uint8_t image_arch;
1386 	int aarch32_support = 0;
1387 
1388 #ifdef CONFIG_ARM64_SUPPORT_AARCH32
1389 	aarch32_support = 1;
1390 #endif
1391 
1392 	if (fit_image_get_arch(fit, noffset, &image_arch))
1393 		return 0;
1394 	return (arch == image_arch) ||
1395 		(arch == IH_ARCH_I386 && image_arch == IH_ARCH_X86_64) ||
1396 		(arch == IH_ARCH_ARM64 && image_arch == IH_ARCH_ARM &&
1397 		 aarch32_support);
1398 }
1399 
1400 /**
1401  * fit_image_check_type - check whether image node is of a given type
1402  * @fit: pointer to the FIT format image header
1403  * @noffset: component image node offset
1404  * @type: requested image type
1405  *
1406  * fit_image_check_type() reads image type property and compares its numeric
1407  * id with the requested type. Comparison result is returned to the caller.
1408  *
1409  * returns:
1410  *     1 if image is of given type
1411  *     0 otherwise (or on error)
1412  */
fit_image_check_type(const void * fit,int noffset,uint8_t type)1413 int fit_image_check_type(const void *fit, int noffset, uint8_t type)
1414 {
1415 	uint8_t image_type;
1416 
1417 	if (fit_image_get_type(fit, noffset, &image_type))
1418 		return 0;
1419 	return (type == image_type);
1420 }
1421 
1422 /**
1423  * fit_image_check_comp - check whether image node uses given compression
1424  * @fit: pointer to the FIT format image header
1425  * @noffset: component image node offset
1426  * @comp: requested image compression type
1427  *
1428  * fit_image_check_comp() reads image compression property and compares its
1429  * numeric id with the requested compression type. Comparison result is
1430  * returned to the caller.
1431  *
1432  * returns:
1433  *     1 if image uses requested compression
1434  *     0 otherwise (or on error)
1435  */
fit_image_check_comp(const void * fit,int noffset,uint8_t comp)1436 int fit_image_check_comp(const void *fit, int noffset, uint8_t comp)
1437 {
1438 	uint8_t image_comp;
1439 
1440 	if (fit_image_get_comp(fit, noffset, &image_comp))
1441 		return 0;
1442 	return (comp == image_comp);
1443 }
1444 
1445 /**
1446  * fit_check_format - sanity check FIT image format
1447  * @fit: pointer to the FIT format image header
1448  *
1449  * fit_check_format() runs a basic sanity FIT image verification.
1450  * Routine checks for mandatory properties, nodes, etc.
1451  *
1452  * returns:
1453  *     1, on success
1454  *     0, on failure
1455  */
fit_check_format(const void * fit)1456 int fit_check_format(const void *fit)
1457 {
1458 	/* A FIT image must be a valid FDT */
1459 	if (fdt_check_header(fit)) {
1460 		debug("Wrong FIT format: not a flattened device tree\n");
1461 		return 0;
1462 	}
1463 
1464 	/* mandatory / node 'description' property */
1465 	if (fdt_getprop(fit, 0, FIT_DESC_PROP, NULL) == NULL) {
1466 		debug("Wrong FIT format: no description\n");
1467 		return 0;
1468 	}
1469 
1470 	if (IMAGE_ENABLE_TIMESTAMP) {
1471 		/* mandatory / node 'timestamp' property */
1472 		if (fdt_getprop(fit, 0, FIT_TIMESTAMP_PROP, NULL) == NULL) {
1473 			debug("Wrong FIT format: no timestamp\n");
1474 			return 0;
1475 		}
1476 	}
1477 
1478 	/* mandatory subimages parent '/images' node */
1479 	if (fdt_path_offset(fit, FIT_IMAGES_PATH) < 0) {
1480 		debug("Wrong FIT format: no images parent node\n");
1481 		return 0;
1482 	}
1483 
1484 	return 1;
1485 }
1486 
1487 
1488 /**
1489  * fit_conf_find_compat
1490  * @fit: pointer to the FIT format image header
1491  * @fdt: pointer to the device tree to compare against
1492  *
1493  * fit_conf_find_compat() attempts to find the configuration whose fdt is the
1494  * most compatible with the passed in device tree.
1495  *
1496  * Example:
1497  *
1498  * / o image-tree
1499  *   |-o images
1500  *   | |-o fdt-1
1501  *   | |-o fdt-2
1502  *   |
1503  *   |-o configurations
1504  *     |-o config-1
1505  *     | |-fdt = fdt-1
1506  *     |
1507  *     |-o config-2
1508  *       |-fdt = fdt-2
1509  *
1510  * / o U-Boot fdt
1511  *   |-compatible = "foo,bar", "bim,bam"
1512  *
1513  * / o kernel fdt1
1514  *   |-compatible = "foo,bar",
1515  *
1516  * / o kernel fdt2
1517  *   |-compatible = "bim,bam", "baz,biz"
1518  *
1519  * Configuration 1 would be picked because the first string in U-Boot's
1520  * compatible list, "foo,bar", matches a compatible string in the root of fdt1.
1521  * "bim,bam" in fdt2 matches the second string which isn't as good as fdt1.
1522  *
1523  * returns:
1524  *     offset to the configuration to use if one was found
1525  *     -1 otherwise
1526  */
fit_conf_find_compat(const void * fit,const void * fdt)1527 int fit_conf_find_compat(const void *fit, const void *fdt)
1528 {
1529 	int ndepth = 0;
1530 	int noffset, confs_noffset, images_noffset;
1531 	const void *fdt_compat;
1532 	int fdt_compat_len;
1533 	int best_match_offset = 0;
1534 	int best_match_pos = 0;
1535 
1536 	confs_noffset = fdt_path_offset(fit, FIT_CONFS_PATH);
1537 	images_noffset = fdt_path_offset(fit, FIT_IMAGES_PATH);
1538 	if (confs_noffset < 0 || images_noffset < 0) {
1539 		debug("Can't find configurations or images nodes.\n");
1540 		return -1;
1541 	}
1542 
1543 	fdt_compat = fdt_getprop(fdt, 0, "compatible", &fdt_compat_len);
1544 	if (!fdt_compat) {
1545 		debug("Fdt for comparison has no \"compatible\" property.\n");
1546 		return -1;
1547 	}
1548 
1549 	/*
1550 	 * Loop over the configurations in the FIT image.
1551 	 */
1552 	for (noffset = fdt_next_node(fit, confs_noffset, &ndepth);
1553 			(noffset >= 0) && (ndepth > 0);
1554 			noffset = fdt_next_node(fit, noffset, &ndepth)) {
1555 		const void *kfdt;
1556 		const char *kfdt_name;
1557 		int kfdt_noffset;
1558 		const char *cur_fdt_compat;
1559 		int len;
1560 		size_t size;
1561 		int i;
1562 
1563 		if (ndepth > 1)
1564 			continue;
1565 
1566 		kfdt_name = fdt_getprop(fit, noffset, "fdt", &len);
1567 		if (!kfdt_name) {
1568 			debug("No fdt property found.\n");
1569 			continue;
1570 		}
1571 		kfdt_noffset = fdt_subnode_offset(fit, images_noffset,
1572 						  kfdt_name);
1573 		if (kfdt_noffset < 0) {
1574 			debug("No image node named \"%s\" found.\n",
1575 			      kfdt_name);
1576 			continue;
1577 		}
1578 		/*
1579 		 * Get a pointer to this configuration's fdt.
1580 		 */
1581 		if (fit_image_get_data(fit, kfdt_noffset, &kfdt, &size)) {
1582 			debug("Failed to get fdt \"%s\".\n", kfdt_name);
1583 			continue;
1584 		}
1585 
1586 		len = fdt_compat_len;
1587 		cur_fdt_compat = fdt_compat;
1588 		/*
1589 		 * Look for a match for each U-Boot compatibility string in
1590 		 * turn in this configuration's fdt.
1591 		 */
1592 		for (i = 0; len > 0 &&
1593 		     (!best_match_offset || best_match_pos > i); i++) {
1594 			int cur_len = strlen(cur_fdt_compat) + 1;
1595 
1596 			if (!fdt_node_check_compatible(kfdt, 0,
1597 						       cur_fdt_compat)) {
1598 				best_match_offset = noffset;
1599 				best_match_pos = i;
1600 				break;
1601 			}
1602 			len -= cur_len;
1603 			cur_fdt_compat += cur_len;
1604 		}
1605 	}
1606 	if (!best_match_offset) {
1607 		debug("No match found.\n");
1608 		return -1;
1609 	}
1610 
1611 	return best_match_offset;
1612 }
1613 
1614 /**
1615  * fit_conf_get_node - get node offset for configuration of a given unit name
1616  * @fit: pointer to the FIT format image header
1617  * @conf_uname: configuration node unit name
1618  *
1619  * fit_conf_get_node() finds a configuration (within the '/configurations'
1620  * parent node) of a provided unit name. If configuration is found its node
1621  * offset is returned to the caller.
1622  *
1623  * When NULL is provided in second argument fit_conf_get_node() will search
1624  * for a default configuration node instead. Default configuration node unit
1625  * name is retrieved from FIT_DEFAULT_PROP property of the '/configurations'
1626  * node.
1627  *
1628  * returns:
1629  *     configuration node offset when found (>=0)
1630  *     negative number on failure (FDT_ERR_* code)
1631  */
fit_conf_get_node(const void * fit,const char * conf_uname)1632 int fit_conf_get_node(const void *fit, const char *conf_uname)
1633 {
1634 	int noffset, confs_noffset;
1635 	int len;
1636 	const char *s;
1637 	char *conf_uname_copy = NULL;
1638 
1639 	confs_noffset = fdt_path_offset(fit, FIT_CONFS_PATH);
1640 	if (confs_noffset < 0) {
1641 		debug("Can't find configurations parent node '%s' (%s)\n",
1642 		      FIT_CONFS_PATH, fdt_strerror(confs_noffset));
1643 		return confs_noffset;
1644 	}
1645 
1646 	if (conf_uname == NULL) {
1647 		/* get configuration unit name from the default property */
1648 		debug("No configuration specified, trying default...\n");
1649 		conf_uname = (char *)fdt_getprop(fit, confs_noffset,
1650 						 FIT_DEFAULT_PROP, &len);
1651 		if (conf_uname == NULL) {
1652 			fit_get_debug(fit, confs_noffset, FIT_DEFAULT_PROP,
1653 				      len);
1654 			return len;
1655 		}
1656 		debug("Found default configuration: '%s'\n", conf_uname);
1657 	}
1658 
1659 	s = strchr(conf_uname, '#');
1660 	if (s) {
1661 		len = s - conf_uname;
1662 		conf_uname_copy = malloc(len + 1);
1663 		if (!conf_uname_copy) {
1664 			debug("Can't allocate uname copy: '%s'\n",
1665 					conf_uname);
1666 			return -ENOMEM;
1667 		}
1668 		memcpy(conf_uname_copy, conf_uname, len);
1669 		conf_uname_copy[len] = '\0';
1670 		conf_uname = conf_uname_copy;
1671 	}
1672 
1673 	noffset = fdt_subnode_offset(fit, confs_noffset, conf_uname);
1674 	if (noffset < 0) {
1675 		debug("Can't get node offset for configuration unit name: '%s' (%s)\n",
1676 		      conf_uname, fdt_strerror(noffset));
1677 	}
1678 
1679 	if (conf_uname_copy)
1680 		free(conf_uname_copy);
1681 
1682 	return noffset;
1683 }
1684 
fit_conf_get_prop_node_count(const void * fit,int noffset,const char * prop_name)1685 int fit_conf_get_prop_node_count(const void *fit, int noffset,
1686 		const char *prop_name)
1687 {
1688 	return fdt_stringlist_count(fit, noffset, prop_name);
1689 }
1690 
fit_conf_get_prop_node_index(const void * fit,int noffset,const char * prop_name,int index)1691 int fit_conf_get_prop_node_index(const void *fit, int noffset,
1692 		const char *prop_name, int index)
1693 {
1694 	const char *uname;
1695 	int len;
1696 
1697 	/* get kernel image unit name from configuration kernel property */
1698 	uname = fdt_stringlist_get(fit, noffset, prop_name, index, &len);
1699 	if (uname == NULL)
1700 		return len;
1701 
1702 	return fit_image_get_node(fit, uname);
1703 }
1704 
fit_conf_get_prop_node(const void * fit,int noffset,const char * prop_name)1705 int fit_conf_get_prop_node(const void *fit, int noffset,
1706 		const char *prop_name)
1707 {
1708 	return fit_conf_get_prop_node_index(fit, noffset, prop_name, 0);
1709 }
1710 
fit_image_select(const void * fit,int rd_noffset,int verify)1711 static int fit_image_select(const void *fit, int rd_noffset, int verify)
1712 {
1713 	fit_image_print(fit, rd_noffset, "   ");
1714 
1715 	if (verify) {
1716 		puts("   Verifying Hash Integrity ... ");
1717 		if (!fit_image_verify(fit, rd_noffset)) {
1718 			puts("Bad Data Hash\n");
1719 			return -EACCES;
1720 		}
1721 		puts("OK\n");
1722 	}
1723 
1724 	return 0;
1725 }
1726 
fit_get_node_from_config(bootm_headers_t * images,const char * prop_name,ulong addr)1727 int fit_get_node_from_config(bootm_headers_t *images, const char *prop_name,
1728 			ulong addr)
1729 {
1730 	int cfg_noffset;
1731 	void *fit_hdr;
1732 	int noffset;
1733 
1734 	debug("*  %s: using config '%s' from image at 0x%08lx\n",
1735 	      prop_name, images->fit_uname_cfg, addr);
1736 
1737 	/* Check whether configuration has this property defined */
1738 	fit_hdr = map_sysmem(addr, 0);
1739 	cfg_noffset = fit_conf_get_node(fit_hdr, images->fit_uname_cfg);
1740 	if (cfg_noffset < 0) {
1741 		debug("*  %s: no such config\n", prop_name);
1742 		return -EINVAL;
1743 	}
1744 
1745 	noffset = fit_conf_get_prop_node(fit_hdr, cfg_noffset, prop_name);
1746 	if (noffset < 0) {
1747 		debug("*  %s: no '%s' in config\n", prop_name, prop_name);
1748 		return -ENOENT;
1749 	}
1750 
1751 	return noffset;
1752 }
1753 
1754 /**
1755  * fit_get_image_type_property() - get property name for IH_TYPE_...
1756  *
1757  * @return the properly name where we expect to find the image in the
1758  * config node
1759  */
fit_get_image_type_property(int type)1760 static const char *fit_get_image_type_property(int type)
1761 {
1762 	/*
1763 	 * This is sort-of available in the uimage_type[] table in image.c
1764 	 * but we don't have access to the short name, and "fdt" is different
1765 	 * anyway. So let's just keep it here.
1766 	 */
1767 	switch (type) {
1768 	case IH_TYPE_FLATDT:
1769 		return FIT_FDT_PROP;
1770 	case IH_TYPE_KERNEL:
1771 		return FIT_KERNEL_PROP;
1772 	case IH_TYPE_RAMDISK:
1773 		return FIT_RAMDISK_PROP;
1774 	case IH_TYPE_X86_SETUP:
1775 		return FIT_SETUP_PROP;
1776 	case IH_TYPE_LOADABLE:
1777 		return FIT_LOADABLE_PROP;
1778 	case IH_TYPE_FPGA:
1779 		return FIT_FPGA_PROP;
1780 	case IH_TYPE_STANDALONE:
1781 		return FIT_STANDALONE_PROP;
1782 	}
1783 
1784 	return "unknown";
1785 }
1786 
fit_image_load(bootm_headers_t * images,ulong addr,const char ** fit_unamep,const char ** fit_uname_configp,int arch,int image_type,int bootstage_id,enum fit_load_op load_op,ulong * datap,ulong * lenp)1787 int fit_image_load(bootm_headers_t *images, ulong addr,
1788 		   const char **fit_unamep, const char **fit_uname_configp,
1789 		   int arch, int image_type, int bootstage_id,
1790 		   enum fit_load_op load_op, ulong *datap, ulong *lenp)
1791 {
1792 	int cfg_noffset, noffset;
1793 	const char *fit_uname;
1794 	const char *fit_uname_config;
1795 	const char *fit_base_uname_config;
1796 	const void *fit;
1797 	const void *buf;
1798 	size_t size;
1799 	int type_ok, os_ok;
1800 	ulong load, data, len;
1801 	uint8_t os;
1802 #ifndef USE_HOSTCC
1803 	uint8_t os_arch;
1804 #endif
1805 	const char *prop_name;
1806 	int ret;
1807 
1808 	fit = map_sysmem(addr, 0);
1809 	fit_uname = fit_unamep ? *fit_unamep : NULL;
1810 	fit_uname_config = fit_uname_configp ? *fit_uname_configp : NULL;
1811 	fit_base_uname_config = NULL;
1812 	prop_name = fit_get_image_type_property(image_type);
1813 	printf("## Loading %s from FIT Image at %08lx ...\n", prop_name, addr);
1814 
1815 	bootstage_mark(bootstage_id + BOOTSTAGE_SUB_FORMAT);
1816 	if (!fit_check_format(fit)) {
1817 		printf("Bad FIT %s image format!\n", prop_name);
1818 		bootstage_error(bootstage_id + BOOTSTAGE_SUB_FORMAT);
1819 		return -ENOEXEC;
1820 	}
1821 	bootstage_mark(bootstage_id + BOOTSTAGE_SUB_FORMAT_OK);
1822 	if (fit_uname) {
1823 		/* get FIT component image node offset */
1824 		bootstage_mark(bootstage_id + BOOTSTAGE_SUB_UNIT_NAME);
1825 		noffset = fit_image_get_node(fit, fit_uname);
1826 	} else {
1827 		/*
1828 		 * no image node unit name, try to get config
1829 		 * node first. If config unit node name is NULL
1830 		 * fit_conf_get_node() will try to find default config node
1831 		 */
1832 		bootstage_mark(bootstage_id + BOOTSTAGE_SUB_NO_UNIT_NAME);
1833 		if (IMAGE_ENABLE_BEST_MATCH && !fit_uname_config) {
1834 			cfg_noffset = fit_conf_find_compat(fit, gd_fdt_blob());
1835 		} else {
1836 			cfg_noffset = fit_conf_get_node(fit,
1837 							fit_uname_config);
1838 		}
1839 		if (cfg_noffset < 0) {
1840 			puts("Could not find configuration node\n");
1841 			bootstage_error(bootstage_id +
1842 					BOOTSTAGE_SUB_NO_UNIT_NAME);
1843 			return -ENOENT;
1844 		}
1845 
1846 		fit_base_uname_config = fdt_get_name(fit, cfg_noffset, NULL);
1847 		printf("   Using '%s' configuration\n", fit_base_uname_config);
1848 		/* Remember this config */
1849 		if (image_type == IH_TYPE_KERNEL)
1850 			images->fit_uname_cfg = fit_base_uname_config;
1851 
1852 		if (IMAGE_ENABLE_VERIFY && images->verify) {
1853 			puts("   Verifying Hash Integrity ... ");
1854 			if (fit_config_verify(fit, cfg_noffset)) {
1855 				puts("Bad Data Hash\n");
1856 				bootstage_error(bootstage_id +
1857 					BOOTSTAGE_SUB_HASH);
1858 				return -EACCES;
1859 			}
1860 			puts("OK\n");
1861 		}
1862 
1863 		bootstage_mark(BOOTSTAGE_ID_FIT_CONFIG);
1864 
1865 		noffset = fit_conf_get_prop_node(fit, cfg_noffset,
1866 						 prop_name);
1867 		fit_uname = fit_get_name(fit, noffset, NULL);
1868 	}
1869 	if (noffset < 0) {
1870 		printf("Could not find subimage node type '%s'\n", prop_name);
1871 		bootstage_error(bootstage_id + BOOTSTAGE_SUB_SUBNODE);
1872 		return -ENOENT;
1873 	}
1874 
1875 	printf("   Trying '%s' %s subimage\n", fit_uname, prop_name);
1876 
1877 	ret = fit_image_select(fit, noffset, images->verify);
1878 	if (ret) {
1879 		bootstage_error(bootstage_id + BOOTSTAGE_SUB_HASH);
1880 		return ret;
1881 	}
1882 
1883 	bootstage_mark(bootstage_id + BOOTSTAGE_SUB_CHECK_ARCH);
1884 #if !defined(USE_HOSTCC) && !defined(CONFIG_SANDBOX)
1885 	if (!fit_image_check_target_arch(fit, noffset)) {
1886 		puts("Unsupported Architecture\n");
1887 		bootstage_error(bootstage_id + BOOTSTAGE_SUB_CHECK_ARCH);
1888 		return -ENOEXEC;
1889 	}
1890 #endif
1891 
1892 #ifndef USE_HOSTCC
1893 	fit_image_get_arch(fit, noffset, &os_arch);
1894 	images->os.arch = os_arch;
1895 #endif
1896 
1897 	if (image_type == IH_TYPE_FLATDT &&
1898 	    !fit_image_check_comp(fit, noffset, IH_COMP_NONE)) {
1899 		puts("FDT image is compressed");
1900 		return -EPROTONOSUPPORT;
1901 	}
1902 
1903 	bootstage_mark(bootstage_id + BOOTSTAGE_SUB_CHECK_ALL);
1904 	type_ok = fit_image_check_type(fit, noffset, image_type) ||
1905 		  fit_image_check_type(fit, noffset, IH_TYPE_FIRMWARE) ||
1906 		  (image_type == IH_TYPE_KERNEL &&
1907 		   fit_image_check_type(fit, noffset, IH_TYPE_KERNEL_NOLOAD));
1908 
1909 	os_ok = image_type == IH_TYPE_FLATDT ||
1910 		image_type == IH_TYPE_FPGA ||
1911 		fit_image_check_os(fit, noffset, IH_OS_LINUX) ||
1912 		fit_image_check_os(fit, noffset, IH_OS_U_BOOT) ||
1913 		fit_image_check_os(fit, noffset, IH_OS_OPENRTOS);
1914 
1915 	/*
1916 	 * If either of the checks fail, we should report an error, but
1917 	 * if the image type is coming from the "loadables" field, we
1918 	 * don't care what it is
1919 	 */
1920 	if ((!type_ok || !os_ok) && image_type != IH_TYPE_LOADABLE) {
1921 		fit_image_get_os(fit, noffset, &os);
1922 		printf("No %s %s %s Image\n",
1923 		       genimg_get_os_name(os),
1924 		       genimg_get_arch_name(arch),
1925 		       genimg_get_type_name(image_type));
1926 		bootstage_error(bootstage_id + BOOTSTAGE_SUB_CHECK_ALL);
1927 		return -EIO;
1928 	}
1929 
1930 	bootstage_mark(bootstage_id + BOOTSTAGE_SUB_CHECK_ALL_OK);
1931 
1932 	/* get image data address and length */
1933 	if (fit_image_get_data_and_size(fit, noffset, &buf, &size)) {
1934 		printf("Could not find %s subimage data!\n", prop_name);
1935 		bootstage_error(bootstage_id + BOOTSTAGE_SUB_GET_DATA);
1936 		return -ENOENT;
1937 	}
1938 
1939 #if !defined(USE_HOSTCC) && defined(CONFIG_FIT_IMAGE_POST_PROCESS)
1940 	/* perform any post-processing on the image data */
1941 	board_fit_image_post_process(fit, noffset, (void **)&buf, &size);
1942 #endif
1943 
1944 	len = (ulong)size;
1945 
1946 	/* verify that image data is a proper FDT blob */
1947 	if (image_type == IH_TYPE_FLATDT && fdt_check_header(buf)) {
1948 		puts("Subimage data is not a FDT");
1949 		return -ENOEXEC;
1950 	}
1951 
1952 	bootstage_mark(bootstage_id + BOOTSTAGE_SUB_GET_DATA_OK);
1953 
1954 	/*
1955 	 * Work-around for eldk-4.2 which gives this warning if we try to
1956 	 * cast in the unmap_sysmem() call:
1957 	 * warning: initialization discards qualifiers from pointer target type
1958 	 */
1959 	{
1960 		void *vbuf = (void *)buf;
1961 
1962 		data = map_to_sysmem(vbuf);
1963 	}
1964 
1965 	if (load_op == FIT_LOAD_IGNORED) {
1966 		/* Don't load */
1967 	} else if (fit_image_get_load(fit, noffset, &load)) {
1968 		if (load_op == FIT_LOAD_REQUIRED) {
1969 			printf("Can't get %s subimage load address!\n",
1970 			       prop_name);
1971 			bootstage_error(bootstage_id + BOOTSTAGE_SUB_LOAD);
1972 			return -EBADF;
1973 		}
1974 	} else if (load_op != FIT_LOAD_OPTIONAL_NON_ZERO || load) {
1975 		ulong image_start, image_end;
1976 		ulong load_end;
1977 		void *dst;
1978 
1979 		/*
1980 		 * move image data to the load address,
1981 		 * make sure we don't overwrite initial image
1982 		 */
1983 		image_start = addr;
1984 		image_end = addr + fit_get_size(fit);
1985 
1986 		load_end = load + len;
1987 		if (image_type != IH_TYPE_KERNEL &&
1988 		    load < image_end && load_end > image_start) {
1989 			printf("Error: %s overwritten\n", prop_name);
1990 			return -EXDEV;
1991 		}
1992 
1993 		printf("   Loading %s from 0x%08lx to 0x%08lx\n",
1994 		       prop_name, data, load);
1995 
1996 		dst = map_sysmem(load, len);
1997 		memmove(dst, buf, len);
1998 		data = load;
1999 	}
2000 	bootstage_mark(bootstage_id + BOOTSTAGE_SUB_LOAD);
2001 
2002 	*datap = data;
2003 	*lenp = len;
2004 	if (fit_unamep)
2005 		*fit_unamep = (char *)fit_uname;
2006 	if (fit_uname_configp)
2007 		*fit_uname_configp = (char *)(fit_uname_config ? :
2008 					      fit_base_uname_config);
2009 
2010 	return noffset;
2011 }
2012 
boot_get_setup_fit(bootm_headers_t * images,uint8_t arch,ulong * setup_start,ulong * setup_len)2013 int boot_get_setup_fit(bootm_headers_t *images, uint8_t arch,
2014 			ulong *setup_start, ulong *setup_len)
2015 {
2016 	int noffset;
2017 	ulong addr;
2018 	ulong len;
2019 	int ret;
2020 
2021 	addr = map_to_sysmem(images->fit_hdr_os);
2022 	noffset = fit_get_node_from_config(images, FIT_SETUP_PROP, addr);
2023 	if (noffset < 0)
2024 		return noffset;
2025 
2026 	ret = fit_image_load(images, addr, NULL, NULL, arch,
2027 			     IH_TYPE_X86_SETUP, BOOTSTAGE_ID_FIT_SETUP_START,
2028 			     FIT_LOAD_REQUIRED, setup_start, &len);
2029 
2030 	return ret;
2031 }
2032 
2033 #ifndef USE_HOSTCC
boot_get_fdt_fit(bootm_headers_t * images,ulong addr,const char ** fit_unamep,const char ** fit_uname_configp,int arch,ulong * datap,ulong * lenp)2034 int boot_get_fdt_fit(bootm_headers_t *images, ulong addr,
2035 		   const char **fit_unamep, const char **fit_uname_configp,
2036 		   int arch, ulong *datap, ulong *lenp)
2037 {
2038 	int fdt_noffset, cfg_noffset, count;
2039 	const void *fit;
2040 	const char *fit_uname = NULL;
2041 	const char *fit_uname_config = NULL;
2042 	char *fit_uname_config_copy = NULL;
2043 	char *next_config = NULL;
2044 	ulong load, len;
2045 #ifdef CONFIG_OF_LIBFDT_OVERLAY
2046 	ulong image_start, image_end;
2047 	ulong ovload, ovlen;
2048 	const char *uconfig;
2049 	const char *uname;
2050 	void *base, *ov;
2051 	int i, err, noffset, ov_noffset;
2052 #endif
2053 
2054 	fit_uname = fit_unamep ? *fit_unamep : NULL;
2055 
2056 	if (fit_uname_configp && *fit_uname_configp) {
2057 		fit_uname_config_copy = strdup(*fit_uname_configp);
2058 		if (!fit_uname_config_copy)
2059 			return -ENOMEM;
2060 
2061 		next_config = strchr(fit_uname_config_copy, '#');
2062 		if (next_config)
2063 			*next_config++ = '\0';
2064 		if (next_config - 1 > fit_uname_config_copy)
2065 			fit_uname_config = fit_uname_config_copy;
2066 	}
2067 
2068 	fdt_noffset = fit_image_load(images,
2069 		addr, &fit_uname, &fit_uname_config,
2070 		arch, IH_TYPE_FLATDT,
2071 		BOOTSTAGE_ID_FIT_FDT_START,
2072 		FIT_LOAD_OPTIONAL, &load, &len);
2073 
2074 	if (fdt_noffset < 0)
2075 		goto out;
2076 
2077 	debug("fit_uname=%s, fit_uname_config=%s\n",
2078 			fit_uname ? fit_uname : "<NULL>",
2079 			fit_uname_config ? fit_uname_config : "<NULL>");
2080 
2081 	fit = map_sysmem(addr, 0);
2082 
2083 	cfg_noffset = fit_conf_get_node(fit, fit_uname_config);
2084 
2085 	/* single blob, or error just return as well */
2086 	count = fit_conf_get_prop_node_count(fit, cfg_noffset, FIT_FDT_PROP);
2087 	if (count <= 1 && !next_config)
2088 		goto out;
2089 
2090 	/* we need to apply overlays */
2091 
2092 #ifdef CONFIG_OF_LIBFDT_OVERLAY
2093 	image_start = addr;
2094 	image_end = addr + fit_get_size(fit);
2095 	/* verify that relocation took place by load address not being in fit */
2096 	if (load >= image_start && load < image_end) {
2097 		/* check is simplified; fit load checks for overlaps */
2098 		printf("Overlayed FDT requires relocation\n");
2099 		fdt_noffset = -EBADF;
2100 		goto out;
2101 	}
2102 
2103 	base = map_sysmem(load, len);
2104 
2105 	/* apply extra configs in FIT first, followed by args */
2106 	for (i = 1; ; i++) {
2107 		if (i < count) {
2108 			noffset = fit_conf_get_prop_node_index(fit, cfg_noffset,
2109 							       FIT_FDT_PROP, i);
2110 			uname = fit_get_name(fit, noffset, NULL);
2111 			uconfig = NULL;
2112 		} else {
2113 			if (!next_config)
2114 				break;
2115 			uconfig = next_config;
2116 			next_config = strchr(next_config, '#');
2117 			if (next_config)
2118 				*next_config++ = '\0';
2119 			uname = NULL;
2120 		}
2121 
2122 		debug("%d: using uname=%s uconfig=%s\n", i, uname, uconfig);
2123 
2124 		ov_noffset = fit_image_load(images,
2125 			addr, &uname, &uconfig,
2126 			arch, IH_TYPE_FLATDT,
2127 			BOOTSTAGE_ID_FIT_FDT_START,
2128 			FIT_LOAD_REQUIRED, &ovload, &ovlen);
2129 		if (ov_noffset < 0) {
2130 			printf("load of %s failed\n", uname);
2131 			continue;
2132 		}
2133 		debug("%s loaded at 0x%08lx len=0x%08lx\n",
2134 				uname, ovload, ovlen);
2135 		ov = map_sysmem(ovload, ovlen);
2136 
2137 		base = map_sysmem(load, len + ovlen);
2138 		err = fdt_open_into(base, base, len + ovlen);
2139 		if (err < 0) {
2140 			printf("failed on fdt_open_into\n");
2141 			fdt_noffset = err;
2142 			goto out;
2143 		}
2144 		/* the verbose method prints out messages on error */
2145 		err = fdt_overlay_apply_verbose(base, ov);
2146 		if (err < 0) {
2147 			fdt_noffset = err;
2148 			goto out;
2149 		}
2150 		fdt_pack(base);
2151 		len = fdt_totalsize(base);
2152 	}
2153 #else
2154 	printf("config with overlays but CONFIG_OF_LIBFDT_OVERLAY not set\n");
2155 	fdt_noffset = -EBADF;
2156 #endif
2157 
2158 out:
2159 	if (datap)
2160 		*datap = load;
2161 	if (lenp)
2162 		*lenp = len;
2163 	if (fit_unamep)
2164 		*fit_unamep = fit_uname;
2165 	if (fit_uname_configp)
2166 		*fit_uname_configp = fit_uname_config;
2167 
2168 	if (fit_uname_config_copy)
2169 		free(fit_uname_config_copy);
2170 	return fdt_noffset;
2171 }
2172 #endif
2173