1 // SPDX-License-Identifier: GPL-2.0+
3 * Copyright (c) 2013, Google Inc.
5 * (C) Copyright 2008 Semihalf
7 * (C) Copyright 2000-2006
8 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
11 #define LOG_CATEGORY LOGC_BOOT
16 #include <linux/libfdt.h>
17 #include <u-boot/crc.h>
19 #include <linux/compiler.h>
26 #include <asm/global_data.h>
27 DECLARE_GLOBAL_DATA_PTR;
28 #endif /* !USE_HOSTCC*/
32 #include <bootstage.h>
33 #include <linux/kconfig.h>
34 #include <u-boot/crc.h>
35 #include <u-boot/md5.h>
36 #include <u-boot/sha1.h>
37 #include <u-boot/sha256.h>
38 #include <u-boot/sha512.h>
40 /*****************************************************************************/
41 /* New uImage format routines */
42 /*****************************************************************************/
44 static int fit_parse_spec(const char *spec, char sepc, ulong addr_curr,
45 ulong *addr, const char **name)
52 sep = strchr(spec, sepc);
55 *addr = simple_strtoul(spec, NULL, 16);
65 * fit_parse_conf - parse FIT configuration spec
66 * @spec: input string, containing configuration spec
67 * @add_curr: current image address (to be used as a possible default)
68 * @addr: pointer to a ulong variable, will hold FIT image address of a given
70 * @conf_name double pointer to a char, will hold pointer to a configuration
73 * fit_parse_conf() expects configuration spec in the form of [<addr>]#<conf>,
74 * where <addr> is a FIT image address that contains configuration
75 * with a <conf> unit name.
77 * Address part is optional, and if omitted default add_curr will
81 * 1 if spec is a valid configuration string,
82 * addr and conf_name are set accordingly
85 int fit_parse_conf(const char *spec, ulong addr_curr,
86 ulong *addr, const char **conf_name)
88 return fit_parse_spec(spec, '#', addr_curr, addr, conf_name);
92 * fit_parse_subimage - parse FIT subimage spec
93 * @spec: input string, containing subimage spec
94 * @add_curr: current image address (to be used as a possible default)
95 * @addr: pointer to a ulong variable, will hold FIT image address of a given
97 * @image_name: double pointer to a char, will hold pointer to a subimage name
99 * fit_parse_subimage() expects subimage spec in the form of
100 * [<addr>]:<subimage>, where <addr> is a FIT image address that contains
101 * subimage with a <subimg> unit name.
103 * Address part is optional, and if omitted default add_curr will
107 * 1 if spec is a valid subimage string,
108 * addr and image_name are set accordingly
111 int fit_parse_subimage(const char *spec, ulong addr_curr,
112 ulong *addr, const char **image_name)
114 return fit_parse_spec(spec, ':', addr_curr, addr, image_name);
116 #endif /* !USE_HOSTCC */
119 /* Host tools use these implementations for Cipher and Signature support */
120 static void *host_blob;
122 void image_set_host_blob(void *blob)
127 void *image_get_host_blob(void)
131 #endif /* USE_HOSTCC */
133 static void fit_get_debug(const void *fit, int noffset,
134 char *prop_name, int err)
136 debug("Can't get '%s' property from FIT 0x%08lx, node: offset %d, name %s (%s)\n",
137 prop_name, (ulong)fit, noffset, fit_get_name(fit, noffset, NULL),
142 * fit_get_subimage_count - get component (sub-image) count
143 * @fit: pointer to the FIT format image header
144 * @images_noffset: offset of images node
147 * number of image components
149 int fit_get_subimage_count(const void *fit, int images_noffset)
155 /* Process its subnodes, print out component images details */
156 for (ndepth = 0, count = 0,
157 noffset = fdt_next_node(fit, images_noffset, &ndepth);
158 (noffset >= 0) && (ndepth > 0);
159 noffset = fdt_next_node(fit, noffset, &ndepth)) {
168 #if CONFIG_IS_ENABLED(FIT_PRINT) || CONFIG_IS_ENABLED(SPL_FIT_PRINT)
170 * fit_image_print_data() - prints out the hash node details
171 * @fit: pointer to the FIT format image header
172 * @noffset: offset of the hash node
173 * @p: pointer to prefix string
174 * @type: Type of information to print ("hash" or "sign")
176 * fit_image_print_data() lists properties for the processed hash node
178 * This function avoid using puts() since it prints a newline on the host
179 * but does not in U-Boot.
182 * no returned results
184 static void fit_image_print_data(const void *fit, int noffset, const char *p,
195 debug("%s %s node: '%s'\n", p, type,
196 fit_get_name(fit, noffset, NULL));
197 printf("%s %s algo: ", p, type);
198 if (fit_image_hash_get_algo(fit, noffset, &algo)) {
199 printf("invalid/unsupported\n");
203 keyname = fdt_getprop(fit, noffset, FIT_KEY_HINT, NULL);
204 required = fdt_getprop(fit, noffset, FIT_KEY_REQUIRED, NULL) != NULL;
206 printf(":%s", keyname);
208 printf(" (required)");
211 padding = fdt_getprop(fit, noffset, "padding", NULL);
213 printf("%s %s padding: %s\n", p, type, padding);
215 ret = fit_image_hash_get_value(fit, noffset, &value,
217 printf("%s %s value: ", p, type);
219 printf("unavailable\n");
221 for (i = 0; i < value_len; i++)
222 printf("%02x", value[i]);
226 debug("%s %s len: %d\n", p, type, value_len);
228 /* Signatures have a time stamp */
229 if (IMAGE_ENABLE_TIMESTAMP && keyname) {
232 printf("%s Timestamp: ", p);
233 if (fit_get_timestamp(fit, noffset, ×tamp))
234 printf("unavailable\n");
236 genimg_print_time(timestamp);
241 * fit_image_print_verification_data() - prints out the hash/signature details
242 * @fit: pointer to the FIT format image header
243 * @noffset: offset of the hash or signature node
244 * @p: pointer to prefix string
246 * This lists properties for the processed hash node
249 * no returned results
251 static void fit_image_print_verification_data(const void *fit, int noffset,
257 * Check subnode name, must be equal to "hash" or "signature".
258 * Multiple hash/signature nodes require unique unit node
259 * names, e.g. hash-1, hash-2, signature-1, signature-2, etc.
261 name = fit_get_name(fit, noffset, NULL);
262 if (!strncmp(name, FIT_HASH_NODENAME, strlen(FIT_HASH_NODENAME))) {
263 fit_image_print_data(fit, noffset, p, "Hash");
264 } else if (!strncmp(name, FIT_SIG_NODENAME,
265 strlen(FIT_SIG_NODENAME))) {
266 fit_image_print_data(fit, noffset, p, "Sign");
271 * fit_conf_print - prints out the FIT configuration details
272 * @fit: pointer to the FIT format image header
273 * @noffset: offset of the configuration node
274 * @p: pointer to prefix string
276 * fit_conf_print() lists all mandatory properties for the processed
277 * configuration node.
280 * no returned results
282 static void fit_conf_print(const void *fit, int noffset, const char *p)
287 int fdt_index, loadables_index;
290 /* Mandatory properties */
291 ret = fit_get_desc(fit, noffset, &desc);
292 printf("%s Description: ", p);
294 printf("unavailable\n");
296 printf("%s\n", desc);
298 uname = fdt_getprop(fit, noffset, FIT_KERNEL_PROP, NULL);
299 printf("%s Kernel: ", p);
301 printf("unavailable\n");
303 printf("%s\n", uname);
305 /* Optional properties */
306 uname = fdt_getprop(fit, noffset, FIT_RAMDISK_PROP, NULL);
308 printf("%s Init Ramdisk: %s\n", p, uname);
310 uname = fdt_getprop(fit, noffset, FIT_FIRMWARE_PROP, NULL);
312 printf("%s Firmware: %s\n", p, uname);
315 uname = fdt_stringlist_get(fit, noffset, FIT_FDT_PROP,
316 fdt_index, NULL), uname;
319 printf("%s FDT: ", p);
322 printf("%s\n", uname);
325 uname = fdt_getprop(fit, noffset, FIT_FPGA_PROP, NULL);
327 printf("%s FPGA: %s\n", p, uname);
329 /* Print out all of the specified loadables */
330 for (loadables_index = 0;
331 uname = fdt_stringlist_get(fit, noffset, FIT_LOADABLE_PROP,
332 loadables_index, NULL), uname;
334 if (loadables_index == 0) {
335 printf("%s Loadables: ", p);
339 printf("%s\n", uname);
342 /* Process all hash subnodes of the component configuration node */
343 for (ndepth = 0, noffset = fdt_next_node(fit, noffset, &ndepth);
344 (noffset >= 0) && (ndepth > 0);
345 noffset = fdt_next_node(fit, noffset, &ndepth)) {
347 /* Direct child node of the component configuration node */
348 fit_image_print_verification_data(fit, noffset, p);
354 * fit_print_contents - prints out the contents of the FIT format image
355 * @fit: pointer to the FIT format image header
356 * @p: pointer to prefix string
358 * fit_print_contents() formats a multi line FIT image contents description.
359 * The routine prints out FIT image properties (root node level) followed by
360 * the details of each component image.
363 * no returned results
365 void fit_print_contents(const void *fit)
378 /* Indent string is defined in header image.h */
379 p = IMAGE_INDENT_STRING;
381 /* Root node properties */
382 ret = fit_get_desc(fit, 0, &desc);
383 printf("%sFIT description: ", p);
385 printf("unavailable\n");
387 printf("%s\n", desc);
389 if (IMAGE_ENABLE_TIMESTAMP) {
390 ret = fit_get_timestamp(fit, 0, ×tamp);
391 printf("%sCreated: ", p);
393 printf("unavailable\n");
395 genimg_print_time(timestamp);
398 /* Find images parent node offset */
399 images_noffset = fdt_path_offset(fit, FIT_IMAGES_PATH);
400 if (images_noffset < 0) {
401 printf("Can't find images parent node '%s' (%s)\n",
402 FIT_IMAGES_PATH, fdt_strerror(images_noffset));
406 /* Process its subnodes, print out component images details */
407 for (ndepth = 0, count = 0,
408 noffset = fdt_next_node(fit, images_noffset, &ndepth);
409 (noffset >= 0) && (ndepth > 0);
410 noffset = fdt_next_node(fit, noffset, &ndepth)) {
413 * Direct child node of the images parent node,
414 * i.e. component image node.
416 printf("%s Image %u (%s)\n", p, count++,
417 fit_get_name(fit, noffset, NULL));
419 fit_image_print(fit, noffset, p);
423 /* Find configurations parent node offset */
424 confs_noffset = fdt_path_offset(fit, FIT_CONFS_PATH);
425 if (confs_noffset < 0) {
426 debug("Can't get configurations parent node '%s' (%s)\n",
427 FIT_CONFS_PATH, fdt_strerror(confs_noffset));
431 /* get default configuration unit name from default property */
432 uname = (char *)fdt_getprop(fit, noffset, FIT_DEFAULT_PROP, NULL);
434 printf("%s Default Configuration: '%s'\n", p, uname);
436 /* Process its subnodes, print out configurations details */
437 for (ndepth = 0, count = 0,
438 noffset = fdt_next_node(fit, confs_noffset, &ndepth);
439 (noffset >= 0) && (ndepth > 0);
440 noffset = fdt_next_node(fit, noffset, &ndepth)) {
443 * Direct child node of the configurations parent node,
444 * i.e. configuration node.
446 printf("%s Configuration %u (%s)\n", p, count++,
447 fit_get_name(fit, noffset, NULL));
449 fit_conf_print(fit, noffset, p);
455 * fit_image_print - prints out the FIT component image details
456 * @fit: pointer to the FIT format image header
457 * @image_noffset: offset of the component image node
458 * @p: pointer to prefix string
460 * fit_image_print() lists all mandatory properties for the processed component
461 * image. If present, hash nodes are printed out as well. Load
462 * address for images of type firmware is also printed out. Since the load
463 * address is not mandatory for firmware images, it will be output as
464 * "unavailable" when not present.
467 * no returned results
469 void fit_image_print(const void *fit, int image_noffset, const char *p)
472 uint8_t type, arch, os, comp;
480 /* Mandatory properties */
481 ret = fit_get_desc(fit, image_noffset, &desc);
482 printf("%s Description: ", p);
484 printf("unavailable\n");
486 printf("%s\n", desc);
488 if (IMAGE_ENABLE_TIMESTAMP) {
491 ret = fit_get_timestamp(fit, 0, ×tamp);
492 printf("%s Created: ", p);
494 printf("unavailable\n");
496 genimg_print_time(timestamp);
499 fit_image_get_type(fit, image_noffset, &type);
500 printf("%s Type: %s\n", p, genimg_get_type_name(type));
502 fit_image_get_comp(fit, image_noffset, &comp);
503 printf("%s Compression: %s\n", p, genimg_get_comp_name(comp));
505 ret = fit_image_get_data_and_size(fit, image_noffset, &data, &size);
508 printf("%s Data Start: ", p);
510 printf("unavailable\n");
512 void *vdata = (void *)data;
514 printf("0x%08lx\n", (ulong)map_to_sysmem(vdata));
518 printf("%s Data Size: ", p);
520 printf("unavailable\n");
522 genimg_print_size(size);
524 /* Remaining, type dependent properties */
525 if ((type == IH_TYPE_KERNEL) || (type == IH_TYPE_STANDALONE) ||
526 (type == IH_TYPE_RAMDISK) || (type == IH_TYPE_FIRMWARE) ||
527 (type == IH_TYPE_FLATDT)) {
528 fit_image_get_arch(fit, image_noffset, &arch);
529 printf("%s Architecture: %s\n", p, genimg_get_arch_name(arch));
532 if ((type == IH_TYPE_KERNEL) || (type == IH_TYPE_RAMDISK) ||
533 (type == IH_TYPE_FIRMWARE)) {
534 fit_image_get_os(fit, image_noffset, &os);
535 printf("%s OS: %s\n", p, genimg_get_os_name(os));
538 if ((type == IH_TYPE_KERNEL) || (type == IH_TYPE_STANDALONE) ||
539 (type == IH_TYPE_FIRMWARE) || (type == IH_TYPE_RAMDISK) ||
540 (type == IH_TYPE_FPGA)) {
541 ret = fit_image_get_load(fit, image_noffset, &load);
542 printf("%s Load Address: ", p);
544 printf("unavailable\n");
546 printf("0x%08lx\n", load);
549 /* optional load address for FDT */
550 if (type == IH_TYPE_FLATDT && !fit_image_get_load(fit, image_noffset, &load))
551 printf("%s Load Address: 0x%08lx\n", p, load);
553 if ((type == IH_TYPE_KERNEL) || (type == IH_TYPE_STANDALONE) ||
554 (type == IH_TYPE_RAMDISK)) {
555 ret = fit_image_get_entry(fit, image_noffset, &entry);
556 printf("%s Entry Point: ", p);
558 printf("unavailable\n");
560 printf("0x%08lx\n", entry);
563 /* Process all hash subnodes of the component image node */
564 for (ndepth = 0, noffset = fdt_next_node(fit, image_noffset, &ndepth);
565 (noffset >= 0) && (ndepth > 0);
566 noffset = fdt_next_node(fit, noffset, &ndepth)) {
568 /* Direct child node of the component image node */
569 fit_image_print_verification_data(fit, noffset, p);
574 void fit_print_contents(const void *fit) { }
575 void fit_image_print(const void *fit, int image_noffset, const char *p) { }
576 #endif /* CONFIG_IS_ENABLED(FIR_PRINT) || CONFIG_IS_ENABLED(SPL_FIT_PRINT) */
579 * fit_get_desc - get node description property
580 * @fit: pointer to the FIT format image header
581 * @noffset: node offset
582 * @desc: double pointer to the char, will hold pointer to the description
584 * fit_get_desc() reads description property from a given node, if
585 * description is found pointer to it is returned in third call argument.
591 int fit_get_desc(const void *fit, int noffset, char **desc)
595 *desc = (char *)fdt_getprop(fit, noffset, FIT_DESC_PROP, &len);
597 fit_get_debug(fit, noffset, FIT_DESC_PROP, len);
605 * fit_get_timestamp - get node timestamp property
606 * @fit: pointer to the FIT format image header
607 * @noffset: node offset
608 * @timestamp: pointer to the time_t, will hold read timestamp
610 * fit_get_timestamp() reads timestamp property from given node, if timestamp
611 * is found and has a correct size its value is returned in third call
616 * -1, on property read failure
617 * -2, on wrong timestamp size
619 int fit_get_timestamp(const void *fit, int noffset, time_t *timestamp)
624 data = fdt_getprop(fit, noffset, FIT_TIMESTAMP_PROP, &len);
626 fit_get_debug(fit, noffset, FIT_TIMESTAMP_PROP, len);
629 if (len != sizeof(uint32_t)) {
630 debug("FIT timestamp with incorrect size of (%u)\n", len);
634 *timestamp = uimage_to_cpu(*((uint32_t *)data));
639 * fit_image_get_node - get node offset for component image of a given unit name
640 * @fit: pointer to the FIT format image header
641 * @image_uname: component image node unit name
643 * fit_image_get_node() finds a component image (within the '/images'
644 * node) of a provided unit name. If image is found its node offset is
645 * returned to the caller.
648 * image node offset when found (>=0)
649 * negative number on failure (FDT_ERR_* code)
651 int fit_image_get_node(const void *fit, const char *image_uname)
653 int noffset, images_noffset;
655 images_noffset = fdt_path_offset(fit, FIT_IMAGES_PATH);
656 if (images_noffset < 0) {
657 debug("Can't find images parent node '%s' (%s)\n",
658 FIT_IMAGES_PATH, fdt_strerror(images_noffset));
659 return images_noffset;
662 noffset = fdt_subnode_offset(fit, images_noffset, image_uname);
664 debug("Can't get node offset for image unit name: '%s' (%s)\n",
665 image_uname, fdt_strerror(noffset));
672 * fit_image_get_os - get os id for a given component image node
673 * @fit: pointer to the FIT format image header
674 * @noffset: component image node offset
675 * @os: pointer to the uint8_t, will hold os numeric id
677 * fit_image_get_os() finds os property in a given component image node.
678 * If the property is found, its (string) value is translated to the numeric
679 * id which is returned to the caller.
685 int fit_image_get_os(const void *fit, int noffset, uint8_t *os)
690 /* Get OS name from property data */
691 data = fdt_getprop(fit, noffset, FIT_OS_PROP, &len);
693 fit_get_debug(fit, noffset, FIT_OS_PROP, len);
698 /* Translate OS name to id */
699 *os = genimg_get_os_id(data);
704 * fit_image_get_arch - get arch id for a given component image node
705 * @fit: pointer to the FIT format image header
706 * @noffset: component image node offset
707 * @arch: pointer to the uint8_t, will hold arch numeric id
709 * fit_image_get_arch() finds arch property in a given component image node.
710 * If the property is found, its (string) value is translated to the numeric
711 * id which is returned to the caller.
717 int fit_image_get_arch(const void *fit, int noffset, uint8_t *arch)
722 /* Get architecture name from property data */
723 data = fdt_getprop(fit, noffset, FIT_ARCH_PROP, &len);
725 fit_get_debug(fit, noffset, FIT_ARCH_PROP, len);
730 /* Translate architecture name to id */
731 *arch = genimg_get_arch_id(data);
736 * fit_image_get_type - get type id for a given component image node
737 * @fit: pointer to the FIT format image header
738 * @noffset: component image node offset
739 * @type: pointer to the uint8_t, will hold type numeric id
741 * fit_image_get_type() finds type property in a given component image node.
742 * If the property is found, its (string) value is translated to the numeric
743 * id which is returned to the caller.
749 int fit_image_get_type(const void *fit, int noffset, uint8_t *type)
754 /* Get image type name from property data */
755 data = fdt_getprop(fit, noffset, FIT_TYPE_PROP, &len);
757 fit_get_debug(fit, noffset, FIT_TYPE_PROP, len);
762 /* Translate image type name to id */
763 *type = genimg_get_type_id(data);
768 * fit_image_get_comp - get comp id for a given component image node
769 * @fit: pointer to the FIT format image header
770 * @noffset: component image node offset
771 * @comp: pointer to the uint8_t, will hold comp numeric id
773 * fit_image_get_comp() finds comp property in a given component image node.
774 * If the property is found, its (string) value is translated to the numeric
775 * id which is returned to the caller.
781 int fit_image_get_comp(const void *fit, int noffset, uint8_t *comp)
786 /* Get compression name from property data */
787 data = fdt_getprop(fit, noffset, FIT_COMP_PROP, &len);
789 fit_get_debug(fit, noffset, FIT_COMP_PROP, len);
794 /* Translate compression name to id */
795 *comp = genimg_get_comp_id(data);
799 static int fit_image_get_address(const void *fit, int noffset, char *name,
806 cell = fdt_getprop(fit, noffset, name, &len);
808 fit_get_debug(fit, noffset, name, len);
813 /* Use load64 to avoid compiling warning for 32-bit target */
815 load64 = (load64 << 32) | uimage_to_cpu(*cell);
819 if (len > sizeof(ulong) && (uint32_t)(load64 >> 32)) {
820 printf("Unsupported %s address size\n", name);
824 *load = (ulong)load64;
829 * fit_image_get_load() - get load addr property for given component image node
830 * @fit: pointer to the FIT format image header
831 * @noffset: component image node offset
832 * @load: pointer to the uint32_t, will hold load address
834 * fit_image_get_load() finds load address property in a given component
835 * image node. If the property is found, its value is returned to the caller.
841 int fit_image_get_load(const void *fit, int noffset, ulong *load)
843 return fit_image_get_address(fit, noffset, FIT_LOAD_PROP, load);
847 * fit_image_get_entry() - get entry point address property
848 * @fit: pointer to the FIT format image header
849 * @noffset: component image node offset
850 * @entry: pointer to the uint32_t, will hold entry point address
852 * This gets the entry point address property for a given component image
855 * fit_image_get_entry() finds entry point address property in a given
856 * component image node. If the property is found, its value is returned
863 int fit_image_get_entry(const void *fit, int noffset, ulong *entry)
865 return fit_image_get_address(fit, noffset, FIT_ENTRY_PROP, entry);
869 * fit_image_get_data - get data property and its size for a given component image node
870 * @fit: pointer to the FIT format image header
871 * @noffset: component image node offset
872 * @data: double pointer to void, will hold data property's data address
873 * @size: pointer to size_t, will hold data property's data size
875 * fit_image_get_data() finds data property in a given component image node.
876 * If the property is found its data start address and size are returned to
883 int fit_image_get_data(const void *fit, int noffset,
884 const void **data, size_t *size)
888 *data = fdt_getprop(fit, noffset, FIT_DATA_PROP, &len);
890 fit_get_debug(fit, noffset, FIT_DATA_PROP, len);
900 * Get 'data-offset' property from a given image node.
902 * @fit: pointer to the FIT image header
903 * @noffset: component image node offset
904 * @data_offset: holds the data-offset property
908 * -ENOENT if the property could not be found
910 int fit_image_get_data_offset(const void *fit, int noffset, int *data_offset)
914 val = fdt_getprop(fit, noffset, FIT_DATA_OFFSET_PROP, NULL);
918 *data_offset = fdt32_to_cpu(*val);
924 * Get 'data-position' property from a given image node.
926 * @fit: pointer to the FIT image header
927 * @noffset: component image node offset
928 * @data_position: holds the data-position property
932 * -ENOENT if the property could not be found
934 int fit_image_get_data_position(const void *fit, int noffset,
939 val = fdt_getprop(fit, noffset, FIT_DATA_POSITION_PROP, NULL);
943 *data_position = fdt32_to_cpu(*val);
949 * Get 'data-size' property from a given image node.
951 * @fit: pointer to the FIT image header
952 * @noffset: component image node offset
953 * @data_size: holds the data-size property
957 * -ENOENT if the property could not be found
959 int fit_image_get_data_size(const void *fit, int noffset, int *data_size)
963 val = fdt_getprop(fit, noffset, FIT_DATA_SIZE_PROP, NULL);
967 *data_size = fdt32_to_cpu(*val);
973 * Get 'data-size-unciphered' property from a given image node.
975 * @fit: pointer to the FIT image header
976 * @noffset: component image node offset
977 * @data_size: holds the data-size property
981 * -ENOENT if the property could not be found
983 int fit_image_get_data_size_unciphered(const void *fit, int noffset,
988 val = fdt_getprop(fit, noffset, "data-size-unciphered", NULL);
992 *data_size = (size_t)fdt32_to_cpu(*val);
998 * fit_image_get_data_and_size - get data and its size including
999 * both embedded and external data
1000 * @fit: pointer to the FIT format image header
1001 * @noffset: component image node offset
1002 * @data: double pointer to void, will hold data property's data address
1003 * @size: pointer to size_t, will hold data property's data size
1005 * fit_image_get_data_and_size() finds data and its size including
1006 * both embedded and external data. If the property is found
1007 * its data start address and size are returned to the caller.
1011 * otherwise, on failure
1013 int fit_image_get_data_and_size(const void *fit, int noffset,
1014 const void **data, size_t *size)
1016 bool external_data = false;
1021 if (!fit_image_get_data_position(fit, noffset, &offset)) {
1022 external_data = true;
1023 } else if (!fit_image_get_data_offset(fit, noffset, &offset)) {
1024 external_data = true;
1026 * For FIT with external data, figure out where
1027 * the external images start. This is the base
1028 * for the data-offset properties in each image.
1030 offset += ((fdt_totalsize(fit) + 3) & ~3);
1033 if (external_data) {
1034 debug("External Data\n");
1035 ret = fit_image_get_data_size(fit, noffset, &len);
1037 *data = fit + offset;
1041 ret = fit_image_get_data(fit, noffset, data, size);
1048 * fit_image_hash_get_algo - get hash algorithm name
1049 * @fit: pointer to the FIT format image header
1050 * @noffset: hash node offset
1051 * @algo: double pointer to char, will hold pointer to the algorithm name
1053 * fit_image_hash_get_algo() finds hash algorithm property in a given hash node.
1054 * If the property is found its data start address is returned to the caller.
1060 int fit_image_hash_get_algo(const void *fit, int noffset, char **algo)
1064 *algo = (char *)fdt_getprop(fit, noffset, FIT_ALGO_PROP, &len);
1065 if (*algo == NULL) {
1066 fit_get_debug(fit, noffset, FIT_ALGO_PROP, len);
1074 * fit_image_hash_get_value - get hash value and length
1075 * @fit: pointer to the FIT format image header
1076 * @noffset: hash node offset
1077 * @value: double pointer to uint8_t, will hold address of a hash value data
1078 * @value_len: pointer to an int, will hold hash data length
1080 * fit_image_hash_get_value() finds hash value property in a given hash node.
1081 * If the property is found its data start address and size are returned to
1088 int fit_image_hash_get_value(const void *fit, int noffset, uint8_t **value,
1093 *value = (uint8_t *)fdt_getprop(fit, noffset, FIT_VALUE_PROP, &len);
1094 if (*value == NULL) {
1095 fit_get_debug(fit, noffset, FIT_VALUE_PROP, len);
1105 * fit_image_hash_get_ignore - get hash ignore flag
1106 * @fit: pointer to the FIT format image header
1107 * @noffset: hash node offset
1108 * @ignore: pointer to an int, will hold hash ignore flag
1110 * fit_image_hash_get_ignore() finds hash ignore property in a given hash node.
1111 * If the property is found and non-zero, the hash algorithm is not verified by
1112 * u-boot automatically.
1115 * 0, on ignore not found
1116 * value, on ignore found
1118 static int fit_image_hash_get_ignore(const void *fit, int noffset, int *ignore)
1123 value = (int *)fdt_getprop(fit, noffset, FIT_IGNORE_PROP, &len);
1124 if (value == NULL || len != sizeof(int))
1133 * fit_image_cipher_get_algo - get cipher algorithm name
1134 * @fit: pointer to the FIT format image header
1135 * @noffset: cipher node offset
1136 * @algo: double pointer to char, will hold pointer to the algorithm name
1138 * fit_image_cipher_get_algo() finds cipher algorithm property in a given
1139 * cipher node. If the property is found its data start address is returned
1146 int fit_image_cipher_get_algo(const void *fit, int noffset, char **algo)
1150 *algo = (char *)fdt_getprop(fit, noffset, FIT_ALGO_PROP, &len);
1152 fit_get_debug(fit, noffset, FIT_ALGO_PROP, len);
1159 ulong fit_get_end(const void *fit)
1161 return map_to_sysmem((void *)(fit + fdt_totalsize(fit)));
1165 * fit_set_timestamp - set node timestamp property
1166 * @fit: pointer to the FIT format image header
1167 * @noffset: node offset
1168 * @timestamp: timestamp value to be set
1170 * fit_set_timestamp() attempts to set timestamp property in the requested
1171 * node and returns operation status to the caller.
1175 * -ENOSPC if no space in device tree, -1 for other error
1177 int fit_set_timestamp(void *fit, int noffset, time_t timestamp)
1182 t = cpu_to_uimage(timestamp);
1183 ret = fdt_setprop(fit, noffset, FIT_TIMESTAMP_PROP, &t,
1186 debug("Can't set '%s' property for '%s' node (%s)\n",
1187 FIT_TIMESTAMP_PROP, fit_get_name(fit, noffset, NULL),
1189 return ret == -FDT_ERR_NOSPACE ? -ENOSPC : -1;
1196 * calculate_hash - calculate and return hash for provided input data
1197 * @data: pointer to the input data
1198 * @data_len: data length
1199 * @algo: requested hash algorithm
1200 * @value: pointer to the char, will hold hash value data (caller must
1201 * allocate enough free space)
1202 * value_len: length of the calculated hash
1204 * calculate_hash() computes input data hash according to the requested
1206 * Resulting hash value is placed in caller provided 'value' buffer, length
1207 * of the calculated hash is returned via value_len pointer argument.
1211 * -1, when algo is unsupported
1213 int calculate_hash(const void *data, int data_len, const char *algo,
1214 uint8_t *value, int *value_len)
1216 if (IMAGE_ENABLE_CRC32 && strcmp(algo, "crc32") == 0) {
1217 *((uint32_t *)value) = crc32_wd(0, data, data_len,
1219 *((uint32_t *)value) = cpu_to_uimage(*((uint32_t *)value));
1221 } else if (IMAGE_ENABLE_SHA1 && strcmp(algo, "sha1") == 0) {
1222 sha1_csum_wd((unsigned char *)data, data_len,
1223 (unsigned char *)value, CHUNKSZ_SHA1);
1225 } else if (IMAGE_ENABLE_SHA256 && strcmp(algo, "sha256") == 0) {
1226 sha256_csum_wd((unsigned char *)data, data_len,
1227 (unsigned char *)value, CHUNKSZ_SHA256);
1228 *value_len = SHA256_SUM_LEN;
1229 } else if (IMAGE_ENABLE_SHA384 && strcmp(algo, "sha384") == 0) {
1230 sha384_csum_wd((unsigned char *)data, data_len,
1231 (unsigned char *)value, CHUNKSZ_SHA384);
1232 *value_len = SHA384_SUM_LEN;
1233 } else if (IMAGE_ENABLE_SHA512 && strcmp(algo, "sha512") == 0) {
1234 sha512_csum_wd((unsigned char *)data, data_len,
1235 (unsigned char *)value, CHUNKSZ_SHA512);
1236 *value_len = SHA512_SUM_LEN;
1237 } else if (IMAGE_ENABLE_MD5 && strcmp(algo, "md5") == 0) {
1238 md5_wd((unsigned char *)data, data_len, value, CHUNKSZ_MD5);
1241 debug("Unsupported hash alogrithm\n");
1247 static int fit_image_check_hash(const void *fit, int noffset, const void *data,
1248 size_t size, char **err_msgp)
1250 uint8_t value[FIT_MAX_HASH_LEN];
1259 if (fit_image_hash_get_algo(fit, noffset, &algo)) {
1260 *err_msgp = "Can't get hash algo property";
1265 if (IMAGE_ENABLE_IGNORE) {
1266 fit_image_hash_get_ignore(fit, noffset, &ignore);
1268 printf("-skipped ");
1273 if (fit_image_hash_get_value(fit, noffset, &fit_value,
1275 *err_msgp = "Can't get hash value property";
1279 if (calculate_hash(data, size, algo, value, &value_len)) {
1280 *err_msgp = "Unsupported hash algorithm";
1284 if (value_len != fit_value_len) {
1285 *err_msgp = "Bad hash value len";
1287 } else if (memcmp(value, fit_value, value_len) != 0) {
1288 *err_msgp = "Bad hash value";
1295 int fit_image_verify_with_data(const void *fit, int image_noffset,
1296 const void *data, size_t size)
1303 /* Verify all required signatures */
1304 if (FIT_IMAGE_ENABLE_VERIFY &&
1305 fit_image_verify_required_sigs(fit, image_noffset, data, size,
1306 gd_fdt_blob(), &verify_all)) {
1307 err_msg = "Unable to verify required signature";
1311 /* Process all hash subnodes of the component image node */
1312 fdt_for_each_subnode(noffset, fit, image_noffset) {
1313 const char *name = fit_get_name(fit, noffset, NULL);
1316 * Check subnode name, must be equal to "hash".
1317 * Multiple hash nodes require unique unit node
1318 * names, e.g. hash-1, hash-2, etc.
1320 if (!strncmp(name, FIT_HASH_NODENAME,
1321 strlen(FIT_HASH_NODENAME))) {
1322 if (fit_image_check_hash(fit, noffset, data, size,
1326 } else if (FIT_IMAGE_ENABLE_VERIFY && verify_all &&
1327 !strncmp(name, FIT_SIG_NODENAME,
1328 strlen(FIT_SIG_NODENAME))) {
1329 ret = fit_image_check_sig(fit, noffset, data,
1330 size, -1, &err_msg);
1333 * Show an indication on failure, but do not return
1334 * an error. Only keys marked 'required' can cause
1335 * an image validation failure. See the call to
1336 * fit_image_verify_required_sigs() above.
1345 if (noffset == -FDT_ERR_TRUNCATED || noffset == -FDT_ERR_BADSTRUCTURE) {
1346 err_msg = "Corrupted or truncated tree";
1353 printf(" error!\n%s for '%s' hash node in '%s' image node\n",
1354 err_msg, fit_get_name(fit, noffset, NULL),
1355 fit_get_name(fit, image_noffset, NULL));
1360 * fit_image_verify - verify data integrity
1361 * @fit: pointer to the FIT format image header
1362 * @image_noffset: component image node offset
1364 * fit_image_verify() goes over component image hash nodes,
1365 * re-calculates each data hash and compares with the value stored in hash
1369 * 1, if all hashes are valid
1370 * 0, otherwise (or on error)
1372 int fit_image_verify(const void *fit, int image_noffset)
1374 const char *name = fit_get_name(fit, image_noffset, NULL);
1379 if (strchr(name, '@')) {
1381 * We don't support this since libfdt considers names with the
1382 * name root but different @ suffix to be equal
1384 err_msg = "Node name contains @";
1387 /* Get image data and data length */
1388 if (fit_image_get_data_and_size(fit, image_noffset, &data, &size)) {
1389 err_msg = "Can't get image data/size";
1393 return fit_image_verify_with_data(fit, image_noffset, data, size);
1396 printf("error!\n%s in '%s' image node\n", err_msg,
1397 fit_get_name(fit, image_noffset, NULL));
1402 * fit_all_image_verify - verify data integrity for all images
1403 * @fit: pointer to the FIT format image header
1405 * fit_all_image_verify() goes over all images in the FIT and
1406 * for every images checks if all it's hashes are valid.
1409 * 1, if all hashes of all images are valid
1410 * 0, otherwise (or on error)
1412 int fit_all_image_verify(const void *fit)
1419 /* Find images parent node offset */
1420 images_noffset = fdt_path_offset(fit, FIT_IMAGES_PATH);
1421 if (images_noffset < 0) {
1422 printf("Can't find images parent node '%s' (%s)\n",
1423 FIT_IMAGES_PATH, fdt_strerror(images_noffset));
1427 /* Process all image subnodes, check hashes for each */
1428 printf("## Checking hash(es) for FIT Image at %08lx ...\n",
1430 for (ndepth = 0, count = 0,
1431 noffset = fdt_next_node(fit, images_noffset, &ndepth);
1432 (noffset >= 0) && (ndepth > 0);
1433 noffset = fdt_next_node(fit, noffset, &ndepth)) {
1436 * Direct child node of the images parent node,
1437 * i.e. component image node.
1439 printf(" Hash(es) for Image %u (%s): ", count,
1440 fit_get_name(fit, noffset, NULL));
1443 if (!fit_image_verify(fit, noffset))
1451 static int fit_image_uncipher(const void *fit, int image_noffset,
1452 void **data, size_t *size)
1454 int cipher_noffset, ret;
1458 cipher_noffset = fdt_subnode_offset(fit, image_noffset,
1459 FIT_CIPHER_NODENAME);
1460 if (cipher_noffset < 0)
1463 ret = fit_image_decrypt_data(fit, image_noffset, cipher_noffset,
1464 *data, *size, &dst, &size_dst);
1476 * fit_image_check_os - check whether image node is of a given os type
1477 * @fit: pointer to the FIT format image header
1478 * @noffset: component image node offset
1479 * @os: requested image os
1481 * fit_image_check_os() reads image os property and compares its numeric
1482 * id with the requested os. Comparison result is returned to the caller.
1485 * 1 if image is of given os type
1486 * 0 otherwise (or on error)
1488 int fit_image_check_os(const void *fit, int noffset, uint8_t os)
1492 if (fit_image_get_os(fit, noffset, &image_os))
1494 return (os == image_os);
1498 * fit_image_check_arch - check whether image node is of a given arch
1499 * @fit: pointer to the FIT format image header
1500 * @noffset: component image node offset
1501 * @arch: requested imagearch
1503 * fit_image_check_arch() reads image arch property and compares its numeric
1504 * id with the requested arch. Comparison result is returned to the caller.
1507 * 1 if image is of given arch
1508 * 0 otherwise (or on error)
1510 int fit_image_check_arch(const void *fit, int noffset, uint8_t arch)
1513 int aarch32_support = 0;
1515 /* Let's assume that sandbox can load any architecture */
1516 if (IS_ENABLED(CONFIG_SANDBOX))
1519 if (IS_ENABLED(CONFIG_ARM64_SUPPORT_AARCH32))
1520 aarch32_support = 1;
1522 if (fit_image_get_arch(fit, noffset, &image_arch))
1524 return (arch == image_arch) ||
1525 (arch == IH_ARCH_I386 && image_arch == IH_ARCH_X86_64) ||
1526 (arch == IH_ARCH_ARM64 && image_arch == IH_ARCH_ARM &&
1531 * fit_image_check_type - check whether image node is of a given type
1532 * @fit: pointer to the FIT format image header
1533 * @noffset: component image node offset
1534 * @type: requested image type
1536 * fit_image_check_type() reads image type property and compares its numeric
1537 * id with the requested type. Comparison result is returned to the caller.
1540 * 1 if image is of given type
1541 * 0 otherwise (or on error)
1543 int fit_image_check_type(const void *fit, int noffset, uint8_t type)
1547 if (fit_image_get_type(fit, noffset, &image_type))
1549 return (type == image_type);
1553 * fit_image_check_comp - check whether image node uses given compression
1554 * @fit: pointer to the FIT format image header
1555 * @noffset: component image node offset
1556 * @comp: requested image compression type
1558 * fit_image_check_comp() reads image compression property and compares its
1559 * numeric id with the requested compression type. Comparison result is
1560 * returned to the caller.
1563 * 1 if image uses requested compression
1564 * 0 otherwise (or on error)
1566 int fit_image_check_comp(const void *fit, int noffset, uint8_t comp)
1570 if (fit_image_get_comp(fit, noffset, &image_comp))
1572 return (comp == image_comp);
1576 * fdt_check_no_at() - Check for nodes whose names contain '@'
1578 * This checks the parent node and all subnodes recursively
1580 * @fit: FIT to check
1581 * @parent: Parent node to check
1582 * @return 0 if OK, -EADDRNOTAVAIL is a node has a name containing '@'
1584 static int fdt_check_no_at(const void *fit, int parent)
1590 name = fdt_get_name(fit, parent, NULL);
1591 if (!name || strchr(name, '@'))
1592 return -EADDRNOTAVAIL;
1594 fdt_for_each_subnode(node, fit, parent) {
1595 ret = fdt_check_no_at(fit, node);
1603 int fit_check_format(const void *fit, ulong size)
1607 /* A FIT image must be a valid FDT */
1608 ret = fdt_check_header(fit);
1610 log_debug("Wrong FIT format: not a flattened device tree (err=%d)\n",
1615 if (CONFIG_IS_ENABLED(FIT_FULL_CHECK)) {
1617 * If we are not given the size, make do wtih calculating it.
1618 * This is not as secure, so we should consider a flag to
1621 if (size == IMAGE_SIZE_INVAL)
1622 size = fdt_totalsize(fit);
1623 ret = fdt_check_full(fit, size);
1628 * U-Boot stopped using unit addressed in 2017. Since libfdt
1629 * can match nodes ignoring any unit address, signature
1630 * verification can see the wrong node if one is inserted with
1631 * the same name as a valid node but with a unit address
1632 * attached. Protect against this by disallowing unit addresses.
1634 if (!ret && CONFIG_IS_ENABLED(FIT_SIGNATURE)) {
1635 ret = fdt_check_no_at(fit, 0);
1638 log_debug("FIT check error %d\n", ret);
1643 log_debug("FIT check error %d\n", ret);
1648 /* mandatory / node 'description' property */
1649 if (!fdt_getprop(fit, 0, FIT_DESC_PROP, NULL)) {
1650 log_debug("Wrong FIT format: no description\n");
1654 if (IMAGE_ENABLE_TIMESTAMP) {
1655 /* mandatory / node 'timestamp' property */
1656 if (!fdt_getprop(fit, 0, FIT_TIMESTAMP_PROP, NULL)) {
1657 log_debug("Wrong FIT format: no timestamp\n");
1662 /* mandatory subimages parent '/images' node */
1663 if (fdt_path_offset(fit, FIT_IMAGES_PATH) < 0) {
1664 log_debug("Wrong FIT format: no images parent node\n");
1672 * fit_conf_find_compat
1673 * @fit: pointer to the FIT format image header
1674 * @fdt: pointer to the device tree to compare against
1676 * fit_conf_find_compat() attempts to find the configuration whose fdt is the
1677 * most compatible with the passed in device tree.
1686 * |-o configurations
1694 * |-compatible = "foo,bar", "bim,bam"
1697 * |-compatible = "foo,bar",
1700 * |-compatible = "bim,bam", "baz,biz"
1702 * Configuration 1 would be picked because the first string in U-Boot's
1703 * compatible list, "foo,bar", matches a compatible string in the root of fdt1.
1704 * "bim,bam" in fdt2 matches the second string which isn't as good as fdt1.
1706 * As an optimization, the compatible property from the FDT's root node can be
1707 * copied into the configuration node in the FIT image. This is required to
1708 * match configurations with compressed FDTs.
1711 * offset to the configuration to use if one was found
1714 int fit_conf_find_compat(const void *fit, const void *fdt)
1717 int noffset, confs_noffset, images_noffset;
1718 const void *fdt_compat;
1720 int best_match_offset = 0;
1721 int best_match_pos = 0;
1723 confs_noffset = fdt_path_offset(fit, FIT_CONFS_PATH);
1724 images_noffset = fdt_path_offset(fit, FIT_IMAGES_PATH);
1725 if (confs_noffset < 0 || images_noffset < 0) {
1726 debug("Can't find configurations or images nodes.\n");
1730 fdt_compat = fdt_getprop(fdt, 0, "compatible", &fdt_compat_len);
1732 debug("Fdt for comparison has no \"compatible\" property.\n");
1737 * Loop over the configurations in the FIT image.
1739 for (noffset = fdt_next_node(fit, confs_noffset, &ndepth);
1740 (noffset >= 0) && (ndepth > 0);
1741 noffset = fdt_next_node(fit, noffset, &ndepth)) {
1743 const char *kfdt_name;
1744 int kfdt_noffset, compat_noffset;
1745 const char *cur_fdt_compat;
1753 /* If there's a compat property in the config node, use that. */
1754 if (fdt_getprop(fit, noffset, "compatible", NULL)) {
1755 fdt = fit; /* search in FIT image */
1756 compat_noffset = noffset; /* search under config node */
1757 } else { /* Otherwise extract it from the kernel FDT. */
1758 kfdt_name = fdt_getprop(fit, noffset, "fdt", &len);
1760 debug("No fdt property found.\n");
1763 kfdt_noffset = fdt_subnode_offset(fit, images_noffset,
1765 if (kfdt_noffset < 0) {
1766 debug("No image node named \"%s\" found.\n",
1771 if (!fit_image_check_comp(fit, kfdt_noffset,
1773 debug("Can't extract compat from \"%s\" "
1774 "(compressed)\n", kfdt_name);
1778 /* search in this config's kernel FDT */
1779 if (fit_image_get_data(fit, kfdt_noffset, &fdt, &sz)) {
1780 debug("Failed to get fdt \"%s\".\n", kfdt_name);
1784 compat_noffset = 0; /* search kFDT under root node */
1787 len = fdt_compat_len;
1788 cur_fdt_compat = fdt_compat;
1790 * Look for a match for each U-Boot compatibility string in
1791 * turn in the compat string property.
1793 for (i = 0; len > 0 &&
1794 (!best_match_offset || best_match_pos > i); i++) {
1795 int cur_len = strlen(cur_fdt_compat) + 1;
1797 if (!fdt_node_check_compatible(fdt, compat_noffset,
1799 best_match_offset = noffset;
1804 cur_fdt_compat += cur_len;
1807 if (!best_match_offset) {
1808 debug("No match found.\n");
1812 return best_match_offset;
1815 int fit_conf_get_node(const void *fit, const char *conf_uname)
1817 int noffset, confs_noffset;
1820 char *conf_uname_copy = NULL;
1822 confs_noffset = fdt_path_offset(fit, FIT_CONFS_PATH);
1823 if (confs_noffset < 0) {
1824 debug("Can't find configurations parent node '%s' (%s)\n",
1825 FIT_CONFS_PATH, fdt_strerror(confs_noffset));
1826 return confs_noffset;
1829 if (conf_uname == NULL) {
1830 /* get configuration unit name from the default property */
1831 debug("No configuration specified, trying default...\n");
1832 if (!host_build() && IS_ENABLED(CONFIG_MULTI_DTB_FIT)) {
1833 noffset = fit_find_config_node(fit);
1836 conf_uname = fdt_get_name(fit, noffset, NULL);
1838 conf_uname = (char *)fdt_getprop(fit, confs_noffset,
1839 FIT_DEFAULT_PROP, &len);
1840 if (conf_uname == NULL) {
1841 fit_get_debug(fit, confs_noffset, FIT_DEFAULT_PROP,
1846 debug("Found default configuration: '%s'\n", conf_uname);
1849 s = strchr(conf_uname, '#');
1851 len = s - conf_uname;
1852 conf_uname_copy = malloc(len + 1);
1853 if (!conf_uname_copy) {
1854 debug("Can't allocate uname copy: '%s'\n",
1858 memcpy(conf_uname_copy, conf_uname, len);
1859 conf_uname_copy[len] = '\0';
1860 conf_uname = conf_uname_copy;
1863 noffset = fdt_subnode_offset(fit, confs_noffset, conf_uname);
1865 debug("Can't get node offset for configuration unit name: '%s' (%s)\n",
1866 conf_uname, fdt_strerror(noffset));
1869 if (conf_uname_copy)
1870 free(conf_uname_copy);
1875 int fit_conf_get_prop_node_count(const void *fit, int noffset,
1876 const char *prop_name)
1878 return fdt_stringlist_count(fit, noffset, prop_name);
1881 int fit_conf_get_prop_node_index(const void *fit, int noffset,
1882 const char *prop_name, int index)
1887 /* get kernel image unit name from configuration kernel property */
1888 uname = fdt_stringlist_get(fit, noffset, prop_name, index, &len);
1892 return fit_image_get_node(fit, uname);
1895 int fit_conf_get_prop_node(const void *fit, int noffset,
1896 const char *prop_name)
1898 return fit_conf_get_prop_node_index(fit, noffset, prop_name, 0);
1901 static int fit_image_select(const void *fit, int rd_noffset, int verify)
1903 fit_image_print(fit, rd_noffset, " ");
1906 puts(" Verifying Hash Integrity ... ");
1907 if (!fit_image_verify(fit, rd_noffset)) {
1908 puts("Bad Data Hash\n");
1917 int fit_get_node_from_config(bootm_headers_t *images, const char *prop_name,
1924 debug("* %s: using config '%s' from image at 0x%08lx\n",
1925 prop_name, images->fit_uname_cfg, addr);
1927 /* Check whether configuration has this property defined */
1928 fit_hdr = map_sysmem(addr, 0);
1929 cfg_noffset = fit_conf_get_node(fit_hdr, images->fit_uname_cfg);
1930 if (cfg_noffset < 0) {
1931 debug("* %s: no such config\n", prop_name);
1935 noffset = fit_conf_get_prop_node(fit_hdr, cfg_noffset, prop_name);
1937 debug("* %s: no '%s' in config\n", prop_name, prop_name);
1945 * fit_get_image_type_property() - get property name for IH_TYPE_...
1947 * @return the properly name where we expect to find the image in the
1950 static const char *fit_get_image_type_property(int type)
1953 * This is sort-of available in the uimage_type[] table in image.c
1954 * but we don't have access to the short name, and "fdt" is different
1955 * anyway. So let's just keep it here.
1958 case IH_TYPE_FLATDT:
1959 return FIT_FDT_PROP;
1960 case IH_TYPE_KERNEL:
1961 return FIT_KERNEL_PROP;
1962 case IH_TYPE_RAMDISK:
1963 return FIT_RAMDISK_PROP;
1964 case IH_TYPE_X86_SETUP:
1965 return FIT_SETUP_PROP;
1966 case IH_TYPE_LOADABLE:
1967 return FIT_LOADABLE_PROP;
1969 return FIT_FPGA_PROP;
1970 case IH_TYPE_STANDALONE:
1971 return FIT_STANDALONE_PROP;
1977 int fit_image_load(bootm_headers_t *images, ulong addr,
1978 const char **fit_unamep, const char **fit_uname_configp,
1979 int arch, int image_type, int bootstage_id,
1980 enum fit_load_op load_op, ulong *datap, ulong *lenp)
1982 int cfg_noffset, noffset;
1983 const char *fit_uname;
1984 const char *fit_uname_config;
1985 const char *fit_base_uname_config;
1991 ulong load, load_end, data, len;
1996 const char *prop_name;
1999 fit = map_sysmem(addr, 0);
2000 fit_uname = fit_unamep ? *fit_unamep : NULL;
2001 fit_uname_config = fit_uname_configp ? *fit_uname_configp : NULL;
2002 fit_base_uname_config = NULL;
2003 prop_name = fit_get_image_type_property(image_type);
2004 printf("## Loading %s from FIT Image at %08lx ...\n", prop_name, addr);
2006 bootstage_mark(bootstage_id + BOOTSTAGE_SUB_FORMAT);
2007 ret = fit_check_format(fit, IMAGE_SIZE_INVAL);
2009 printf("Bad FIT %s image format! (err=%d)\n", prop_name, ret);
2010 if (CONFIG_IS_ENABLED(FIT_SIGNATURE) && ret == -EADDRNOTAVAIL)
2011 printf("Signature checking prevents use of unit addresses (@) in nodes\n");
2012 bootstage_error(bootstage_id + BOOTSTAGE_SUB_FORMAT);
2015 bootstage_mark(bootstage_id + BOOTSTAGE_SUB_FORMAT_OK);
2017 /* get FIT component image node offset */
2018 bootstage_mark(bootstage_id + BOOTSTAGE_SUB_UNIT_NAME);
2019 noffset = fit_image_get_node(fit, fit_uname);
2022 * no image node unit name, try to get config
2023 * node first. If config unit node name is NULL
2024 * fit_conf_get_node() will try to find default config node
2026 bootstage_mark(bootstage_id + BOOTSTAGE_SUB_NO_UNIT_NAME);
2027 if (IMAGE_ENABLE_BEST_MATCH && !fit_uname_config) {
2028 cfg_noffset = fit_conf_find_compat(fit, gd_fdt_blob());
2030 cfg_noffset = fit_conf_get_node(fit,
2033 if (cfg_noffset < 0) {
2034 puts("Could not find configuration node\n");
2035 bootstage_error(bootstage_id +
2036 BOOTSTAGE_SUB_NO_UNIT_NAME);
2040 fit_base_uname_config = fdt_get_name(fit, cfg_noffset, NULL);
2041 printf(" Using '%s' configuration\n", fit_base_uname_config);
2042 /* Remember this config */
2043 if (image_type == IH_TYPE_KERNEL)
2044 images->fit_uname_cfg = fit_base_uname_config;
2046 if (FIT_IMAGE_ENABLE_VERIFY && images->verify) {
2047 puts(" Verifying Hash Integrity ... ");
2048 if (fit_config_verify(fit, cfg_noffset)) {
2049 puts("Bad Data Hash\n");
2050 bootstage_error(bootstage_id +
2051 BOOTSTAGE_SUB_HASH);
2057 bootstage_mark(BOOTSTAGE_ID_FIT_CONFIG);
2059 noffset = fit_conf_get_prop_node(fit, cfg_noffset,
2061 fit_uname = fit_get_name(fit, noffset, NULL);
2064 printf("Could not find subimage node type '%s'\n", prop_name);
2065 bootstage_error(bootstage_id + BOOTSTAGE_SUB_SUBNODE);
2069 printf(" Trying '%s' %s subimage\n", fit_uname, prop_name);
2071 ret = fit_image_select(fit, noffset, images->verify);
2073 bootstage_error(bootstage_id + BOOTSTAGE_SUB_HASH);
2077 bootstage_mark(bootstage_id + BOOTSTAGE_SUB_CHECK_ARCH);
2078 if (!host_build() && IS_ENABLED(CONFIG_SANDBOX)) {
2079 if (!fit_image_check_target_arch(fit, noffset)) {
2080 puts("Unsupported Architecture\n");
2081 bootstage_error(bootstage_id + BOOTSTAGE_SUB_CHECK_ARCH);
2087 fit_image_get_arch(fit, noffset, &os_arch);
2088 images->os.arch = os_arch;
2091 bootstage_mark(bootstage_id + BOOTSTAGE_SUB_CHECK_ALL);
2092 type_ok = fit_image_check_type(fit, noffset, image_type) ||
2093 fit_image_check_type(fit, noffset, IH_TYPE_FIRMWARE) ||
2094 (image_type == IH_TYPE_KERNEL &&
2095 fit_image_check_type(fit, noffset, IH_TYPE_KERNEL_NOLOAD));
2097 os_ok = image_type == IH_TYPE_FLATDT ||
2098 image_type == IH_TYPE_FPGA ||
2099 fit_image_check_os(fit, noffset, IH_OS_LINUX) ||
2100 fit_image_check_os(fit, noffset, IH_OS_U_BOOT) ||
2101 fit_image_check_os(fit, noffset, IH_OS_OPENRTOS) ||
2102 fit_image_check_os(fit, noffset, IH_OS_EFI) ||
2103 fit_image_check_os(fit, noffset, IH_OS_VXWORKS);
2106 * If either of the checks fail, we should report an error, but
2107 * if the image type is coming from the "loadables" field, we
2108 * don't care what it is
2110 if ((!type_ok || !os_ok) && image_type != IH_TYPE_LOADABLE) {
2111 fit_image_get_os(fit, noffset, &os);
2112 printf("No %s %s %s Image\n",
2113 genimg_get_os_name(os),
2114 genimg_get_arch_name(arch),
2115 genimg_get_type_name(image_type));
2116 bootstage_error(bootstage_id + BOOTSTAGE_SUB_CHECK_ALL);
2120 bootstage_mark(bootstage_id + BOOTSTAGE_SUB_CHECK_ALL_OK);
2122 /* get image data address and length */
2123 if (fit_image_get_data_and_size(fit, noffset,
2124 (const void **)&buf, &size)) {
2125 printf("Could not find %s subimage data!\n", prop_name);
2126 bootstage_error(bootstage_id + BOOTSTAGE_SUB_GET_DATA);
2130 /* Decrypt data before uncompress/move */
2131 if (IS_ENABLED(CONFIG_FIT_CIPHER) && IMAGE_ENABLE_DECRYPT) {
2132 puts(" Decrypting Data ... ");
2133 if (fit_image_uncipher(fit, noffset, &buf, &size)) {
2140 /* perform any post-processing on the image data */
2141 if (!host_build() && IS_ENABLED(CONFIG_FIT_IMAGE_POST_PROCESS))
2142 board_fit_image_post_process(&buf, &size);
2146 bootstage_mark(bootstage_id + BOOTSTAGE_SUB_GET_DATA_OK);
2148 data = map_to_sysmem(buf);
2150 if (load_op == FIT_LOAD_IGNORED) {
2152 } else if (fit_image_get_load(fit, noffset, &load)) {
2153 if (load_op == FIT_LOAD_REQUIRED) {
2154 printf("Can't get %s subimage load address!\n",
2156 bootstage_error(bootstage_id + BOOTSTAGE_SUB_LOAD);
2159 } else if (load_op != FIT_LOAD_OPTIONAL_NON_ZERO || load) {
2160 ulong image_start, image_end;
2163 * move image data to the load address,
2164 * make sure we don't overwrite initial image
2167 image_end = addr + fit_get_size(fit);
2169 load_end = load + len;
2170 if (image_type != IH_TYPE_KERNEL &&
2171 load < image_end && load_end > image_start) {
2172 printf("Error: %s overwritten\n", prop_name);
2176 printf(" Loading %s from 0x%08lx to 0x%08lx\n",
2177 prop_name, data, load);
2179 load = data; /* No load address specified */
2182 comp = IH_COMP_NONE;
2184 /* Kernel images get decompressed later in bootm_load_os(). */
2185 if (!fit_image_get_comp(fit, noffset, &comp) &&
2186 comp != IH_COMP_NONE &&
2187 !(image_type == IH_TYPE_KERNEL ||
2188 image_type == IH_TYPE_KERNEL_NOLOAD ||
2189 image_type == IH_TYPE_RAMDISK)) {
2190 ulong max_decomp_len = len * 20;
2192 loadbuf = malloc(max_decomp_len);
2193 load = map_to_sysmem(loadbuf);
2195 loadbuf = map_sysmem(load, max_decomp_len);
2197 if (image_decomp(comp, load, data, image_type,
2198 loadbuf, buf, len, max_decomp_len, &load_end)) {
2199 printf("Error decompressing %s\n", prop_name);
2203 len = load_end - load;
2204 } else if (load != data) {
2205 loadbuf = map_sysmem(load, len);
2206 memcpy(loadbuf, buf, len);
2209 if (image_type == IH_TYPE_RAMDISK && comp != IH_COMP_NONE)
2210 puts("WARNING: 'compression' nodes for ramdisks are deprecated,"
2211 " please fix your .its file!\n");
2213 /* verify that image data is a proper FDT blob */
2214 if (image_type == IH_TYPE_FLATDT && fdt_check_header(loadbuf)) {
2215 puts("Subimage data is not a FDT");
2219 bootstage_mark(bootstage_id + BOOTSTAGE_SUB_LOAD);
2224 *fit_unamep = (char *)fit_uname;
2225 if (fit_uname_configp)
2226 *fit_uname_configp = (char *)(fit_uname_config ? :
2227 fit_base_uname_config);
2232 int boot_get_setup_fit(bootm_headers_t *images, uint8_t arch,
2233 ulong *setup_start, ulong *setup_len)
2240 addr = map_to_sysmem(images->fit_hdr_os);
2241 noffset = fit_get_node_from_config(images, FIT_SETUP_PROP, addr);
2245 ret = fit_image_load(images, addr, NULL, NULL, arch,
2246 IH_TYPE_X86_SETUP, BOOTSTAGE_ID_FIT_SETUP_START,
2247 FIT_LOAD_REQUIRED, setup_start, &len);
2253 int boot_get_fdt_fit(bootm_headers_t *images, ulong addr,
2254 const char **fit_unamep, const char **fit_uname_configp,
2255 int arch, ulong *datap, ulong *lenp)
2257 int fdt_noffset, cfg_noffset, count;
2259 const char *fit_uname = NULL;
2260 const char *fit_uname_config = NULL;
2261 char *fit_uname_config_copy = NULL;
2262 char *next_config = NULL;
2264 #ifdef CONFIG_OF_LIBFDT_OVERLAY
2265 ulong image_start, image_end;
2266 ulong ovload, ovlen;
2267 const char *uconfig;
2270 int i, err, noffset, ov_noffset;
2273 fit_uname = fit_unamep ? *fit_unamep : NULL;
2275 if (fit_uname_configp && *fit_uname_configp) {
2276 fit_uname_config_copy = strdup(*fit_uname_configp);
2277 if (!fit_uname_config_copy)
2280 next_config = strchr(fit_uname_config_copy, '#');
2282 *next_config++ = '\0';
2283 if (next_config - 1 > fit_uname_config_copy)
2284 fit_uname_config = fit_uname_config_copy;
2287 fdt_noffset = fit_image_load(images,
2288 addr, &fit_uname, &fit_uname_config,
2289 arch, IH_TYPE_FLATDT,
2290 BOOTSTAGE_ID_FIT_FDT_START,
2291 FIT_LOAD_OPTIONAL, &load, &len);
2293 if (fdt_noffset < 0)
2296 debug("fit_uname=%s, fit_uname_config=%s\n",
2297 fit_uname ? fit_uname : "<NULL>",
2298 fit_uname_config ? fit_uname_config : "<NULL>");
2300 fit = map_sysmem(addr, 0);
2302 cfg_noffset = fit_conf_get_node(fit, fit_uname_config);
2304 /* single blob, or error just return as well */
2305 count = fit_conf_get_prop_node_count(fit, cfg_noffset, FIT_FDT_PROP);
2306 if (count <= 1 && !next_config)
2309 /* we need to apply overlays */
2311 #ifdef CONFIG_OF_LIBFDT_OVERLAY
2313 image_end = addr + fit_get_size(fit);
2314 /* verify that relocation took place by load address not being in fit */
2315 if (load >= image_start && load < image_end) {
2316 /* check is simplified; fit load checks for overlaps */
2317 printf("Overlayed FDT requires relocation\n");
2318 fdt_noffset = -EBADF;
2322 base = map_sysmem(load, len);
2324 /* apply extra configs in FIT first, followed by args */
2325 for (i = 1; ; i++) {
2327 noffset = fit_conf_get_prop_node_index(fit, cfg_noffset,
2329 uname = fit_get_name(fit, noffset, NULL);
2334 uconfig = next_config;
2335 next_config = strchr(next_config, '#');
2337 *next_config++ = '\0';
2341 * fit_image_load() would load the first FDT from the
2342 * extra config only when uconfig is specified.
2343 * Check if the extra config contains multiple FDTs and
2346 cfg_noffset = fit_conf_get_node(fit, uconfig);
2349 count = fit_conf_get_prop_node_count(fit, cfg_noffset,
2353 debug("%d: using uname=%s uconfig=%s\n", i, uname, uconfig);
2355 ov_noffset = fit_image_load(images,
2356 addr, &uname, &uconfig,
2357 arch, IH_TYPE_FLATDT,
2358 BOOTSTAGE_ID_FIT_FDT_START,
2359 FIT_LOAD_REQUIRED, &ovload, &ovlen);
2360 if (ov_noffset < 0) {
2361 printf("load of %s failed\n", uname);
2364 debug("%s loaded at 0x%08lx len=0x%08lx\n",
2365 uname, ovload, ovlen);
2366 ov = map_sysmem(ovload, ovlen);
2368 base = map_sysmem(load, len + ovlen);
2369 err = fdt_open_into(base, base, len + ovlen);
2371 printf("failed on fdt_open_into\n");
2375 /* the verbose method prints out messages on error */
2376 err = fdt_overlay_apply_verbose(base, ov);
2382 len = fdt_totalsize(base);
2385 printf("config with overlays but CONFIG_OF_LIBFDT_OVERLAY not set\n");
2386 fdt_noffset = -EBADF;
2395 *fit_unamep = fit_uname;
2396 if (fit_uname_configp)
2397 *fit_uname_configp = fit_uname_config;
2399 if (fit_uname_config_copy)
2400 free(fit_uname_config_copy);