Eric Lee / smarc-uboot | Embedian Git Server

Commit 5fd13d973613d308663f97b51059ecd9179baf09

Authored by York Sun 2017-08-16 02:14:44 +0800

spl: fit: Support both external and embedded data

SPL supports U-Boot image in FIT format which has data outside of
FIT structure. This adds support for embedded data for normal FIT
images.

Signed-off-by: York Sun <york.sun@nxp.com>
Reviewed-by: Tom Rini <trini@konsulko.com>
Reviewed-by: Simon Glass <sjg@chromium.org>

Showing 2 changed files with 37 additions and 19 deletions Inline Diff

common/spl/spl_fit.c
doc/uImage.FIT/source_file_format.txt

common/spl/spl_fit.c

Diff comments View file @ 5fd13d9

 /*
  * Copyright (C) 2016 Google, Inc
  * Written by Simon Glass <sjg@chromium.org>
  *
  * SPDX-License-Identifier:     GPL-2.0+
  */
 #include <common.h>
 #include <errno.h>
 #include <image.h>
 #include <libfdt.h>
 #include <spl.h>
 #ifndef CONFIG_SYS_BOOTM_LEN
 #define CONFIG_SYS_BOOTM_LEN	(64 << 20)
 #endif
 /**
  * spl_fit_get_image_node(): By using the matching configuration subnode,
  * retrieve the name of an image, specified by a property name and an index
  * into that.
  * @fit:	Pointer to the FDT blob.
  * @images:	Offset of the /images subnode.
  * @type:	Name of the property within the configuration subnode.
  * @index:	Index into the list of strings in this property.
  *
  * Return:	the node offset of the respective image node or a negative
  * 		error number.
  */
 static int spl_fit_get_image_node(const void *fit, int images,
 				  const char *type, int index)
 {
 	const char *name, *str;
 	int node, conf_node;
 	int len, i;
 	conf_node = fit_find_config_node(fit);
 	if (conf_node < 0) {
 #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
 		printf("No matching DT out of these options:\n");
 		for (node = fdt_first_subnode(fit, conf_node);
 		     node >= 0;
 		     node = fdt_next_subnode(fit, node)) {
 			name = fdt_getprop(fit, node, "description", &len);
 			printf("   %s\n", name);
 		}
 #endif
 		return conf_node;
 	}
 	name = fdt_getprop(fit, conf_node, type, &len);
 	if (!name) {
 		debug("cannot find property '%s': %d\n", type, len);
 		return -EINVAL;
 	}
 	str = name;
 	for (i = 0; i < index; i++) {
 		str = strchr(str, '\0') + 1;
 		if (!str || (str - name >= len)) {
 			debug("no string for index %d\n", index);
 			return -E2BIG;
 		}
 	}
 	debug("%s: '%s'\n", type, str);
 	node = fdt_subnode_offset(fit, images, str);
 	if (node < 0) {
 		debug("cannot find image node '%s': %d\n", str, node);
 		return -EINVAL;
 	}
 	return node;
 }
 static int get_aligned_image_offset(struct spl_load_info *info, int offset)
 {
 	/*
 	 * If it is a FS read, get the first address before offset which is
 	 * aligned to ARCH_DMA_MINALIGN. If it is raw read return the
 	 * block number to which offset belongs.
 	 */
 	if (info->filename)
 		return offset & ~(ARCH_DMA_MINALIGN - 1);
 	return offset / info->bl_len;
 }
 static int get_aligned_image_overhead(struct spl_load_info *info, int offset)
 {
 	/*
 	 * If it is a FS read, get the difference between the offset and
 	 * the first address before offset which is aligned to
 	 * ARCH_DMA_MINALIGN. If it is raw read return the offset within the
 	 * block.
 	 */
 	if (info->filename)
 		return offset & (ARCH_DMA_MINALIGN - 1);
 	return offset % info->bl_len;
 }
 static int get_aligned_image_size(struct spl_load_info *info, int data_size,
 				  int offset)
 {
 	data_size = data_size + get_aligned_image_overhead(info, offset);
 	if (info->filename)
 		return data_size;
 	return (data_size + info->bl_len - 1) / info->bl_len;
 }
 /**
  * spl_load_fit_image(): load the image described in a certain FIT node
  * @info:	points to information about the device to load data from
  * @sector:	the start sector of the FIT image on the device
  * @fit:	points to the flattened device tree blob describing the FIT
  * 		image
  * @base_offset: the beginning of the data area containing the actual
  *		image data, relative to the beginning of the FIT
  * @node:	offset of the DT node describing the image to load (relative
  * 		to @fit)
  * @image_info:	will be filled with information about the loaded image
  * 		If the FIT node does not contain a "load" (address) property,
  * 		the image gets loaded to the address pointed to by the
  * 		load_addr member in this struct.
  *
  * Return:	0 on success or a negative error number.
  */
 static int spl_load_fit_image(struct spl_load_info *info, ulong sector,
 			      void *fit, ulong base_offset, int node,
 			      struct spl_image_info *image_info)
 {
-	ulong offset;
+	int offset;
 	size_t length;
+	int len;
 	ulong load_addr, load_ptr;
 	void *src;
 	ulong overhead;
 	int nr_sectors;
 	int align_len = ARCH_DMA_MINALIGN - 1;
 	uint8_t image_comp = -1, type = -1;
+	const void *data;
 	if (IS_ENABLED(CONFIG_SPL_OS_BOOT) && IS_ENABLED(CONFIG_SPL_GZIP)) {
 		if (fit_image_get_comp(fit, node, &image_comp))
 			puts("Cannot get image compression format.\n");
 		else
 			debug("%s ", genimg_get_comp_name(image_comp));
 		if (fit_image_get_type(fit, node, &type))
 			puts("Cannot get image type.\n");
 		else
 			debug("%s ", genimg_get_type_name(type));
 	}
-	offset = fdt_getprop_u32(fit, node, "data-offset");
+	if (fit_image_get_load(fit, node, &load_addr))
-	if (offset == FDT_ERROR)
-		return -ENOENT;
-	offset += base_offset;
-	length = fdt_getprop_u32(fit, node, "data-size");
-	if (length == FDT_ERROR)
-		return -ENOENT;
-	load_addr = fdt_getprop_u32(fit, node, "load");
-	if (load_addr == FDT_ERROR && image_info)
 		load_addr = image_info->load_addr;
-	load_ptr = (load_addr + align_len) & ~align_len;
-	overhead = get_aligned_image_overhead(info, offset);
+	if (!fit_image_get_data_offset(fit, node, &offset)) {
-	nr_sectors = get_aligned_image_size(info, length, offset);
+		/* External data */
+		offset += base_offset;
+		if (fit_image_get_data_size(fit, node, &len))
+			return -ENOENT;
-	if (info->read(info, sector + get_aligned_image_offset(info, offset),
+		load_ptr = (load_addr + align_len) & ~align_len;
-		       nr_sectors, (void*)load_ptr) != nr_sectors)
+		length = len;
-		return -EIO;
-	debug("image dst=%lx, offset=%lx, size=%lx\n", load_ptr, offset,
-	      (unsigned long)length);
-	src = (void *)load_ptr + overhead;
+		overhead = get_aligned_image_overhead(info, offset);
+		nr_sectors = get_aligned_image_size(info, length, offset);
+		if (info->read(info,
+			       sector + get_aligned_image_offset(info, offset),
+			       nr_sectors, (void *)load_ptr) != nr_sectors)
+			return -EIO;
+		debug("External data: dst=%lx, offset=%x, size=%lx\n",
+		      load_ptr, offset, (unsigned long)length);
+		src = (void *)load_ptr + overhead;
+	} else {
+		/* Embedded data */
+		if (fit_image_get_data(fit, node, &data, &length)) {
+			puts("Cannot get image data/size\n");
+			return -ENOENT;
+		}
+		debug("Embedded data: dst=%lx, size=%lx\n", load_addr,
+		      (unsigned long)length);
+		src = (void *)data;
+	}
 #ifdef CONFIG_SPL_FIT_IMAGE_POST_PROCESS
 	board_fit_image_post_process(&src, &length);
 #endif
 	if (IS_ENABLED(CONFIG_SPL_OS_BOOT)	&&
 	    IS_ENABLED(CONFIG_SPL_GZIP)		&&
 	    image_comp == IH_COMP_GZIP		&&
 	    type == IH_TYPE_KERNEL) {
 		if (gunzip((void *)load_addr, CONFIG_SYS_BOOTM_LEN,
 			   src, &length)) {
 			puts("Uncompressing error\n");
 			return -EIO;
 		}
 	} else {
 		memcpy((void *)load_addr, src, length);
 	}
 	if (image_info) {
 		image_info->load_addr = load_addr;
 		image_info->size = length;
 		image_info->entry_point = fdt_getprop_u32(fit, node, "entry");
 	}
 	return 0;
 }
 int spl_load_simple_fit(struct spl_image_info *spl_image,
 			struct spl_load_info *info, ulong sector, void *fit)
 {
 	int sectors;
 	ulong size;
 	unsigned long count;
 	struct spl_image_info image_info;
 	int node, images, ret;
 	int base_offset, align_len = ARCH_DMA_MINALIGN - 1;
 	int index = 0;
 	/*
 	 * Figure out where the external images start. This is the base for the
 	 * data-offset properties in each image.
 	 */
 	size = fdt_totalsize(fit);
 	size = (size + 3) & ~3;
 	base_offset = (size + 3) & ~3;
 	/*
 	 * So far we only have one block of data from the FIT. Read the entire
 	 * thing, including that first block, placing it so it finishes before
 	 * where we will load the image.
 	 *
 	 * Note that we will load the image such that its first byte will be
 	 * at the load address. Since that byte may be part-way through a
 	 * block, we may load the image up to one block before the load
 	 * address. So take account of that here by subtracting an addition
 	 * block length from the FIT start position.
 	 *
 	 * In fact the FIT has its own load address, but we assume it cannot
 	 * be before CONFIG_SYS_TEXT_BASE.
 	 */
 	fit = (void *)((CONFIG_SYS_TEXT_BASE - size - info->bl_len -
 			align_len) & ~align_len);
 	sectors = get_aligned_image_size(info, size, 0);
 	count = info->read(info, sector, sectors, fit);
 	debug("fit read sector %lx, sectors=%d, dst=%p, count=%lu\n",
 	      sector, sectors, fit, count);
 	if (count == 0)
 		return -EIO;
 	/* find the node holding the images information */
 	images = fdt_path_offset(fit, FIT_IMAGES_PATH);
 	if (images < 0) {
 		debug("%s: Cannot find /images node: %d\n", __func__, images);
 		return -1;
 	}
 	/* find the U-Boot image */
 	node = spl_fit_get_image_node(fit, images, "firmware", 0);
 	if (node < 0) {
 		debug("could not find firmware image, trying loadables...\n");
 		node = spl_fit_get_image_node(fit, images, "loadables", 0);
 		/*
 		 * If we pick the U-Boot image from "loadables", start at
 		 * the second image when later loading additional images.
 		 */
 		index = 1;
 	}
 	if (node < 0) {
 		debug("%s: Cannot find u-boot image node: %d\n",
 		      __func__, node);
 		return -1;
 	}
 	/* Load the image and set up the spl_image structure */
 	ret = spl_load_fit_image(info, sector, fit, base_offset, node,
 				 spl_image);
 	if (ret)
 		return ret;
 	spl_image->os = IH_OS_U_BOOT;
 	/* Figure out which device tree the board wants to use */
 	node = spl_fit_get_image_node(fit, images, FIT_FDT_PROP, 0);
 	if (node < 0) {
 		debug("%s: cannot find FDT node\n", __func__);
 		return node;
 	}
 	/*
 	 * Read the device tree and place it after the image.
 	 * Align the destination address to ARCH_DMA_MINALIGN.
 	 */
 	image_info.load_addr = spl_image->load_addr + spl_image->size;
 	ret = spl_load_fit_image(info, sector, fit, base_offset, node,
 				 &image_info);
 	if (ret < 0)
 		return ret;
 	/* Now check if there are more images for us to load */
 	for (; ; index++) {
 		node = spl_fit_get_image_node(fit, images, "loadables", index);
 		if (node < 0)
 			break;
 		ret = spl_load_fit_image(info, sector, fit, base_offset, node,
 					 &image_info);
 		if (ret < 0)
 			continue;
 		/*
 		 * If the "firmware" image did not provide an entry point,
 		 * use the first valid entry point from the loadables.
 		 */
 		if (spl_image->entry_point == FDT_ERROR &&
 		    image_info.entry_point != FDT_ERROR)
 			spl_image->entry_point = image_info.entry_point;
 	}

doc/uImage.FIT/source_file_format.txt

Diff comments View file @ 5fd13d9

 U-Boot new uImage source file format (bindings definition)
 ==========================================================
 Author: Marian Balakowicz <m8@semihalf.com>
 External data additions, 25/1/16 Simon Glass <sjg@chromium.org>
 1) Introduction
 ---------------
 Evolution of the 2.6 Linux kernel for embedded PowerPC systems introduced new
 booting method which requires that hardware description is available to the
 kernel in the form of Flattened Device Tree.
 Booting with a Flattened Device Tree is much more flexible and is intended to
 replace direct passing of 'struct bd_info' which was used to boot pre-FDT
 kernels.
 However, U-Boot needs to support both techniques to provide backward
 compatibility for platforms which are not FDT ready. Number of elements
 playing role in the booting process has increased and now includes the FDT
 blob. Kernel image, FDT blob and possibly ramdisk image - all must be placed
 in the system memory and passed to bootm as a arguments. Some of them may be
 missing: FDT is not present for legacy platforms, ramdisk is always optional.
 Additionally, old uImage format has been extended to support multi sub-images
 but the support is limited by simple format of the legacy uImage structure.
 Single binary header 'struct image_header' is not flexible enough to cover all
 possible scenarios.
 All those factors combined clearly show that there is a need for new, more
 flexible, multi component uImage format.
 2) New uImage format assumptions
 --------------------------------
 a) Implementation
 Libfdt has been selected for the new uImage format implementation as (1) it
 provides needed functionality, (2) is actively maintained and developed and
 (3) increases code reuse as it is already part of the U-Boot source tree.
 b) Terminology
 This document defines new uImage structure by providing FDT bindings for new
 uImage internals. Bindings are defined from U-Boot perspective, i.e. describe
 final form of the uImage at the moment when it reaches U-Boot. User
 perspective may be simpler, as some of the properties (like timestamps and
 hashes) will need to be filled in automatically by the U-Boot mkimage tool.
 To avoid confusion with the kernel FDT the following naming convention is
 proposed for the new uImage format related terms:
 FIT	- Flattened uImage Tree
 FIT is formally a flattened device tree (in the libfdt meaning), which
 conforms to bindings defined in this document.
 .its	- image tree source
 .itb	- flattened image tree blob
 c) Image building procedure
 The following picture shows how the new uImage is prepared. Input consists of
 image source file (.its) and a set of data files. Image is created with the
 help of standard U-Boot mkimage tool which in turn uses dtc (device tree
 compiler) to produce image tree blob (.itb).  Resulting .itb file is the
 actual binary of a new uImage.
 tqm5200.its
 +
 vmlinux.bin.gz	   mkimage + dtc	       xfer to target
 eldk-4.2-ramdisk  --------------> tqm5200.itb --------------> bootm
 tqm5200.dtb			     /|\
 ...				      |
 				 'new uImage'
 	- create .its file, automatically filled-in properties are omitted
 	- call mkimage tool on a .its file
 	- mkimage calls dtc to create .itb image and assures that
 	  missing properties are added
 	- .itb (new uImage) is uploaded onto the target and used therein
 d) Unique identifiers
 To identify FIT sub-nodes representing images, hashes, configurations (which
 are defined in the following sections), the "unit name" of the given sub-node
 is used as it's identifier as it assures uniqueness without additional
 checking required.
 3) Root node properties
 -----------------------
 Root node of the uImage Tree should have the following layout:
 / o image-tree
     |- description = "image description"
     |- timestamp = <12399321>
     |- #address-cells = <1>
     |
     o images
     | |
     | o image@1 {...}
     | o image@2 {...}
     | ...
     |
     o configurations
       |- default = "conf@1"
       |
       o conf@1 {...}
       o conf@2 {...}
       ...
   Optional property:
   - description : Textual description of the uImage
   Mandatory property:
   - timestamp : Last image modification time being counted in seconds since
     1970-01-01 00:00:00 - to be automatically calculated by mkimage tool.
   Conditionally mandatory property:
   - #address-cells : Number of 32bit cells required to represent entry and
     load addresses supplied within sub-image nodes. May be omitted when no
     entry or load addresses are used.
   Mandatory node:
   - images : This node contains a set of sub-nodes, each of them representing
     single component sub-image (like kernel, ramdisk, etc.). At least one
     sub-image is required.
   Optional node:
   - configurations : Contains a set of available configuration nodes and
     defines a default configuration.
 4) '/images' node
 -----------------
 This node is a container node for component sub-image nodes. Each sub-node of
 the '/images' node should have the following layout:
  o image@1
    |- description = "component sub-image description"
    |- data = /incbin/("path/to/data/file.bin")
    |- type = "sub-image type name"
    |- arch = "ARCH name"
    |- os = "OS name"
    |- compression = "compression name"
    |- load = <00000000>
    |- entry = <00000000>
    |
    o hash@1 {...}
    o hash@2 {...}
    ...
   Mandatory properties:
   - description : Textual description of the component sub-image
   - type : Name of component sub-image type, supported types are:
     "standalone", "kernel", "kernel_noload", "ramdisk", "firmware", "script",
     "filesystem", "flat_dt" and others (see uimage_type in common/image.c).
   - data : Path to the external file which contains this node's binary data.
   - compression : Compression used by included data. Supported compressions
     are "gzip" and "bzip2". If no compression is used compression property
     should be set to "none".
   Conditionally mandatory property:
   - os : OS name, mandatory for types "kernel" and "ramdisk". Valid OS names
     are: "openbsd", "netbsd", "freebsd", "4_4bsd", "linux", "svr4", "esix",
     "solaris", "irix", "sco", "dell", "ncr", "lynxos", "vxworks", "psos", "qnx",
     "u_boot", "rtems", "unity", "integrity".
   - arch : Architecture name, mandatory for types: "standalone", "kernel",
     "firmware", "ramdisk" and "fdt". Valid architecture names are: "alpha",
     "arm", "i386", "ia64", "mips", "mips64", "ppc", "s390", "sh", "sparc",
     "sparc64", "m68k", "microblaze", "nios2", "blackfin", "avr32", "st200",
     "sandbox".
   - entry : entry point address, address size is determined by
     '#address-cells' property of the root node. Mandatory for for types:
     "standalone" and "kernel".
   - load : load address, address size is determined by '#address-cells'
     property of the root node. Mandatory for types: "standalone" and "kernel".
   Optional nodes:
   - hash@1 : Each hash sub-node represents separate hash or checksum
     calculated for node's data according to specified algorithm.
 5) Hash nodes
 -------------
 o hash@1
   |- algo = "hash or checksum algorithm name"
   |- value = [hash or checksum value]
   Mandatory properties:
   - algo : Algorithm name, supported are "crc32", "md5" and "sha1".
   - value : Actual checksum or hash value, correspondingly 4, 16 or 20 bytes
     long.
 6) '/configurations' node
 -------------------------
 The 'configurations' node is optional. If present, it allows to create a
 convenient, labeled boot configurations, which combine together kernel images
 with their ramdisks and fdt blobs.
 The 'configurations' node has has the following structure:
 o configurations
   |- default = "default configuration sub-node unit name"
   |
   o config@1 {...}
   o config@2 {...}
   ...
   Optional property:
   - default : Selects one of the configuration sub-nodes as a default
     configuration.
   Mandatory nodes:
   - configuration-sub-node-unit-name : At least one of the configuration
     sub-nodes is required.
 7) Configuration nodes
 ----------------------
 Each configuration has the following structure:
 o config@1
   |- description = "configuration description"
   |- kernel = "kernel sub-node unit name"
   |- ramdisk = "ramdisk sub-node unit name"
   |- fdt = "fdt sub-node unit-name"
   |- fpga = "fpga sub-node unit-name"
   |- loadables = "loadables sub-node unit-name"
   Mandatory properties:
   - description : Textual configuration description.
   - kernel : Unit name of the corresponding kernel image (image sub-node of a
     "kernel" type).
   Optional properties:
   - ramdisk : Unit name of the corresponding ramdisk image (component image
     node of a "ramdisk" type).
   - fdt : Unit name of the corresponding fdt blob (component image node of a
     "fdt type").
   - setup : Unit name of the corresponding setup binary (used for booting
     an x86 kernel). This contains the setup.bin file built by the kernel.
   - fpga : Unit name of the corresponding fpga bitstream blob
     (component image node of a "fpga type").
   - loadables : Unit name containing a list of additional binaries to be
     loaded at their given locations.  "loadables" is a comma-separated list
     of strings. U-Boot will load each binary at its given start-address and
     may optionaly invoke additional post-processing steps on this binary based
     on its component image node type.
 The FDT blob is required to properly boot FDT based kernel, so the minimal
 configuration for 2.6 FDT kernel is (kernel, fdt) pair.
 Older, 2.4 kernel and 2.6 non-FDT kernel do not use FDT blob, in such cases
 'struct bd_info' must be passed instead of FDT blob, thus fdt property *must
 not* be specified in a configuration node.
 8) External data
 ----------------
 The above format shows a 'data' property which holds the data for each image.
 It is also possible for this data to reside outside the FIT itself. This
 allows the FIT to be quite small, so that it can be loaded and scanned
 without loading a large amount of data. Then when an image is needed it can
 be loaded from an external source.
 In this case the 'data' property is omitted. Instead you can use:
   - data-offset : offset of the data in a separate image store. The image
     store is placed immediately after the last byte of the device tree binary,
     aligned to a 4-byte boundary.
   - data-size : size of the data in bytes
 The 'data-offset' property can be substituted with 'data-position', which
 defines an absolute position or address as the offset. This is helpful when
 booting U-Boot proper before performing relocation.
+Normal kernel FIT image has data embedded within FIT structure. U-Boot image
+for SPL boot has external data. Existence of 'data-offset' can be used to
+identify which format is used.
 9) Examples
 -----------
 Please see doc/uImage.FIT/*.its for actual image source files.