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.
14 #include <linux/libfdt.h>
15 #include <u-boot/crc.h>
17 #include <linux/compiler.h>
24 DECLARE_GLOBAL_DATA_PTR;
25 #endif /* !USE_HOSTCC*/
29 #include <bootstage.h>
30 #include <linux/kconfig.h>
31 #include <u-boot/crc.h>
32 #include <u-boot/md5.h>
33 #include <u-boot/sha1.h>
34 #include <u-boot/sha256.h>
35 #include <u-boot/sha512.h>
37 /*****************************************************************************/
38 /* New uImage format routines */
39 /*****************************************************************************/
41 static int fit_parse_spec(const char *spec, char sepc, ulong addr_curr,
42 ulong *addr, const char **name)
49 sep = strchr(spec, sepc);
52 *addr = simple_strtoul(spec, NULL, 16);
62 * fit_parse_conf - parse FIT configuration spec
63 * @spec: input string, containing configuration spec
64 * @add_curr: current image address (to be used as a possible default)
65 * @addr: pointer to a ulong variable, will hold FIT image address of a given
67 * @conf_name double pointer to a char, will hold pointer to a configuration
70 * fit_parse_conf() expects configuration spec in the form of [<addr>]#<conf>,
71 * where <addr> is a FIT image address that contains configuration
72 * with a <conf> unit name.
74 * Address part is optional, and if omitted default add_curr will
78 * 1 if spec is a valid configuration string,
79 * addr and conf_name are set accordingly
82 int fit_parse_conf(const char *spec, ulong addr_curr,
83 ulong *addr, const char **conf_name)
85 return fit_parse_spec(spec, '#', addr_curr, addr, conf_name);
89 * fit_parse_subimage - parse FIT subimage spec
90 * @spec: input string, containing subimage spec
91 * @add_curr: current image address (to be used as a possible default)
92 * @addr: pointer to a ulong variable, will hold FIT image address of a given
94 * @image_name: double pointer to a char, will hold pointer to a subimage name
96 * fit_parse_subimage() expects subimage spec in the form of
97 * [<addr>]:<subimage>, where <addr> is a FIT image address that contains
98 * subimage with a <subimg> unit name.
100 * Address part is optional, and if omitted default add_curr will
104 * 1 if spec is a valid subimage string,
105 * addr and image_name are set accordingly
108 int fit_parse_subimage(const char *spec, ulong addr_curr,
109 ulong *addr, const char **image_name)
111 return fit_parse_spec(spec, ':', addr_curr, addr, image_name);
113 #endif /* !USE_HOSTCC */
115 static void fit_get_debug(const void *fit, int noffset,
116 char *prop_name, int err)
118 debug("Can't get '%s' property from FIT 0x%08lx, node: offset %d, name %s (%s)\n",
119 prop_name, (ulong)fit, noffset, fit_get_name(fit, noffset, NULL),
124 * fit_get_subimage_count - get component (sub-image) count
125 * @fit: pointer to the FIT format image header
126 * @images_noffset: offset of images node
129 * number of image components
131 int fit_get_subimage_count(const void *fit, int images_noffset)
137 /* Process its subnodes, print out component images details */
138 for (ndepth = 0, count = 0,
139 noffset = fdt_next_node(fit, images_noffset, &ndepth);
140 (noffset >= 0) && (ndepth > 0);
141 noffset = fdt_next_node(fit, noffset, &ndepth)) {
150 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_FIT_PRINT)
152 * fit_image_print_data() - prints out the hash node details
153 * @fit: pointer to the FIT format image header
154 * @noffset: offset of the hash node
155 * @p: pointer to prefix string
156 * @type: Type of information to print ("hash" or "sign")
158 * fit_image_print_data() lists properties for the processed hash node
160 * This function avoid using puts() since it prints a newline on the host
161 * but does not in U-Boot.
164 * no returned results
166 static void fit_image_print_data(const void *fit, int noffset, const char *p,
177 debug("%s %s node: '%s'\n", p, type,
178 fit_get_name(fit, noffset, NULL));
179 printf("%s %s algo: ", p, type);
180 if (fit_image_hash_get_algo(fit, noffset, &algo)) {
181 printf("invalid/unsupported\n");
185 keyname = fdt_getprop(fit, noffset, FIT_KEY_HINT, NULL);
186 required = fdt_getprop(fit, noffset, FIT_KEY_REQUIRED, NULL) != NULL;
188 printf(":%s", keyname);
190 printf(" (required)");
193 padding = fdt_getprop(fit, noffset, "padding", NULL);
195 printf("%s %s padding: %s\n", p, type, padding);
197 ret = fit_image_hash_get_value(fit, noffset, &value,
199 printf("%s %s value: ", p, type);
201 printf("unavailable\n");
203 for (i = 0; i < value_len; i++)
204 printf("%02x", value[i]);
208 debug("%s %s len: %d\n", p, type, value_len);
210 /* Signatures have a time stamp */
211 if (IMAGE_ENABLE_TIMESTAMP && keyname) {
214 printf("%s Timestamp: ", p);
215 if (fit_get_timestamp(fit, noffset, ×tamp))
216 printf("unavailable\n");
218 genimg_print_time(timestamp);
223 * fit_image_print_verification_data() - prints out the hash/signature details
224 * @fit: pointer to the FIT format image header
225 * @noffset: offset of the hash or signature node
226 * @p: pointer to prefix string
228 * This lists properties for the processed hash node
231 * no returned results
233 static void fit_image_print_verification_data(const void *fit, int noffset,
239 * Check subnode name, must be equal to "hash" or "signature".
240 * Multiple hash/signature nodes require unique unit node
241 * names, e.g. hash-1, hash-2, signature-1, signature-2, etc.
243 name = fit_get_name(fit, noffset, NULL);
244 if (!strncmp(name, FIT_HASH_NODENAME, strlen(FIT_HASH_NODENAME))) {
245 fit_image_print_data(fit, noffset, p, "Hash");
246 } else if (!strncmp(name, FIT_SIG_NODENAME,
247 strlen(FIT_SIG_NODENAME))) {
248 fit_image_print_data(fit, noffset, p, "Sign");
253 * fit_conf_print - prints out the FIT configuration details
254 * @fit: pointer to the FIT format image header
255 * @noffset: offset of the configuration node
256 * @p: pointer to prefix string
258 * fit_conf_print() lists all mandatory properties for the processed
259 * configuration node.
262 * no returned results
264 static void fit_conf_print(const void *fit, int noffset, const char *p)
269 int fdt_index, loadables_index;
272 /* Mandatory properties */
273 ret = fit_get_desc(fit, noffset, &desc);
274 printf("%s Description: ", p);
276 printf("unavailable\n");
278 printf("%s\n", desc);
280 uname = fdt_getprop(fit, noffset, FIT_KERNEL_PROP, NULL);
281 printf("%s Kernel: ", p);
283 printf("unavailable\n");
285 printf("%s\n", uname);
287 /* Optional properties */
288 uname = fdt_getprop(fit, noffset, FIT_RAMDISK_PROP, NULL);
290 printf("%s Init Ramdisk: %s\n", p, uname);
292 uname = fdt_getprop(fit, noffset, FIT_FIRMWARE_PROP, NULL);
294 printf("%s Firmware: %s\n", p, uname);
297 uname = fdt_stringlist_get(fit, noffset, FIT_FDT_PROP,
298 fdt_index, NULL), uname;
301 printf("%s FDT: ", p);
304 printf("%s\n", uname);
307 uname = fdt_getprop(fit, noffset, FIT_FPGA_PROP, NULL);
309 printf("%s FPGA: %s\n", p, uname);
311 /* Print out all of the specified loadables */
312 for (loadables_index = 0;
313 uname = fdt_stringlist_get(fit, noffset, FIT_LOADABLE_PROP,
314 loadables_index, NULL), uname;
316 if (loadables_index == 0) {
317 printf("%s Loadables: ", p);
321 printf("%s\n", uname);
324 /* Process all hash subnodes of the component configuration node */
325 for (ndepth = 0, noffset = fdt_next_node(fit, noffset, &ndepth);
326 (noffset >= 0) && (ndepth > 0);
327 noffset = fdt_next_node(fit, noffset, &ndepth)) {
329 /* Direct child node of the component configuration node */
330 fit_image_print_verification_data(fit, noffset, p);
336 * fit_print_contents - prints out the contents of the FIT format image
337 * @fit: pointer to the FIT format image header
338 * @p: pointer to prefix string
340 * fit_print_contents() formats a multi line FIT image contents description.
341 * The routine prints out FIT image properties (root node level) followed by
342 * the details of each component image.
345 * no returned results
347 void fit_print_contents(const void *fit)
360 /* Indent string is defined in header image.h */
361 p = IMAGE_INDENT_STRING;
363 /* Root node properties */
364 ret = fit_get_desc(fit, 0, &desc);
365 printf("%sFIT description: ", p);
367 printf("unavailable\n");
369 printf("%s\n", desc);
371 if (IMAGE_ENABLE_TIMESTAMP) {
372 ret = fit_get_timestamp(fit, 0, ×tamp);
373 printf("%sCreated: ", p);
375 printf("unavailable\n");
377 genimg_print_time(timestamp);
380 /* Find images parent node offset */
381 images_noffset = fdt_path_offset(fit, FIT_IMAGES_PATH);
382 if (images_noffset < 0) {
383 printf("Can't find images parent node '%s' (%s)\n",
384 FIT_IMAGES_PATH, fdt_strerror(images_noffset));
388 /* Process its subnodes, print out component images details */
389 for (ndepth = 0, count = 0,
390 noffset = fdt_next_node(fit, images_noffset, &ndepth);
391 (noffset >= 0) && (ndepth > 0);
392 noffset = fdt_next_node(fit, noffset, &ndepth)) {
395 * Direct child node of the images parent node,
396 * i.e. component image node.
398 printf("%s Image %u (%s)\n", p, count++,
399 fit_get_name(fit, noffset, NULL));
401 fit_image_print(fit, noffset, p);
405 /* Find configurations parent node offset */
406 confs_noffset = fdt_path_offset(fit, FIT_CONFS_PATH);
407 if (confs_noffset < 0) {
408 debug("Can't get configurations parent node '%s' (%s)\n",
409 FIT_CONFS_PATH, fdt_strerror(confs_noffset));
413 /* get default configuration unit name from default property */
414 uname = (char *)fdt_getprop(fit, noffset, FIT_DEFAULT_PROP, NULL);
416 printf("%s Default Configuration: '%s'\n", p, uname);
418 /* Process its subnodes, print out configurations details */
419 for (ndepth = 0, count = 0,
420 noffset = fdt_next_node(fit, confs_noffset, &ndepth);
421 (noffset >= 0) && (ndepth > 0);
422 noffset = fdt_next_node(fit, noffset, &ndepth)) {
425 * Direct child node of the configurations parent node,
426 * i.e. configuration node.
428 printf("%s Configuration %u (%s)\n", p, count++,
429 fit_get_name(fit, noffset, NULL));
431 fit_conf_print(fit, noffset, p);
437 * fit_image_print - prints out the FIT component image details
438 * @fit: pointer to the FIT format image header
439 * @image_noffset: offset of the component image node
440 * @p: pointer to prefix string
442 * fit_image_print() lists all mandatory properties for the processed component
443 * image. If present, hash nodes are printed out as well. Load
444 * address for images of type firmware is also printed out. Since the load
445 * address is not mandatory for firmware images, it will be output as
446 * "unavailable" when not present.
449 * no returned results
451 void fit_image_print(const void *fit, int image_noffset, const char *p)
454 uint8_t type, arch, os, comp;
462 /* Mandatory properties */
463 ret = fit_get_desc(fit, image_noffset, &desc);
464 printf("%s Description: ", p);
466 printf("unavailable\n");
468 printf("%s\n", desc);
470 if (IMAGE_ENABLE_TIMESTAMP) {
473 ret = fit_get_timestamp(fit, 0, ×tamp);
474 printf("%s Created: ", p);
476 printf("unavailable\n");
478 genimg_print_time(timestamp);
481 fit_image_get_type(fit, image_noffset, &type);
482 printf("%s Type: %s\n", p, genimg_get_type_name(type));
484 fit_image_get_comp(fit, image_noffset, &comp);
485 printf("%s Compression: %s\n", p, genimg_get_comp_name(comp));
487 ret = fit_image_get_data_and_size(fit, image_noffset, &data, &size);
490 printf("%s Data Start: ", p);
492 printf("unavailable\n");
494 void *vdata = (void *)data;
496 printf("0x%08lx\n", (ulong)map_to_sysmem(vdata));
500 printf("%s Data Size: ", p);
502 printf("unavailable\n");
504 genimg_print_size(size);
506 /* Remaining, type dependent properties */
507 if ((type == IH_TYPE_KERNEL) || (type == IH_TYPE_STANDALONE) ||
508 (type == IH_TYPE_RAMDISK) || (type == IH_TYPE_FIRMWARE) ||
509 (type == IH_TYPE_FLATDT)) {
510 fit_image_get_arch(fit, image_noffset, &arch);
511 printf("%s Architecture: %s\n", p, genimg_get_arch_name(arch));
514 if ((type == IH_TYPE_KERNEL) || (type == IH_TYPE_RAMDISK) ||
515 (type == IH_TYPE_FIRMWARE)) {
516 fit_image_get_os(fit, image_noffset, &os);
517 printf("%s OS: %s\n", p, genimg_get_os_name(os));
520 if ((type == IH_TYPE_KERNEL) || (type == IH_TYPE_STANDALONE) ||
521 (type == IH_TYPE_FIRMWARE) || (type == IH_TYPE_RAMDISK) ||
522 (type == IH_TYPE_FPGA)) {
523 ret = fit_image_get_load(fit, image_noffset, &load);
524 printf("%s Load Address: ", p);
526 printf("unavailable\n");
528 printf("0x%08lx\n", load);
531 /* optional load address for FDT */
532 if (type == IH_TYPE_FLATDT && !fit_image_get_load(fit, image_noffset, &load))
533 printf("%s Load Address: 0x%08lx\n", p, load);
535 if ((type == IH_TYPE_KERNEL) || (type == IH_TYPE_STANDALONE) ||
536 (type == IH_TYPE_RAMDISK)) {
537 ret = fit_image_get_entry(fit, image_noffset, &entry);
538 printf("%s Entry Point: ", p);
540 printf("unavailable\n");
542 printf("0x%08lx\n", entry);
545 /* Process all hash subnodes of the component image node */
546 for (ndepth = 0, noffset = fdt_next_node(fit, image_noffset, &ndepth);
547 (noffset >= 0) && (ndepth > 0);
548 noffset = fdt_next_node(fit, noffset, &ndepth)) {
550 /* Direct child node of the component image node */
551 fit_image_print_verification_data(fit, noffset, p);
556 void fit_print_contents(const void *fit) { }
557 void fit_image_print(const void *fit, int image_noffset, const char *p) { }
558 #endif /* !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_FIT_PRINT) */
561 * fit_get_desc - get node description property
562 * @fit: pointer to the FIT format image header
563 * @noffset: node offset
564 * @desc: double pointer to the char, will hold pointer to the description
566 * fit_get_desc() reads description property from a given node, if
567 * description is found pointer to it is returned in third call argument.
573 int fit_get_desc(const void *fit, int noffset, char **desc)
577 *desc = (char *)fdt_getprop(fit, noffset, FIT_DESC_PROP, &len);
579 fit_get_debug(fit, noffset, FIT_DESC_PROP, len);
587 * fit_get_timestamp - get node timestamp property
588 * @fit: pointer to the FIT format image header
589 * @noffset: node offset
590 * @timestamp: pointer to the time_t, will hold read timestamp
592 * fit_get_timestamp() reads timestamp property from given node, if timestamp
593 * is found and has a correct size its value is returned in third call
598 * -1, on property read failure
599 * -2, on wrong timestamp size
601 int fit_get_timestamp(const void *fit, int noffset, time_t *timestamp)
606 data = fdt_getprop(fit, noffset, FIT_TIMESTAMP_PROP, &len);
608 fit_get_debug(fit, noffset, FIT_TIMESTAMP_PROP, len);
611 if (len != sizeof(uint32_t)) {
612 debug("FIT timestamp with incorrect size of (%u)\n", len);
616 *timestamp = uimage_to_cpu(*((uint32_t *)data));
621 * fit_image_get_node - get node offset for component image of a given unit name
622 * @fit: pointer to the FIT format image header
623 * @image_uname: component image node unit name
625 * fit_image_get_node() finds a component image (within the '/images'
626 * node) of a provided unit name. If image is found its node offset is
627 * returned to the caller.
630 * image node offset when found (>=0)
631 * negative number on failure (FDT_ERR_* code)
633 int fit_image_get_node(const void *fit, const char *image_uname)
635 int noffset, images_noffset;
637 images_noffset = fdt_path_offset(fit, FIT_IMAGES_PATH);
638 if (images_noffset < 0) {
639 debug("Can't find images parent node '%s' (%s)\n",
640 FIT_IMAGES_PATH, fdt_strerror(images_noffset));
641 return images_noffset;
644 noffset = fdt_subnode_offset(fit, images_noffset, image_uname);
646 debug("Can't get node offset for image unit name: '%s' (%s)\n",
647 image_uname, fdt_strerror(noffset));
654 * fit_image_get_os - get os id for a given component image node
655 * @fit: pointer to the FIT format image header
656 * @noffset: component image node offset
657 * @os: pointer to the uint8_t, will hold os numeric id
659 * fit_image_get_os() finds os property in a given component image node.
660 * If the property is found, its (string) value is translated to the numeric
661 * id which is returned to the caller.
667 int fit_image_get_os(const void *fit, int noffset, uint8_t *os)
672 /* Get OS name from property data */
673 data = fdt_getprop(fit, noffset, FIT_OS_PROP, &len);
675 fit_get_debug(fit, noffset, FIT_OS_PROP, len);
680 /* Translate OS name to id */
681 *os = genimg_get_os_id(data);
686 * fit_image_get_arch - get arch id for a given component image node
687 * @fit: pointer to the FIT format image header
688 * @noffset: component image node offset
689 * @arch: pointer to the uint8_t, will hold arch numeric id
691 * fit_image_get_arch() finds arch property in a given component image node.
692 * If the property is found, its (string) value is translated to the numeric
693 * id which is returned to the caller.
699 int fit_image_get_arch(const void *fit, int noffset, uint8_t *arch)
704 /* Get architecture name from property data */
705 data = fdt_getprop(fit, noffset, FIT_ARCH_PROP, &len);
707 fit_get_debug(fit, noffset, FIT_ARCH_PROP, len);
712 /* Translate architecture name to id */
713 *arch = genimg_get_arch_id(data);
718 * fit_image_get_type - get type id for a given component image node
719 * @fit: pointer to the FIT format image header
720 * @noffset: component image node offset
721 * @type: pointer to the uint8_t, will hold type numeric id
723 * fit_image_get_type() finds type property in a given component image node.
724 * If the property is found, its (string) value is translated to the numeric
725 * id which is returned to the caller.
731 int fit_image_get_type(const void *fit, int noffset, uint8_t *type)
736 /* Get image type name from property data */
737 data = fdt_getprop(fit, noffset, FIT_TYPE_PROP, &len);
739 fit_get_debug(fit, noffset, FIT_TYPE_PROP, len);
744 /* Translate image type name to id */
745 *type = genimg_get_type_id(data);
750 * fit_image_get_comp - get comp id for a given component image node
751 * @fit: pointer to the FIT format image header
752 * @noffset: component image node offset
753 * @comp: pointer to the uint8_t, will hold comp numeric id
755 * fit_image_get_comp() finds comp property in a given component image node.
756 * If the property is found, its (string) value is translated to the numeric
757 * id which is returned to the caller.
763 int fit_image_get_comp(const void *fit, int noffset, uint8_t *comp)
768 /* Get compression name from property data */
769 data = fdt_getprop(fit, noffset, FIT_COMP_PROP, &len);
771 fit_get_debug(fit, noffset, FIT_COMP_PROP, len);
776 /* Translate compression name to id */
777 *comp = genimg_get_comp_id(data);
781 static int fit_image_get_address(const void *fit, int noffset, char *name,
788 cell = fdt_getprop(fit, noffset, name, &len);
790 fit_get_debug(fit, noffset, name, len);
795 /* Use load64 to avoid compiling warning for 32-bit target */
797 load64 = (load64 << 32) | uimage_to_cpu(*cell);
801 if (len > sizeof(ulong) && (uint32_t)(load64 >> 32)) {
802 printf("Unsupported %s address size\n", name);
806 *load = (ulong)load64;
811 * fit_image_get_load() - get load addr property for given component image node
812 * @fit: pointer to the FIT format image header
813 * @noffset: component image node offset
814 * @load: pointer to the uint32_t, will hold load address
816 * fit_image_get_load() finds load address property in a given component
817 * image node. If the property is found, its value is returned to the caller.
823 int fit_image_get_load(const void *fit, int noffset, ulong *load)
825 return fit_image_get_address(fit, noffset, FIT_LOAD_PROP, load);
829 * fit_image_get_entry() - get entry point address property
830 * @fit: pointer to the FIT format image header
831 * @noffset: component image node offset
832 * @entry: pointer to the uint32_t, will hold entry point address
834 * This gets the entry point address property for a given component image
837 * fit_image_get_entry() finds entry point address property in a given
838 * component image node. If the property is found, its value is returned
845 int fit_image_get_entry(const void *fit, int noffset, ulong *entry)
847 return fit_image_get_address(fit, noffset, FIT_ENTRY_PROP, entry);
851 * fit_image_get_data - get data property and its size for a given component image node
852 * @fit: pointer to the FIT format image header
853 * @noffset: component image node offset
854 * @data: double pointer to void, will hold data property's data address
855 * @size: pointer to size_t, will hold data property's data size
857 * fit_image_get_data() finds data property in a given component image node.
858 * If the property is found its data start address and size are returned to
865 int fit_image_get_data(const void *fit, int noffset,
866 const void **data, size_t *size)
870 *data = fdt_getprop(fit, noffset, FIT_DATA_PROP, &len);
872 fit_get_debug(fit, noffset, FIT_DATA_PROP, len);
882 * Get 'data-offset' property from a given image node.
884 * @fit: pointer to the FIT image header
885 * @noffset: component image node offset
886 * @data_offset: holds the data-offset property
890 * -ENOENT if the property could not be found
892 int fit_image_get_data_offset(const void *fit, int noffset, int *data_offset)
896 val = fdt_getprop(fit, noffset, FIT_DATA_OFFSET_PROP, NULL);
900 *data_offset = fdt32_to_cpu(*val);
906 * Get 'data-position' property from a given image node.
908 * @fit: pointer to the FIT image header
909 * @noffset: component image node offset
910 * @data_position: holds the data-position property
914 * -ENOENT if the property could not be found
916 int fit_image_get_data_position(const void *fit, int noffset,
921 val = fdt_getprop(fit, noffset, FIT_DATA_POSITION_PROP, NULL);
925 *data_position = fdt32_to_cpu(*val);
931 * Get 'data-size' property from a given image node.
933 * @fit: pointer to the FIT image header
934 * @noffset: component image node offset
935 * @data_size: holds the data-size property
939 * -ENOENT if the property could not be found
941 int fit_image_get_data_size(const void *fit, int noffset, int *data_size)
945 val = fdt_getprop(fit, noffset, FIT_DATA_SIZE_PROP, NULL);
949 *data_size = fdt32_to_cpu(*val);
955 * Get 'data-size-unciphered' property from a given image node.
957 * @fit: pointer to the FIT image header
958 * @noffset: component image node offset
959 * @data_size: holds the data-size property
963 * -ENOENT if the property could not be found
965 int fit_image_get_data_size_unciphered(const void *fit, int noffset,
970 val = fdt_getprop(fit, noffset, "data-size-unciphered", NULL);
974 *data_size = (size_t)fdt32_to_cpu(*val);
980 * fit_image_get_data_and_size - get data and its size including
981 * both embedded and external data
982 * @fit: pointer to the FIT format image header
983 * @noffset: component image node offset
984 * @data: double pointer to void, will hold data property's data address
985 * @size: pointer to size_t, will hold data property's data size
987 * fit_image_get_data_and_size() finds data and its size including
988 * both embedded and external data. If the property is found
989 * its data start address and size are returned to the caller.
993 * otherwise, on failure
995 int fit_image_get_data_and_size(const void *fit, int noffset,
996 const void **data, size_t *size)
998 bool external_data = false;
1003 if (!fit_image_get_data_position(fit, noffset, &offset)) {
1004 external_data = true;
1005 } else if (!fit_image_get_data_offset(fit, noffset, &offset)) {
1006 external_data = true;
1008 * For FIT with external data, figure out where
1009 * the external images start. This is the base
1010 * for the data-offset properties in each image.
1012 offset += ((fdt_totalsize(fit) + 3) & ~3);
1015 if (external_data) {
1016 debug("External Data\n");
1017 ret = fit_image_get_data_size(fit, noffset, &len);
1019 *data = fit + offset;
1023 ret = fit_image_get_data(fit, noffset, data, size);
1030 * fit_image_hash_get_algo - get hash algorithm name
1031 * @fit: pointer to the FIT format image header
1032 * @noffset: hash node offset
1033 * @algo: double pointer to char, will hold pointer to the algorithm name
1035 * fit_image_hash_get_algo() finds hash algorithm property in a given hash node.
1036 * If the property is found its data start address is returned to the caller.
1042 int fit_image_hash_get_algo(const void *fit, int noffset, char **algo)
1046 *algo = (char *)fdt_getprop(fit, noffset, FIT_ALGO_PROP, &len);
1047 if (*algo == NULL) {
1048 fit_get_debug(fit, noffset, FIT_ALGO_PROP, len);
1056 * fit_image_hash_get_value - get hash value and length
1057 * @fit: pointer to the FIT format image header
1058 * @noffset: hash node offset
1059 * @value: double pointer to uint8_t, will hold address of a hash value data
1060 * @value_len: pointer to an int, will hold hash data length
1062 * fit_image_hash_get_value() finds hash value property in a given hash node.
1063 * If the property is found its data start address and size are returned to
1070 int fit_image_hash_get_value(const void *fit, int noffset, uint8_t **value,
1075 *value = (uint8_t *)fdt_getprop(fit, noffset, FIT_VALUE_PROP, &len);
1076 if (*value == NULL) {
1077 fit_get_debug(fit, noffset, FIT_VALUE_PROP, len);
1087 * fit_image_hash_get_ignore - get hash ignore flag
1088 * @fit: pointer to the FIT format image header
1089 * @noffset: hash node offset
1090 * @ignore: pointer to an int, will hold hash ignore flag
1092 * fit_image_hash_get_ignore() finds hash ignore property in a given hash node.
1093 * If the property is found and non-zero, the hash algorithm is not verified by
1094 * u-boot automatically.
1097 * 0, on ignore not found
1098 * value, on ignore found
1100 static int fit_image_hash_get_ignore(const void *fit, int noffset, int *ignore)
1105 value = (int *)fdt_getprop(fit, noffset, FIT_IGNORE_PROP, &len);
1106 if (value == NULL || len != sizeof(int))
1115 * fit_image_cipher_get_algo - get cipher algorithm name
1116 * @fit: pointer to the FIT format image header
1117 * @noffset: cipher node offset
1118 * @algo: double pointer to char, will hold pointer to the algorithm name
1120 * fit_image_cipher_get_algo() finds cipher algorithm property in a given
1121 * cipher node. If the property is found its data start address is returned
1128 int fit_image_cipher_get_algo(const void *fit, int noffset, char **algo)
1132 *algo = (char *)fdt_getprop(fit, noffset, FIT_ALGO_PROP, &len);
1134 fit_get_debug(fit, noffset, FIT_ALGO_PROP, len);
1141 ulong fit_get_end(const void *fit)
1143 return map_to_sysmem((void *)(fit + fdt_totalsize(fit)));
1147 * fit_set_timestamp - set node timestamp property
1148 * @fit: pointer to the FIT format image header
1149 * @noffset: node offset
1150 * @timestamp: timestamp value to be set
1152 * fit_set_timestamp() attempts to set timestamp property in the requested
1153 * node and returns operation status to the caller.
1157 * -ENOSPC if no space in device tree, -1 for other error
1159 int fit_set_timestamp(void *fit, int noffset, time_t timestamp)
1164 t = cpu_to_uimage(timestamp);
1165 ret = fdt_setprop(fit, noffset, FIT_TIMESTAMP_PROP, &t,
1168 debug("Can't set '%s' property for '%s' node (%s)\n",
1169 FIT_TIMESTAMP_PROP, fit_get_name(fit, noffset, NULL),
1171 return ret == -FDT_ERR_NOSPACE ? -ENOSPC : -1;
1178 * calculate_hash - calculate and return hash for provided input data
1179 * @data: pointer to the input data
1180 * @data_len: data length
1181 * @algo: requested hash algorithm
1182 * @value: pointer to the char, will hold hash value data (caller must
1183 * allocate enough free space)
1184 * value_len: length of the calculated hash
1186 * calculate_hash() computes input data hash according to the requested
1188 * Resulting hash value is placed in caller provided 'value' buffer, length
1189 * of the calculated hash is returned via value_len pointer argument.
1193 * -1, when algo is unsupported
1195 int calculate_hash(const void *data, int data_len, const char *algo,
1196 uint8_t *value, int *value_len)
1198 if (IMAGE_ENABLE_CRC32 && strcmp(algo, "crc32") == 0) {
1199 *((uint32_t *)value) = crc32_wd(0, data, data_len,
1201 *((uint32_t *)value) = cpu_to_uimage(*((uint32_t *)value));
1203 } else if (IMAGE_ENABLE_SHA1 && strcmp(algo, "sha1") == 0) {
1204 sha1_csum_wd((unsigned char *)data, data_len,
1205 (unsigned char *)value, CHUNKSZ_SHA1);
1207 } else if (IMAGE_ENABLE_SHA256 && strcmp(algo, "sha256") == 0) {
1208 sha256_csum_wd((unsigned char *)data, data_len,
1209 (unsigned char *)value, CHUNKSZ_SHA256);
1210 *value_len = SHA256_SUM_LEN;
1211 } else if (IMAGE_ENABLE_SHA384 && strcmp(algo, "sha384") == 0) {
1212 sha384_csum_wd((unsigned char *)data, data_len,
1213 (unsigned char *)value, CHUNKSZ_SHA384);
1214 *value_len = SHA384_SUM_LEN;
1215 } else if (IMAGE_ENABLE_SHA512 && strcmp(algo, "sha512") == 0) {
1216 sha512_csum_wd((unsigned char *)data, data_len,
1217 (unsigned char *)value, CHUNKSZ_SHA512);
1218 *value_len = SHA512_SUM_LEN;
1219 } else if (IMAGE_ENABLE_MD5 && strcmp(algo, "md5") == 0) {
1220 md5_wd((unsigned char *)data, data_len, value, CHUNKSZ_MD5);
1223 debug("Unsupported hash alogrithm\n");
1229 static int fit_image_check_hash(const void *fit, int noffset, const void *data,
1230 size_t size, char **err_msgp)
1232 uint8_t value[FIT_MAX_HASH_LEN];
1241 if (fit_image_hash_get_algo(fit, noffset, &algo)) {
1242 *err_msgp = "Can't get hash algo property";
1247 if (IMAGE_ENABLE_IGNORE) {
1248 fit_image_hash_get_ignore(fit, noffset, &ignore);
1250 printf("-skipped ");
1255 if (fit_image_hash_get_value(fit, noffset, &fit_value,
1257 *err_msgp = "Can't get hash value property";
1261 if (calculate_hash(data, size, algo, value, &value_len)) {
1262 *err_msgp = "Unsupported hash algorithm";
1266 if (value_len != fit_value_len) {
1267 *err_msgp = "Bad hash value len";
1269 } else if (memcmp(value, fit_value, value_len) != 0) {
1270 *err_msgp = "Bad hash value";
1277 int fit_image_verify_with_data(const void *fit, int image_noffset,
1278 const void *data, size_t size)
1285 /* Verify all required signatures */
1286 if (FIT_IMAGE_ENABLE_VERIFY &&
1287 fit_image_verify_required_sigs(fit, image_noffset, data, size,
1288 gd_fdt_blob(), &verify_all)) {
1289 err_msg = "Unable to verify required signature";
1293 /* Process all hash subnodes of the component image node */
1294 fdt_for_each_subnode(noffset, fit, image_noffset) {
1295 const char *name = fit_get_name(fit, noffset, NULL);
1298 * Check subnode name, must be equal to "hash".
1299 * Multiple hash nodes require unique unit node
1300 * names, e.g. hash-1, hash-2, etc.
1302 if (!strncmp(name, FIT_HASH_NODENAME,
1303 strlen(FIT_HASH_NODENAME))) {
1304 if (fit_image_check_hash(fit, noffset, data, size,
1308 } else if (FIT_IMAGE_ENABLE_VERIFY && verify_all &&
1309 !strncmp(name, FIT_SIG_NODENAME,
1310 strlen(FIT_SIG_NODENAME))) {
1311 ret = fit_image_check_sig(fit, noffset, data,
1312 size, -1, &err_msg);
1315 * Show an indication on failure, but do not return
1316 * an error. Only keys marked 'required' can cause
1317 * an image validation failure. See the call to
1318 * fit_image_verify_required_sigs() above.
1327 if (noffset == -FDT_ERR_TRUNCATED || noffset == -FDT_ERR_BADSTRUCTURE) {
1328 err_msg = "Corrupted or truncated tree";
1335 printf(" error!\n%s for '%s' hash node in '%s' image node\n",
1336 err_msg, fit_get_name(fit, noffset, NULL),
1337 fit_get_name(fit, image_noffset, NULL));
1342 * fit_image_verify - verify data integrity
1343 * @fit: pointer to the FIT format image header
1344 * @image_noffset: component image node offset
1346 * fit_image_verify() goes over component image hash nodes,
1347 * re-calculates each data hash and compares with the value stored in hash
1351 * 1, if all hashes are valid
1352 * 0, otherwise (or on error)
1354 int fit_image_verify(const void *fit, int image_noffset)
1361 /* Get image data and data length */
1362 if (fit_image_get_data_and_size(fit, image_noffset, &data, &size)) {
1363 err_msg = "Can't get image data/size";
1364 printf("error!\n%s for '%s' hash node in '%s' image node\n",
1365 err_msg, fit_get_name(fit, noffset, NULL),
1366 fit_get_name(fit, image_noffset, NULL));
1370 return fit_image_verify_with_data(fit, image_noffset, data, size);
1374 * fit_all_image_verify - verify data integrity for all images
1375 * @fit: pointer to the FIT format image header
1377 * fit_all_image_verify() goes over all images in the FIT and
1378 * for every images checks if all it's hashes are valid.
1381 * 1, if all hashes of all images are valid
1382 * 0, otherwise (or on error)
1384 int fit_all_image_verify(const void *fit)
1391 /* Find images parent node offset */
1392 images_noffset = fdt_path_offset(fit, FIT_IMAGES_PATH);
1393 if (images_noffset < 0) {
1394 printf("Can't find images parent node '%s' (%s)\n",
1395 FIT_IMAGES_PATH, fdt_strerror(images_noffset));
1399 /* Process all image subnodes, check hashes for each */
1400 printf("## Checking hash(es) for FIT Image at %08lx ...\n",
1402 for (ndepth = 0, count = 0,
1403 noffset = fdt_next_node(fit, images_noffset, &ndepth);
1404 (noffset >= 0) && (ndepth > 0);
1405 noffset = fdt_next_node(fit, noffset, &ndepth)) {
1408 * Direct child node of the images parent node,
1409 * i.e. component image node.
1411 printf(" Hash(es) for Image %u (%s): ", count,
1412 fit_get_name(fit, noffset, NULL));
1415 if (!fit_image_verify(fit, noffset))
1423 static int fit_image_uncipher(const void *fit, int image_noffset,
1424 void **data, size_t *size)
1426 int cipher_noffset, ret;
1430 cipher_noffset = fdt_subnode_offset(fit, image_noffset,
1431 FIT_CIPHER_NODENAME);
1432 if (cipher_noffset < 0)
1435 ret = fit_image_decrypt_data(fit, image_noffset, cipher_noffset,
1436 *data, *size, &dst, &size_dst);
1448 * fit_image_check_os - check whether image node is of a given os type
1449 * @fit: pointer to the FIT format image header
1450 * @noffset: component image node offset
1451 * @os: requested image os
1453 * fit_image_check_os() reads image os property and compares its numeric
1454 * id with the requested os. Comparison result is returned to the caller.
1457 * 1 if image is of given os type
1458 * 0 otherwise (or on error)
1460 int fit_image_check_os(const void *fit, int noffset, uint8_t os)
1464 if (fit_image_get_os(fit, noffset, &image_os))
1466 return (os == image_os);
1470 * fit_image_check_arch - check whether image node is of a given arch
1471 * @fit: pointer to the FIT format image header
1472 * @noffset: component image node offset
1473 * @arch: requested imagearch
1475 * fit_image_check_arch() reads image arch property and compares its numeric
1476 * id with the requested arch. Comparison result is returned to the caller.
1479 * 1 if image is of given arch
1480 * 0 otherwise (or on error)
1482 int fit_image_check_arch(const void *fit, int noffset, uint8_t arch)
1485 int aarch32_support = 0;
1487 if (IS_ENABLED(CONFIG_ARM64_SUPPORT_AARCH32))
1488 aarch32_support = 1;
1490 if (fit_image_get_arch(fit, noffset, &image_arch))
1492 return (arch == image_arch) ||
1493 (arch == IH_ARCH_I386 && image_arch == IH_ARCH_X86_64) ||
1494 (arch == IH_ARCH_ARM64 && image_arch == IH_ARCH_ARM &&
1499 * fit_image_check_type - check whether image node is of a given type
1500 * @fit: pointer to the FIT format image header
1501 * @noffset: component image node offset
1502 * @type: requested image type
1504 * fit_image_check_type() reads image type property and compares its numeric
1505 * id with the requested type. Comparison result is returned to the caller.
1508 * 1 if image is of given type
1509 * 0 otherwise (or on error)
1511 int fit_image_check_type(const void *fit, int noffset, uint8_t type)
1515 if (fit_image_get_type(fit, noffset, &image_type))
1517 return (type == image_type);
1521 * fit_image_check_comp - check whether image node uses given compression
1522 * @fit: pointer to the FIT format image header
1523 * @noffset: component image node offset
1524 * @comp: requested image compression type
1526 * fit_image_check_comp() reads image compression property and compares its
1527 * numeric id with the requested compression type. Comparison result is
1528 * returned to the caller.
1531 * 1 if image uses requested compression
1532 * 0 otherwise (or on error)
1534 int fit_image_check_comp(const void *fit, int noffset, uint8_t comp)
1538 if (fit_image_get_comp(fit, noffset, &image_comp))
1540 return (comp == image_comp);
1544 * fit_check_format - sanity check FIT image format
1545 * @fit: pointer to the FIT format image header
1547 * fit_check_format() runs a basic sanity FIT image verification.
1548 * Routine checks for mandatory properties, nodes, etc.
1554 int fit_check_format(const void *fit)
1556 /* A FIT image must be a valid FDT */
1557 if (fdt_check_header(fit)) {
1558 debug("Wrong FIT format: not a flattened device tree\n");
1562 /* mandatory / node 'description' property */
1563 if (fdt_getprop(fit, 0, FIT_DESC_PROP, NULL) == NULL) {
1564 debug("Wrong FIT format: no description\n");
1568 if (IMAGE_ENABLE_TIMESTAMP) {
1569 /* mandatory / node 'timestamp' property */
1570 if (fdt_getprop(fit, 0, FIT_TIMESTAMP_PROP, NULL) == NULL) {
1571 debug("Wrong FIT format: no timestamp\n");
1576 /* mandatory subimages parent '/images' node */
1577 if (fdt_path_offset(fit, FIT_IMAGES_PATH) < 0) {
1578 debug("Wrong FIT format: no images parent node\n");
1587 * fit_conf_find_compat
1588 * @fit: pointer to the FIT format image header
1589 * @fdt: pointer to the device tree to compare against
1591 * fit_conf_find_compat() attempts to find the configuration whose fdt is the
1592 * most compatible with the passed in device tree.
1601 * |-o configurations
1609 * |-compatible = "foo,bar", "bim,bam"
1612 * |-compatible = "foo,bar",
1615 * |-compatible = "bim,bam", "baz,biz"
1617 * Configuration 1 would be picked because the first string in U-Boot's
1618 * compatible list, "foo,bar", matches a compatible string in the root of fdt1.
1619 * "bim,bam" in fdt2 matches the second string which isn't as good as fdt1.
1621 * As an optimization, the compatible property from the FDT's root node can be
1622 * copied into the configuration node in the FIT image. This is required to
1623 * match configurations with compressed FDTs.
1626 * offset to the configuration to use if one was found
1629 int fit_conf_find_compat(const void *fit, const void *fdt)
1632 int noffset, confs_noffset, images_noffset;
1633 const void *fdt_compat;
1635 int best_match_offset = 0;
1636 int best_match_pos = 0;
1638 confs_noffset = fdt_path_offset(fit, FIT_CONFS_PATH);
1639 images_noffset = fdt_path_offset(fit, FIT_IMAGES_PATH);
1640 if (confs_noffset < 0 || images_noffset < 0) {
1641 debug("Can't find configurations or images nodes.\n");
1645 fdt_compat = fdt_getprop(fdt, 0, "compatible", &fdt_compat_len);
1647 debug("Fdt for comparison has no \"compatible\" property.\n");
1652 * Loop over the configurations in the FIT image.
1654 for (noffset = fdt_next_node(fit, confs_noffset, &ndepth);
1655 (noffset >= 0) && (ndepth > 0);
1656 noffset = fdt_next_node(fit, noffset, &ndepth)) {
1658 const char *kfdt_name;
1659 int kfdt_noffset, compat_noffset;
1660 const char *cur_fdt_compat;
1668 /* If there's a compat property in the config node, use that. */
1669 if (fdt_getprop(fit, noffset, "compatible", NULL)) {
1670 fdt = fit; /* search in FIT image */
1671 compat_noffset = noffset; /* search under config node */
1672 } else { /* Otherwise extract it from the kernel FDT. */
1673 kfdt_name = fdt_getprop(fit, noffset, "fdt", &len);
1675 debug("No fdt property found.\n");
1678 kfdt_noffset = fdt_subnode_offset(fit, images_noffset,
1680 if (kfdt_noffset < 0) {
1681 debug("No image node named \"%s\" found.\n",
1686 if (!fit_image_check_comp(fit, kfdt_noffset,
1688 debug("Can't extract compat from \"%s\" "
1689 "(compressed)\n", kfdt_name);
1693 /* search in this config's kernel FDT */
1694 if (fit_image_get_data(fit, kfdt_noffset, &fdt, &sz)) {
1695 debug("Failed to get fdt \"%s\".\n", kfdt_name);
1699 compat_noffset = 0; /* search kFDT under root node */
1702 len = fdt_compat_len;
1703 cur_fdt_compat = fdt_compat;
1705 * Look for a match for each U-Boot compatibility string in
1706 * turn in the compat string property.
1708 for (i = 0; len > 0 &&
1709 (!best_match_offset || best_match_pos > i); i++) {
1710 int cur_len = strlen(cur_fdt_compat) + 1;
1712 if (!fdt_node_check_compatible(fdt, compat_noffset,
1714 best_match_offset = noffset;
1719 cur_fdt_compat += cur_len;
1722 if (!best_match_offset) {
1723 debug("No match found.\n");
1727 return best_match_offset;
1730 int fit_conf_get_node(const void *fit, const char *conf_uname)
1732 int noffset, confs_noffset;
1735 char *conf_uname_copy = NULL;
1737 confs_noffset = fdt_path_offset(fit, FIT_CONFS_PATH);
1738 if (confs_noffset < 0) {
1739 debug("Can't find configurations parent node '%s' (%s)\n",
1740 FIT_CONFS_PATH, fdt_strerror(confs_noffset));
1741 return confs_noffset;
1744 if (conf_uname == NULL) {
1745 /* get configuration unit name from the default property */
1746 debug("No configuration specified, trying default...\n");
1747 if (!host_build() && IS_ENABLED(CONFIG_MULTI_DTB_FIT)) {
1748 noffset = fit_find_config_node(fit);
1751 conf_uname = fdt_get_name(fit, noffset, NULL);
1753 conf_uname = (char *)fdt_getprop(fit, confs_noffset,
1754 FIT_DEFAULT_PROP, &len);
1755 if (conf_uname == NULL) {
1756 fit_get_debug(fit, confs_noffset, FIT_DEFAULT_PROP,
1761 debug("Found default configuration: '%s'\n", conf_uname);
1764 s = strchr(conf_uname, '#');
1766 len = s - conf_uname;
1767 conf_uname_copy = malloc(len + 1);
1768 if (!conf_uname_copy) {
1769 debug("Can't allocate uname copy: '%s'\n",
1773 memcpy(conf_uname_copy, conf_uname, len);
1774 conf_uname_copy[len] = '\0';
1775 conf_uname = conf_uname_copy;
1778 noffset = fdt_subnode_offset(fit, confs_noffset, conf_uname);
1780 debug("Can't get node offset for configuration unit name: '%s' (%s)\n",
1781 conf_uname, fdt_strerror(noffset));
1784 if (conf_uname_copy)
1785 free(conf_uname_copy);
1790 int fit_conf_get_prop_node_count(const void *fit, int noffset,
1791 const char *prop_name)
1793 return fdt_stringlist_count(fit, noffset, prop_name);
1796 int fit_conf_get_prop_node_index(const void *fit, int noffset,
1797 const char *prop_name, int index)
1802 /* get kernel image unit name from configuration kernel property */
1803 uname = fdt_stringlist_get(fit, noffset, prop_name, index, &len);
1807 return fit_image_get_node(fit, uname);
1810 int fit_conf_get_prop_node(const void *fit, int noffset,
1811 const char *prop_name)
1813 return fit_conf_get_prop_node_index(fit, noffset, prop_name, 0);
1816 static int fit_image_select(const void *fit, int rd_noffset, int verify)
1818 fit_image_print(fit, rd_noffset, " ");
1821 puts(" Verifying Hash Integrity ... ");
1822 if (!fit_image_verify(fit, rd_noffset)) {
1823 puts("Bad Data Hash\n");
1832 int fit_get_node_from_config(bootm_headers_t *images, const char *prop_name,
1839 debug("* %s: using config '%s' from image at 0x%08lx\n",
1840 prop_name, images->fit_uname_cfg, addr);
1842 /* Check whether configuration has this property defined */
1843 fit_hdr = map_sysmem(addr, 0);
1844 cfg_noffset = fit_conf_get_node(fit_hdr, images->fit_uname_cfg);
1845 if (cfg_noffset < 0) {
1846 debug("* %s: no such config\n", prop_name);
1850 noffset = fit_conf_get_prop_node(fit_hdr, cfg_noffset, prop_name);
1852 debug("* %s: no '%s' in config\n", prop_name, prop_name);
1860 * fit_get_image_type_property() - get property name for IH_TYPE_...
1862 * @return the properly name where we expect to find the image in the
1865 static const char *fit_get_image_type_property(int type)
1868 * This is sort-of available in the uimage_type[] table in image.c
1869 * but we don't have access to the short name, and "fdt" is different
1870 * anyway. So let's just keep it here.
1873 case IH_TYPE_FLATDT:
1874 return FIT_FDT_PROP;
1875 case IH_TYPE_KERNEL:
1876 return FIT_KERNEL_PROP;
1877 case IH_TYPE_RAMDISK:
1878 return FIT_RAMDISK_PROP;
1879 case IH_TYPE_X86_SETUP:
1880 return FIT_SETUP_PROP;
1881 case IH_TYPE_LOADABLE:
1882 return FIT_LOADABLE_PROP;
1884 return FIT_FPGA_PROP;
1885 case IH_TYPE_STANDALONE:
1886 return FIT_STANDALONE_PROP;
1892 int fit_image_load(bootm_headers_t *images, ulong addr,
1893 const char **fit_unamep, const char **fit_uname_configp,
1894 int arch, int image_type, int bootstage_id,
1895 enum fit_load_op load_op, ulong *datap, ulong *lenp)
1897 int cfg_noffset, noffset;
1898 const char *fit_uname;
1899 const char *fit_uname_config;
1900 const char *fit_base_uname_config;
1906 ulong load, load_end, data, len;
1911 const char *prop_name;
1914 fit = map_sysmem(addr, 0);
1915 fit_uname = fit_unamep ? *fit_unamep : NULL;
1916 fit_uname_config = fit_uname_configp ? *fit_uname_configp : NULL;
1917 fit_base_uname_config = NULL;
1918 prop_name = fit_get_image_type_property(image_type);
1919 printf("## Loading %s from FIT Image at %08lx ...\n", prop_name, addr);
1921 bootstage_mark(bootstage_id + BOOTSTAGE_SUB_FORMAT);
1922 if (!fit_check_format(fit)) {
1923 printf("Bad FIT %s image format!\n", prop_name);
1924 bootstage_error(bootstage_id + BOOTSTAGE_SUB_FORMAT);
1927 bootstage_mark(bootstage_id + BOOTSTAGE_SUB_FORMAT_OK);
1929 /* get FIT component image node offset */
1930 bootstage_mark(bootstage_id + BOOTSTAGE_SUB_UNIT_NAME);
1931 noffset = fit_image_get_node(fit, fit_uname);
1934 * no image node unit name, try to get config
1935 * node first. If config unit node name is NULL
1936 * fit_conf_get_node() will try to find default config node
1938 bootstage_mark(bootstage_id + BOOTSTAGE_SUB_NO_UNIT_NAME);
1939 if (IMAGE_ENABLE_BEST_MATCH && !fit_uname_config) {
1940 cfg_noffset = fit_conf_find_compat(fit, gd_fdt_blob());
1942 cfg_noffset = fit_conf_get_node(fit,
1945 if (cfg_noffset < 0) {
1946 puts("Could not find configuration node\n");
1947 bootstage_error(bootstage_id +
1948 BOOTSTAGE_SUB_NO_UNIT_NAME);
1952 fit_base_uname_config = fdt_get_name(fit, cfg_noffset, NULL);
1953 printf(" Using '%s' configuration\n", fit_base_uname_config);
1954 /* Remember this config */
1955 if (image_type == IH_TYPE_KERNEL)
1956 images->fit_uname_cfg = fit_base_uname_config;
1958 if (FIT_IMAGE_ENABLE_VERIFY && images->verify) {
1959 puts(" Verifying Hash Integrity ... ");
1960 if (fit_config_verify(fit, cfg_noffset)) {
1961 puts("Bad Data Hash\n");
1962 bootstage_error(bootstage_id +
1963 BOOTSTAGE_SUB_HASH);
1969 bootstage_mark(BOOTSTAGE_ID_FIT_CONFIG);
1971 noffset = fit_conf_get_prop_node(fit, cfg_noffset,
1973 fit_uname = fit_get_name(fit, noffset, NULL);
1976 printf("Could not find subimage node type '%s'\n", prop_name);
1977 bootstage_error(bootstage_id + BOOTSTAGE_SUB_SUBNODE);
1981 printf(" Trying '%s' %s subimage\n", fit_uname, prop_name);
1983 ret = fit_image_select(fit, noffset, images->verify);
1985 bootstage_error(bootstage_id + BOOTSTAGE_SUB_HASH);
1989 bootstage_mark(bootstage_id + BOOTSTAGE_SUB_CHECK_ARCH);
1990 if (!host_build() && IS_ENABLED(CONFIG_SANDBOX)) {
1991 if (!fit_image_check_target_arch(fit, noffset)) {
1992 puts("Unsupported Architecture\n");
1993 bootstage_error(bootstage_id + BOOTSTAGE_SUB_CHECK_ARCH);
1999 fit_image_get_arch(fit, noffset, &os_arch);
2000 images->os.arch = os_arch;
2003 bootstage_mark(bootstage_id + BOOTSTAGE_SUB_CHECK_ALL);
2004 type_ok = fit_image_check_type(fit, noffset, image_type) ||
2005 fit_image_check_type(fit, noffset, IH_TYPE_FIRMWARE) ||
2006 (image_type == IH_TYPE_KERNEL &&
2007 fit_image_check_type(fit, noffset, IH_TYPE_KERNEL_NOLOAD));
2009 os_ok = image_type == IH_TYPE_FLATDT ||
2010 image_type == IH_TYPE_FPGA ||
2011 fit_image_check_os(fit, noffset, IH_OS_LINUX) ||
2012 fit_image_check_os(fit, noffset, IH_OS_U_BOOT) ||
2013 fit_image_check_os(fit, noffset, IH_OS_OPENRTOS) ||
2014 fit_image_check_os(fit, noffset, IH_OS_EFI) ||
2015 fit_image_check_os(fit, noffset, IH_OS_VXWORKS);
2018 * If either of the checks fail, we should report an error, but
2019 * if the image type is coming from the "loadables" field, we
2020 * don't care what it is
2022 if ((!type_ok || !os_ok) && image_type != IH_TYPE_LOADABLE) {
2023 fit_image_get_os(fit, noffset, &os);
2024 printf("No %s %s %s Image\n",
2025 genimg_get_os_name(os),
2026 genimg_get_arch_name(arch),
2027 genimg_get_type_name(image_type));
2028 bootstage_error(bootstage_id + BOOTSTAGE_SUB_CHECK_ALL);
2032 bootstage_mark(bootstage_id + BOOTSTAGE_SUB_CHECK_ALL_OK);
2034 /* get image data address and length */
2035 if (fit_image_get_data_and_size(fit, noffset,
2036 (const void **)&buf, &size)) {
2037 printf("Could not find %s subimage data!\n", prop_name);
2038 bootstage_error(bootstage_id + BOOTSTAGE_SUB_GET_DATA);
2042 /* Decrypt data before uncompress/move */
2043 if (IS_ENABLED(CONFIG_FIT_CIPHER) && IMAGE_ENABLE_DECRYPT) {
2044 puts(" Decrypting Data ... ");
2045 if (fit_image_uncipher(fit, noffset, &buf, &size)) {
2052 /* perform any post-processing on the image data */
2053 if (!host_build() && IS_ENABLED(CONFIG_FIT_IMAGE_POST_PROCESS))
2054 board_fit_image_post_process(&buf, &size);
2058 bootstage_mark(bootstage_id + BOOTSTAGE_SUB_GET_DATA_OK);
2060 data = map_to_sysmem(buf);
2062 if (load_op == FIT_LOAD_IGNORED) {
2064 } else if (fit_image_get_load(fit, noffset, &load)) {
2065 if (load_op == FIT_LOAD_REQUIRED) {
2066 printf("Can't get %s subimage load address!\n",
2068 bootstage_error(bootstage_id + BOOTSTAGE_SUB_LOAD);
2071 } else if (load_op != FIT_LOAD_OPTIONAL_NON_ZERO || load) {
2072 ulong image_start, image_end;
2075 * move image data to the load address,
2076 * make sure we don't overwrite initial image
2079 image_end = addr + fit_get_size(fit);
2081 load_end = load + len;
2082 if (image_type != IH_TYPE_KERNEL &&
2083 load < image_end && load_end > image_start) {
2084 printf("Error: %s overwritten\n", prop_name);
2088 printf(" Loading %s from 0x%08lx to 0x%08lx\n",
2089 prop_name, data, load);
2091 load = data; /* No load address specified */
2094 comp = IH_COMP_NONE;
2096 /* Kernel images get decompressed later in bootm_load_os(). */
2097 if (!fit_image_get_comp(fit, noffset, &comp) &&
2098 comp != IH_COMP_NONE &&
2099 !(image_type == IH_TYPE_KERNEL ||
2100 image_type == IH_TYPE_KERNEL_NOLOAD ||
2101 image_type == IH_TYPE_RAMDISK)) {
2102 ulong max_decomp_len = len * 20;
2104 loadbuf = malloc(max_decomp_len);
2105 load = map_to_sysmem(loadbuf);
2107 loadbuf = map_sysmem(load, max_decomp_len);
2109 if (image_decomp(comp, load, data, image_type,
2110 loadbuf, buf, len, max_decomp_len, &load_end)) {
2111 printf("Error decompressing %s\n", prop_name);
2115 len = load_end - load;
2116 } else if (load != data) {
2117 loadbuf = map_sysmem(load, len);
2118 memcpy(loadbuf, buf, len);
2121 if (image_type == IH_TYPE_RAMDISK && comp != IH_COMP_NONE)
2122 puts("WARNING: 'compression' nodes for ramdisks are deprecated,"
2123 " please fix your .its file!\n");
2125 /* verify that image data is a proper FDT blob */
2126 if (image_type == IH_TYPE_FLATDT && fdt_check_header(loadbuf)) {
2127 puts("Subimage data is not a FDT");
2131 bootstage_mark(bootstage_id + BOOTSTAGE_SUB_LOAD);
2136 *fit_unamep = (char *)fit_uname;
2137 if (fit_uname_configp)
2138 *fit_uname_configp = (char *)(fit_uname_config ? :
2139 fit_base_uname_config);
2144 int boot_get_setup_fit(bootm_headers_t *images, uint8_t arch,
2145 ulong *setup_start, ulong *setup_len)
2152 addr = map_to_sysmem(images->fit_hdr_os);
2153 noffset = fit_get_node_from_config(images, FIT_SETUP_PROP, addr);
2157 ret = fit_image_load(images, addr, NULL, NULL, arch,
2158 IH_TYPE_X86_SETUP, BOOTSTAGE_ID_FIT_SETUP_START,
2159 FIT_LOAD_REQUIRED, setup_start, &len);
2165 int boot_get_fdt_fit(bootm_headers_t *images, ulong addr,
2166 const char **fit_unamep, const char **fit_uname_configp,
2167 int arch, ulong *datap, ulong *lenp)
2169 int fdt_noffset, cfg_noffset, count;
2171 const char *fit_uname = NULL;
2172 const char *fit_uname_config = NULL;
2173 char *fit_uname_config_copy = NULL;
2174 char *next_config = NULL;
2176 #ifdef CONFIG_OF_LIBFDT_OVERLAY
2177 ulong image_start, image_end;
2178 ulong ovload, ovlen;
2179 const char *uconfig;
2182 int i, err, noffset, ov_noffset;
2185 fit_uname = fit_unamep ? *fit_unamep : NULL;
2187 if (fit_uname_configp && *fit_uname_configp) {
2188 fit_uname_config_copy = strdup(*fit_uname_configp);
2189 if (!fit_uname_config_copy)
2192 next_config = strchr(fit_uname_config_copy, '#');
2194 *next_config++ = '\0';
2195 if (next_config - 1 > fit_uname_config_copy)
2196 fit_uname_config = fit_uname_config_copy;
2199 fdt_noffset = fit_image_load(images,
2200 addr, &fit_uname, &fit_uname_config,
2201 arch, IH_TYPE_FLATDT,
2202 BOOTSTAGE_ID_FIT_FDT_START,
2203 FIT_LOAD_OPTIONAL, &load, &len);
2205 if (fdt_noffset < 0)
2208 debug("fit_uname=%s, fit_uname_config=%s\n",
2209 fit_uname ? fit_uname : "<NULL>",
2210 fit_uname_config ? fit_uname_config : "<NULL>");
2212 fit = map_sysmem(addr, 0);
2214 cfg_noffset = fit_conf_get_node(fit, fit_uname_config);
2216 /* single blob, or error just return as well */
2217 count = fit_conf_get_prop_node_count(fit, cfg_noffset, FIT_FDT_PROP);
2218 if (count <= 1 && !next_config)
2221 /* we need to apply overlays */
2223 #ifdef CONFIG_OF_LIBFDT_OVERLAY
2225 image_end = addr + fit_get_size(fit);
2226 /* verify that relocation took place by load address not being in fit */
2227 if (load >= image_start && load < image_end) {
2228 /* check is simplified; fit load checks for overlaps */
2229 printf("Overlayed FDT requires relocation\n");
2230 fdt_noffset = -EBADF;
2234 base = map_sysmem(load, len);
2236 /* apply extra configs in FIT first, followed by args */
2237 for (i = 1; ; i++) {
2239 noffset = fit_conf_get_prop_node_index(fit, cfg_noffset,
2241 uname = fit_get_name(fit, noffset, NULL);
2246 uconfig = next_config;
2247 next_config = strchr(next_config, '#');
2249 *next_config++ = '\0';
2253 * fit_image_load() would load the first FDT from the
2254 * extra config only when uconfig is specified.
2255 * Check if the extra config contains multiple FDTs and
2258 cfg_noffset = fit_conf_get_node(fit, uconfig);
2261 count = fit_conf_get_prop_node_count(fit, cfg_noffset,
2265 debug("%d: using uname=%s uconfig=%s\n", i, uname, uconfig);
2267 ov_noffset = fit_image_load(images,
2268 addr, &uname, &uconfig,
2269 arch, IH_TYPE_FLATDT,
2270 BOOTSTAGE_ID_FIT_FDT_START,
2271 FIT_LOAD_REQUIRED, &ovload, &ovlen);
2272 if (ov_noffset < 0) {
2273 printf("load of %s failed\n", uname);
2276 debug("%s loaded at 0x%08lx len=0x%08lx\n",
2277 uname, ovload, ovlen);
2278 ov = map_sysmem(ovload, ovlen);
2280 base = map_sysmem(load, len + ovlen);
2281 err = fdt_open_into(base, base, len + ovlen);
2283 printf("failed on fdt_open_into\n");
2287 /* the verbose method prints out messages on error */
2288 err = fdt_overlay_apply_verbose(base, ov);
2294 len = fdt_totalsize(base);
2297 printf("config with overlays but CONFIG_OF_LIBFDT_OVERLAY not set\n");
2298 fdt_noffset = -EBADF;
2307 *fit_unamep = fit_uname;
2308 if (fit_uname_configp)
2309 *fit_uname_configp = fit_uname_config;
2311 if (fit_uname_config_copy)
2312 free(fit_uname_config_copy);