1 // SPDX-License-Identifier: GPL-2.0+
3 * Copyright (C) 2016 Google, Inc
4 * Written by Simon Glass <sjg@chromium.org>
17 #include <asm/global_data.h>
19 #include <linux/libfdt.h>
20 #include <linux/printk.h>
22 DECLARE_GLOBAL_DATA_PTR
;
25 const void *fit
; /* Pointer to a valid FIT blob */
26 size_t ext_data_offset
; /* Offset to FIT external data (end of FIT) */
27 int images_node
; /* FDT offset to "/images" node */
28 int conf_node
; /* FDT offset to selected configuration node */
31 __weak ulong
board_spl_fit_size_align(ulong size
)
36 static int find_node_from_desc(const void *fit
, int node
, const char *str
)
43 /* iterate the FIT nodes and find a matching description */
44 for (child
= fdt_first_subnode(fit
, node
); child
>= 0;
45 child
= fdt_next_subnode(fit
, child
)) {
47 const char *desc
= fdt_getprop(fit
, child
, FIT_DESC_PROP
, &len
);
52 if (!strcmp(desc
, str
))
60 * spl_fit_get_image_name(): By using the matching configuration subnode,
61 * retrieve the name of an image, specified by a property name and an index
63 * @fit: Pointer to the FDT blob.
64 * @images: Offset of the /images subnode.
65 * @type: Name of the property within the configuration subnode.
66 * @index: Index into the list of strings in this property.
67 * @outname: Name of the image
69 * Return: 0 on success, or a negative error number
71 static int spl_fit_get_image_name(const struct spl_fit_info
*ctx
,
72 const char *type
, int index
,
75 struct udevice
*sysinfo
;
76 const char *name
, *str
;
77 __maybe_unused
int node
;
81 name
= fdt_getprop(ctx
->fit
, ctx
->conf_node
, type
, &len
);
83 debug("cannot find property '%s': %d\n", type
, len
);
88 for (i
= 0; i
< index
; i
++) {
89 str
= strchr(str
, '\0') + 1;
90 if (!str
|| (str
- name
>= len
)) {
96 if (!found
&& CONFIG_IS_ENABLED(SYSINFO
) && !sysinfo_get(&sysinfo
)) {
99 * no string in the property for this index. Check if the
100 * sysinfo-level code can supply one.
102 rc
= sysinfo_detect(sysinfo
);
106 rc
= sysinfo_get_fit_loadable(sysinfo
, index
- i
- 1, type
,
108 if (rc
&& rc
!= -ENOENT
)
113 * The sysinfo provided a name for a loadable.
114 * Try to match it against the description properties
115 * first. If no matching node is found, use it as a
119 int images
= fdt_path_offset(ctx
->fit
, FIT_IMAGES_PATH
);
121 node
= find_node_from_desc(ctx
->fit
, images
, str
);
123 str
= fdt_get_name(ctx
->fit
, node
, NULL
);
130 debug("no string for index %d\n", index
);
139 * spl_fit_get_image_node(): By using the matching configuration subnode,
140 * retrieve the name of an image, specified by a property name and an index
142 * @fit: Pointer to the FDT blob.
143 * @images: Offset of the /images subnode.
144 * @type: Name of the property within the configuration subnode.
145 * @index: Index into the list of strings in this property.
147 * Return: the node offset of the respective image node or a negative
150 static int spl_fit_get_image_node(const struct spl_fit_info
*ctx
,
151 const char *type
, int index
)
157 err
= spl_fit_get_image_name(ctx
, type
, index
, &str
);
161 debug("%s: '%s'\n", type
, str
);
163 node
= fdt_subnode_offset(ctx
->fit
, ctx
->images_node
, str
);
165 pr_err("cannot find image node '%s': %d\n", str
, node
);
172 static int get_aligned_image_offset(struct spl_load_info
*info
, int offset
)
174 return ALIGN_DOWN(offset
, spl_get_bl_len(info
));
177 static int get_aligned_image_overhead(struct spl_load_info
*info
, int offset
)
179 return offset
& (spl_get_bl_len(info
) - 1);
182 static int get_aligned_image_size(struct spl_load_info
*info
, int data_size
,
185 data_size
= data_size
+ get_aligned_image_overhead(info
, offset
);
187 return ALIGN(data_size
, spl_get_bl_len(info
));
191 * load_simple_fit(): load the image described in a certain FIT node
192 * @info: points to information about the device to load data from
193 * @sector: the start sector of the FIT image on the device
194 * @ctx: points to the FIT context structure
195 * @node: offset of the DT node describing the image to load (relative
197 * @image_info: will be filled with information about the loaded image
198 * If the FIT node does not contain a "load" (address) property,
199 * the image gets loaded to the address pointed to by the
200 * load_addr member in this struct, if load_addr is not 0
202 * Return: 0 on success or a negative error number.
204 static int load_simple_fit(struct spl_load_info
*info
, ulong fit_offset
,
205 const struct spl_fit_info
*ctx
, int node
,
206 struct spl_image_info
*image_info
)
216 uint8_t image_comp
= -1, type
= -1;
218 const void *fit
= ctx
->fit
;
219 bool external_data
= false;
221 if (IS_ENABLED(CONFIG_SPL_FPGA
) ||
222 (IS_ENABLED(CONFIG_SPL_OS_BOOT
) && spl_decompression_enabled())) {
223 if (fit_image_get_type(fit
, node
, &type
))
224 puts("Cannot get image type.\n");
226 debug("%s ", genimg_get_type_name(type
));
229 if (spl_decompression_enabled()) {
230 fit_image_get_comp(fit
, node
, &image_comp
);
231 debug("%s ", genimg_get_comp_name(image_comp
));
234 if (fit_image_get_load(fit
, node
, &load_addr
)) {
235 if (!image_info
->load_addr
) {
236 printf("Can't load %s: No load address and no buffer\n",
237 fit_get_name(fit
, node
, NULL
));
240 load_addr
= image_info
->load_addr
;
243 if (!fit_image_get_data_position(fit
, node
, &offset
)) {
244 external_data
= true;
245 } else if (!fit_image_get_data_offset(fit
, node
, &offset
)) {
246 offset
+= ctx
->ext_data_offset
;
247 external_data
= true;
254 if (fit_image_get_data_size(fit
, node
, &len
))
257 /* Dont bother to copy 0 byte data, but warn, though */
259 log_warning("%s: Skip load '%s': image size is 0!\n",
260 __func__
, fit_get_name(fit
, node
, NULL
));
264 if (spl_decompression_enabled() &&
265 (image_comp
== IH_COMP_GZIP
|| image_comp
== IH_COMP_LZMA
))
266 src_ptr
= map_sysmem(ALIGN(CONFIG_SYS_LOAD_ADDR
, ARCH_DMA_MINALIGN
), len
);
268 src_ptr
= map_sysmem(ALIGN(load_addr
, ARCH_DMA_MINALIGN
), len
);
271 overhead
= get_aligned_image_overhead(info
, offset
);
272 size
= get_aligned_image_size(info
, length
, offset
);
276 get_aligned_image_offset(info
, offset
), size
,
280 debug("External data: dst=%p, offset=%x, size=%lx\n",
281 src_ptr
, offset
, (unsigned long)length
);
282 src
= src_ptr
+ overhead
;
285 if (fit_image_get_data(fit
, node
, &data
, &length
)) {
286 puts("Cannot get image data/size\n");
289 debug("Embedded data: dst=%lx, size=%lx\n", load_addr
,
290 (unsigned long)length
);
291 src
= (void *)data
; /* cast away const */
294 if (CONFIG_IS_ENABLED(FIT_SIGNATURE
)) {
295 printf("## Checking hash(es) for Image %s ... ",
296 fit_get_name(fit
, node
, NULL
));
297 if (!fit_image_verify_with_data(fit
, node
, gd_fdt_blob(), src
,
303 if (CONFIG_IS_ENABLED(FIT_IMAGE_POST_PROCESS
))
304 board_fit_image_post_process(fit
, node
, &src
, &length
);
306 load_ptr
= map_sysmem(load_addr
, length
);
307 if (IS_ENABLED(CONFIG_SPL_GZIP
) && image_comp
== IH_COMP_GZIP
) {
309 if (gunzip(load_ptr
, CONFIG_SYS_BOOTM_LEN
, src
, &size
)) {
310 puts("Uncompressing error\n");
314 } else if (IS_ENABLED(CONFIG_SPL_LZMA
) && image_comp
== IH_COMP_LZMA
) {
315 size
= CONFIG_SYS_BOOTM_LEN
;
318 if (image_decomp(IH_COMP_LZMA
, CONFIG_SYS_LOAD_ADDR
, 0, 0,
319 load_ptr
, src
, length
, size
, &loadEnd
)) {
320 puts("Uncompressing error\n");
323 length
= loadEnd
- CONFIG_SYS_LOAD_ADDR
;
325 memcpy(load_ptr
, src
, length
);
331 image_info
->load_addr
= load_addr
;
332 image_info
->size
= length
;
334 if (!fit_image_get_entry(fit
, node
, &entry_point
))
335 image_info
->entry_point
= entry_point
;
337 image_info
->entry_point
= FDT_ERROR
;
343 static bool os_takes_devicetree(uint8_t os
)
349 return IS_ENABLED(CONFIG_SPL_OS_BOOT
) ||
350 IS_ENABLED(CONFIG_SPL_OPENSBI
);
356 __weak
int board_spl_fit_append_fdt_skip(const char *name
)
358 return 0; /* Do not skip */
361 static int spl_fit_append_fdt(struct spl_image_info
*spl_image
,
362 struct spl_load_info
*info
, ulong offset
,
363 const struct spl_fit_info
*ctx
)
365 struct spl_image_info image_info
;
366 int node
, ret
= 0, index
= 0;
369 * Use the address following the image as target address for the
372 image_info
.load_addr
= spl_image
->load_addr
+ spl_image
->size
;
374 /* Figure out which device tree the board wants to use */
375 node
= spl_fit_get_image_node(ctx
, FIT_FDT_PROP
, index
++);
379 debug("%s: cannot find FDT node\n", __func__
);
382 * U-Boot did not find a device tree inside the FIT image. Use
383 * the U-Boot device tree instead.
389 * Make the load-address of the FDT available for the SPL
392 size
= fdt_totalsize(gd
->fdt_blob
);
393 spl_image
->fdt_addr
= map_sysmem(image_info
.load_addr
, size
);
394 memcpy(spl_image
->fdt_addr
, gd
->fdt_blob
, size
);
396 ret
= load_simple_fit(info
, offset
, ctx
, node
, &image_info
);
400 spl_image
->fdt_addr
= phys_to_virt(image_info
.load_addr
);
403 if (CONFIG_IS_ENABLED(FIT_IMAGE_TINY
))
406 #if CONFIG_IS_ENABLED(LOAD_FIT_APPLY_OVERLAY)
407 void *tmpbuffer
= NULL
;
412 ret
= spl_fit_get_image_name(ctx
, FIT_FDT_PROP
, index
, &str
);
414 debug("%s: No additional FDT node\n", __func__
);
417 } else if (ret
< 0) {
421 ret
= board_spl_fit_append_fdt_skip(str
);
425 node
= fdt_subnode_offset(ctx
->fit
, ctx
->images_node
, str
);
427 debug("%s: unable to find FDT node %d\n",
434 * allocate memory to store the DT overlay
435 * before it is applied. It may not be used
436 * depending on how the overlay is stored, so
437 * don't fail yet if the allocation failed.
439 size_t size
= CONFIG_SPL_LOAD_FIT_APPLY_OVERLAY_BUF_SZ
;
441 tmpbuffer
= malloc_cache_aligned(size
);
443 debug("%s: unable to allocate space for overlays\n",
446 image_info
.load_addr
= (ulong
)tmpbuffer
;
447 ret
= load_simple_fit(info
, offset
, ctx
, node
,
452 /* Make room in FDT for changes from the overlay */
453 ret
= fdt_increase_size(spl_image
->fdt_addr
,
458 ret
= fdt_overlay_apply_verbose(spl_image
->fdt_addr
,
459 (void *)image_info
.load_addr
);
461 pr_err("failed to apply DT overlay %s\n",
462 fit_get_name(ctx
->fit
, node
, NULL
));
466 debug("%s: DT overlay %s applied\n", __func__
,
467 fit_get_name(ctx
->fit
, node
, NULL
));
473 /* Try to make space, so we can inject details on the loadables */
474 ret
= fdt_shrink_to_minimum(spl_image
->fdt_addr
, 8192);
481 static int spl_fit_record_loadable(const struct spl_fit_info
*ctx
, int index
,
482 void *blob
, struct spl_image_info
*image
)
488 if (CONFIG_IS_ENABLED(FIT_IMAGE_TINY
))
491 ret
= spl_fit_get_image_name(ctx
, "loadables", index
, &name
);
495 node
= spl_fit_get_image_node(ctx
, "loadables", index
);
497 ret
= fdt_record_loadable(blob
, index
, name
, image
->load_addr
,
498 image
->size
, image
->entry_point
,
499 fdt_getprop(ctx
->fit
, node
, FIT_TYPE_PROP
, NULL
),
500 fdt_getprop(ctx
->fit
, node
, FIT_OS_PROP
, NULL
),
501 fdt_getprop(ctx
->fit
, node
, FIT_ARCH_PROP
, NULL
));
506 static int spl_fit_image_is_fpga(const void *fit
, int node
)
510 if (!IS_ENABLED(CONFIG_SPL_FPGA
))
513 type
= fdt_getprop(fit
, node
, FIT_TYPE_PROP
, NULL
);
517 return !strcmp(type
, "fpga");
520 static int spl_fit_image_get_os(const void *fit
, int noffset
, uint8_t *os
)
522 if (!CONFIG_IS_ENABLED(FIT_IMAGE_TINY
) || CONFIG_IS_ENABLED(OS_BOOT
))
523 return fit_image_get_os(fit
, noffset
, os
);
525 const char *name
= fdt_getprop(fit
, noffset
, FIT_OS_PROP
, NULL
);
530 * We don't care what the type of the image actually is,
531 * only whether or not it is U-Boot. This saves some
532 * space by omitting the large table of OS types.
534 if (!strcmp(name
, "u-boot"))
543 * The purpose of the FIT load buffer is to provide a memory location that is
544 * independent of the load address of any FIT component.
546 static void *spl_get_fit_load_buffer(size_t size
)
550 buf
= malloc_cache_aligned(size
);
552 pr_err("Could not get FIT buffer of %lu bytes\n", (ulong
)size
);
554 if (IS_ENABLED(CONFIG_SPL_SYS_MALLOC
))
555 pr_err("\tcheck CONFIG_SPL_SYS_MALLOC_SIZE\n");
557 pr_err("\tcheck CONFIG_SPL_SYS_MALLOC_F_LEN\n");
559 buf
= spl_get_load_buffer(0, size
);
564 __weak
void *board_spl_fit_buffer_addr(ulong fit_size
, int sectors
, int bl_len
)
566 return spl_get_fit_load_buffer(sectors
* bl_len
);
570 * Weak default function to allow customizing SPL fit loading for load-only
571 * use cases by allowing to skip the parsing/processing of the FIT contents
572 * (so that this can be done separately in a more customized fashion)
574 __weak
bool spl_load_simple_fit_skip_processing(void)
580 * Weak default function to allow fixes after fit header
583 __weak
void *spl_load_simple_fit_fix_load(const void *fit
)
588 static void warn_deprecated(const char *msg
)
590 printf("DEPRECATED: %s\n", msg
);
591 printf("\tSee doc/uImage.FIT/source_file_format.txt\n");
594 static int spl_fit_upload_fpga(struct spl_fit_info
*ctx
, int node
,
595 struct spl_image_info
*fpga_image
)
597 const char *compatible
;
602 debug("FPGA bitstream at: %x, size: %x\n",
603 (u32
)fpga_image
->load_addr
, fpga_image
->size
);
605 compatible
= fdt_getprop(ctx
->fit
, node
, "compatible", NULL
);
607 warn_deprecated("'fpga' image without 'compatible' property");
609 if (CONFIG_IS_ENABLED(FPGA_LOAD_SECURE
))
610 flags
= fpga_compatible2flag(devnum
, compatible
);
611 if (strcmp(compatible
, "u-boot,fpga-legacy"))
612 debug("Ignoring compatible = %s property\n",
616 ret
= fpga_load(devnum
, (void *)fpga_image
->load_addr
,
617 fpga_image
->size
, BIT_FULL
, flags
);
619 printf("%s: Cannot load the image to the FPGA\n", __func__
);
623 puts("FPGA image loaded from FIT\n");
628 static int spl_fit_load_fpga(struct spl_fit_info
*ctx
,
629 struct spl_load_info
*info
, ulong offset
)
633 struct spl_image_info fpga_image
= {
637 node
= spl_fit_get_image_node(ctx
, "fpga", 0);
641 warn_deprecated("'fpga' property in config node. Use 'loadables'");
643 /* Load the image and set up the fpga_image structure */
644 ret
= load_simple_fit(info
, offset
, ctx
, node
, &fpga_image
);
646 printf("%s: Cannot load the FPGA: %i\n", __func__
, ret
);
650 return spl_fit_upload_fpga(ctx
, node
, &fpga_image
);
653 static int spl_simple_fit_read(struct spl_fit_info
*ctx
,
654 struct spl_load_info
*info
, ulong offset
,
655 const void *fit_header
)
657 unsigned long count
, size
;
661 * For FIT with external data, figure out where the external images
662 * start. This is the base for the data-offset properties in each
665 size
= ALIGN(fdt_totalsize(fit_header
), 4);
666 size
= board_spl_fit_size_align(size
);
667 ctx
->ext_data_offset
= ALIGN(size
, 4);
670 * So far we only have one block of data from the FIT. Read the entire
671 * thing, including that first block.
673 * For FIT with data embedded, data is loaded as part of FIT image.
674 * For FIT with external data, data is not loaded in this step.
676 size
= get_aligned_image_size(info
, size
, 0);
677 buf
= board_spl_fit_buffer_addr(size
, size
, 1);
679 count
= info
->read(info
, offset
, size
, buf
);
681 debug("fit read offset %lx, size=%lu, dst=%p, count=%lu\n",
682 offset
, size
, buf
, count
);
684 return (count
== 0) ? -EIO
: 0;
687 static int spl_simple_fit_parse(struct spl_fit_info
*ctx
)
689 /* Find the correct subnode under "/configurations" */
690 ctx
->conf_node
= fit_find_config_node(ctx
->fit
);
691 if (ctx
->conf_node
< 0)
694 if (IS_ENABLED(CONFIG_SPL_FIT_SIGNATURE
)) {
695 printf("## Checking hash(es) for config %s ... ",
696 fit_get_name(ctx
->fit
, ctx
->conf_node
, NULL
));
697 if (fit_config_verify(ctx
->fit
, ctx
->conf_node
))
702 /* find the node holding the images information */
703 ctx
->images_node
= fdt_path_offset(ctx
->fit
, FIT_IMAGES_PATH
);
704 if (ctx
->images_node
< 0) {
705 debug("%s: Cannot find /images node: %d\n", __func__
,
713 int spl_load_simple_fit(struct spl_image_info
*spl_image
,
714 struct spl_load_info
*info
, ulong offset
, void *fit
)
716 struct spl_image_info image_info
;
717 struct spl_fit_info ctx
;
723 ret
= spl_simple_fit_read(&ctx
, info
, offset
, fit
);
727 /* skip further processing if requested to enable load-only use cases */
728 if (spl_load_simple_fit_skip_processing())
731 ctx
.fit
= spl_load_simple_fit_fix_load(ctx
.fit
);
733 ret
= spl_simple_fit_parse(&ctx
);
737 if (IS_ENABLED(CONFIG_SPL_FPGA
))
738 spl_fit_load_fpga(&ctx
, info
, offset
);
741 * Find the U-Boot image using the following search order:
742 * - start at 'firmware' (e.g. an ARM Trusted Firmware)
743 * - fall back 'kernel' (e.g. a Falcon-mode OS boot
744 * - fall back to using the first 'loadables' entry
747 node
= spl_fit_get_image_node(&ctx
, FIT_FIRMWARE_PROP
, 0);
749 if (node
< 0 && IS_ENABLED(CONFIG_SPL_OS_BOOT
))
750 node
= spl_fit_get_image_node(&ctx
, FIT_KERNEL_PROP
, 0);
753 debug("could not find firmware image, trying loadables...\n");
754 node
= spl_fit_get_image_node(&ctx
, "loadables", 0);
756 * If we pick the U-Boot image from "loadables", start at
757 * the second image when later loading additional images.
762 debug("%s: Cannot find u-boot image node: %d\n",
767 /* Load the image and set up the spl_image structure */
768 ret
= load_simple_fit(info
, offset
, &ctx
, node
, spl_image
);
773 * For backward compatibility, we treat the first node that is
774 * as a U-Boot image, if no OS-type has been declared.
776 if (!spl_fit_image_get_os(ctx
.fit
, node
, &spl_image
->os
))
777 debug("Image OS is %s\n", genimg_get_os_name(spl_image
->os
));
778 else if (!IS_ENABLED(CONFIG_SPL_OS_BOOT
))
779 spl_image
->os
= IH_OS_U_BOOT
;
782 * Booting a next-stage U-Boot may require us to append the FDT.
783 * We allow this to fail, as the U-Boot image might embed its FDT.
785 if (os_takes_devicetree(spl_image
->os
)) {
786 ret
= spl_fit_append_fdt(spl_image
, info
, offset
, &ctx
);
787 if (ret
< 0 && spl_image
->os
!= IH_OS_U_BOOT
)
791 firmware_node
= node
;
792 /* Now check if there are more images for us to load */
794 uint8_t os_type
= IH_OS_INVALID
;
796 node
= spl_fit_get_image_node(&ctx
, "loadables", index
);
801 * if the firmware is also a loadable, skip it because
802 * it already has been loaded. This is typically the case with
803 * u-boot.img generated by mkimage.
805 if (firmware_node
== node
)
808 image_info
.load_addr
= 0;
809 ret
= load_simple_fit(info
, offset
, &ctx
, node
, &image_info
);
811 printf("%s: can't load image loadables index %d (ret = %d)\n",
812 __func__
, index
, ret
);
816 if (spl_fit_image_is_fpga(ctx
.fit
, node
))
817 spl_fit_upload_fpga(&ctx
, node
, &image_info
);
819 if (!spl_fit_image_get_os(ctx
.fit
, node
, &os_type
))
820 debug("Loadable is %s\n", genimg_get_os_name(os_type
));
822 if (os_takes_devicetree(os_type
)) {
823 spl_fit_append_fdt(&image_info
, info
, offset
, &ctx
);
824 spl_image
->fdt_addr
= image_info
.fdt_addr
;
828 * If the "firmware" image did not provide an entry point,
829 * use the first valid entry point from the loadables.
831 if (spl_image
->entry_point
== FDT_ERROR
&&
832 image_info
.entry_point
!= FDT_ERROR
)
833 spl_image
->entry_point
= image_info
.entry_point
;
835 /* Record our loadables into the FDT */
836 if (spl_image
->fdt_addr
)
837 spl_fit_record_loadable(&ctx
, index
,
843 * If a platform does not provide CONFIG_SYS_UBOOT_START, U-Boot's
844 * Makefile will set it to 0 and it will end up as the entry point
845 * here. What it actually means is: use the load address.
847 if (spl_image
->entry_point
== FDT_ERROR
|| spl_image
->entry_point
== 0)
848 spl_image
->entry_point
= spl_image
->load_addr
;
850 spl_image
->flags
|= SPL_FIT_FOUND
;
855 /* Parse and load full fitImage in SPL */
856 int spl_load_fit_image(struct spl_image_info
*spl_image
,
857 const struct legacy_img_hdr
*header
)
859 struct bootm_headers images
;
860 const char *fit_uname_config
= NULL
;
863 ulong fw_data
= 0, dt_data
= 0, img_data
= 0;
864 ulong fw_len
= 0, dt_len
= 0, img_len
= 0;
865 int idx
, conf_noffset
;
868 #ifdef CONFIG_SPL_FIT_SIGNATURE
871 ret
= fit_image_load(&images
, virt_to_phys((void *)header
),
872 NULL
, &fit_uname_config
,
873 IH_ARCH_DEFAULT
, IH_TYPE_STANDALONE
, -1,
874 FIT_LOAD_OPTIONAL
, &fw_data
, &fw_len
);
876 printf("DEPRECATED: 'standalone = ' property.");
877 printf("Please use either 'firmware =' or 'kernel ='\n");
879 ret
= fit_image_load(&images
, virt_to_phys((void *)header
),
880 NULL
, &fit_uname_config
, IH_ARCH_DEFAULT
,
881 IH_TYPE_FIRMWARE
, -1, FIT_LOAD_OPTIONAL
,
886 ret
= fit_image_load(&images
, virt_to_phys((void *)header
),
887 NULL
, &fit_uname_config
, IH_ARCH_DEFAULT
,
888 IH_TYPE_KERNEL
, -1, FIT_LOAD_OPTIONAL
,
895 spl_image
->size
= fw_len
;
896 spl_image
->load_addr
= fw_data
;
897 if (fit_image_get_entry(header
, ret
, &spl_image
->entry_point
))
898 spl_image
->entry_point
= fw_data
;
899 if (fit_image_get_os(header
, ret
, &spl_image
->os
))
900 spl_image
->os
= IH_OS_INVALID
;
901 spl_image
->name
= genimg_get_os_name(spl_image
->os
);
903 debug(SPL_TPL_PROMPT
"payload image: %32s load addr: 0x%lx size: %d\n",
904 spl_image
->name
, spl_image
->load_addr
, spl_image
->size
);
906 #ifdef CONFIG_SPL_FIT_SIGNATURE
909 ret
= fit_image_load(&images
, virt_to_phys((void *)header
), NULL
,
910 &fit_uname_config
, IH_ARCH_DEFAULT
, IH_TYPE_FLATDT
,
911 -1, FIT_LOAD_OPTIONAL
, &dt_data
, &dt_len
);
913 spl_image
->fdt_addr
= (void *)dt_data
;
915 if (spl_image
->os
== IH_OS_U_BOOT
) {
916 /* HACK: U-Boot expects FDT at a specific address */
917 fdt_hack
= spl_image
->load_addr
+ spl_image
->size
;
918 fdt_hack
= (fdt_hack
+ 3) & ~3;
919 debug("Relocating FDT to %p\n", spl_image
->fdt_addr
);
920 memcpy((void *)fdt_hack
, spl_image
->fdt_addr
, dt_len
);
924 conf_noffset
= fit_conf_get_node((const void *)header
,
926 if (conf_noffset
< 0)
930 uname
= fdt_stringlist_get((const void *)header
, conf_noffset
,
931 FIT_LOADABLE_PROP
, idx
,
934 #ifdef CONFIG_SPL_FIT_SIGNATURE
937 ret
= fit_image_load(&images
, (ulong
)header
,
938 &uname
, &fit_uname_config
,
939 IH_ARCH_DEFAULT
, IH_TYPE_LOADABLE
, -1,
940 FIT_LOAD_OPTIONAL_NON_ZERO
,
941 &img_data
, &img_len
);