[U-Boot,03/22] Add core support for a bloblist to convey data from SPL

At present there is no standard way in U-Boot to pass information from SPL
to U-Boot proper. But sometimes SPL wants to convey information to U-Boot
that U-Boot cannot easily figure out. For example, if SPL sets up SDRAM
then it might want to pass the size of SDRAM, or the location of each
bank, to U-Boot proper.

Add a new 'bloblist' feature which provides this. A bloblist is set up in
the first phase of U-Boot that runs (i.e. TPL or SPL). The location of
this info may be in SRAM or CAR (x86 cache-as-RAM) or somewhere else.

Information placed in this region is preserved (with a checksum) through
TPL and SPL and ends up in U-Boot. At this point it is copied into SDRAM
so it can be used after relocation.

Signed-off-by: Simon Glass <sjg@chromium.org>
---

 common/Kconfig     |  48 +++++++++
 common/Makefile    |   1 +
 common/bloblist.c  | 239 +++++++++++++++++++++++++++++++++++++++++++++
 include/bloblist.h | 194 ++++++++++++++++++++++++++++++++++++
 include/log.h      |   1 +
 5 files changed, 483 insertions(+)
 create mode 100644 common/bloblist.c
 create mode 100644 include/bloblist.h

Hi Simon,
some quick comments/notes inlined...

On Wed, Sep 26, 2018 at 03:55:01PM -0600, Simon Glass wrote:
> At present there is no standard way in U-Boot to pass information from SPL
> to U-Boot proper. But sometimes SPL wants to convey information to U-Boot
> that U-Boot cannot easily figure out. For example, if SPL sets up SDRAM
> then it might want to pass the size of SDRAM, or the location of each
> bank, to U-Boot proper.
> 
> Add a new 'bloblist' feature which provides this. A bloblist is set up in
> the first phase of U-Boot that runs (i.e. TPL or SPL). The location of
> this info may be in SRAM or CAR (x86 cache-as-RAM) or somewhere else.
>
> Information placed in this region is preserved (with a checksum) through
> TPL and SPL and ends up in U-Boot. At this point it is copied into SDRAM
> so it can be used after relocation.
>

Seems generally quite useful. For example on different TI platforms we
read out various board-specific information from an EEPROM in SPL (in
addition to DDR related stuff) which needs to be passed to U-Boot proper
and for that we have established the concept of a "scratch pad SRAM"
which essentially serves the same purpose but is very rudimentary for
example with no protection against corruption whereas the bloblists can
use CRC... very nice.
 
> Signed-off-by: Simon Glass <sjg@chromium.org>
> ---
> 
>  common/Kconfig     |  48 +++++++++
>  common/Makefile    |   1 +
>  common/bloblist.c  | 239 +++++++++++++++++++++++++++++++++++++++++++++
>  include/bloblist.h | 194 ++++++++++++++++++++++++++++++++++++
>  include/log.h      |   1 +
>  5 files changed, 483 insertions(+)
>  create mode 100644 common/bloblist.c
>  create mode 100644 include/bloblist.h
> 
> diff --git a/common/Kconfig b/common/Kconfig
> index 5c59f66f95e..b397f18be2e 100644
> --- a/common/Kconfig
> +++ b/common/Kconfig
> @@ -710,4 +710,52 @@ config UPDATE_TFTP_MSEC_MAX
>  
>  endmenu
>  
> +menu "Blob list"
> +
> +config BLOBLIST
> +	bool "Support for a bloblist"
> +	help
> +	  This enables support for a bloblist in U-Boot, which can be passed
> +	  from TPL to SPL to U-Boot proper (and potentially to Linux). The
> +	  blob list supports multiple binary blobs of data, each with a tag,
> +	  so that different U-Boot components can store data which can survive
> +	  through to the next stage of the boot.
> +
> +config SPL_BLOBLIST
> +	bool "Support for a bloblist in SPL"
> +	depends on BLOBLIST
> +	default y if SPL
> +	help
> +	  This enables a bloblist in SPL. If this is the first part of U-Boot
> +	  to run, then the bloblist is set up in SPL and passed to U-Boot
> +	  proper. If TPL also has a bloblist, then SPL uses the one from there.
> +
> +config TPL_BLOBLIST
> +	bool "Support for a bloblist in TPL"
> +	depends on BLOBLIST
> +	default y if TPL
> +	help
> +	  This enables a bloblist in TPL. The bloblist is set up in TPL and
> +	  passed to SPL andU-Boot proper.

...and U-Boot...

> +
> +config BLOBLIST_SIZE
> +	hex "Size of bloblist"
> +	depends on BLOBLIST
> +	default 0x400
> +	help
> +	  Sets the size of the bloblist in bytes. This must include all
> +	  overhead (alignment, bloblist header, record header). The bloblist
> +	  is set up in the first part of U-Boot to run (TPL, SPL or U-Boot
> +	  proper), and this sane bloblist is used for subsequent stages.
> +
> +config BLOBLIST_ADDR
> +	hex "Address of bloblist"
> +	depends on BLOBLIST
> +	default 0xe000
> +	help
> +	  Sets the address of the bloblist, set up by the first part of U-Boot
> +	  which runs. Subsequent U-Boot stages typically use the same address.
> +
> +endmenu
> +
>  source "common/spl/Kconfig"
> diff --git a/common/Makefile b/common/Makefile
> index cbca4ff2da6..6aff2b1a6e3 100644
> --- a/common/Makefile
> +++ b/common/Makefile
> @@ -61,6 +61,7 @@ obj-$(CONFIG_CMDLINE) += cli_readline.o cli_simple.o
>  endif # !CONFIG_SPL_BUILD
>  
>  obj-$(CONFIG_$(SPL_TPL_)BOOTSTAGE) += bootstage.o
> +obj-$(CONFIG_$(SPL_TPL_)BLOBLIST) += bloblist.o
>  
>  ifdef CONFIG_SPL_BUILD
>  ifdef CONFIG_SPL_DFU_SUPPORT
> diff --git a/common/bloblist.c b/common/bloblist.c
> new file mode 100644
> index 00000000000..b4cf169b05a
> --- /dev/null
> +++ b/common/bloblist.c
> @@ -0,0 +1,239 @@
> +// SPDX-License-Identifier: GPL-2.0+
> +/*
> + * Copyright 2018 Google, Inc
> + * Written by Simon Glass <sjg@chromium.org>
> + */
> +
> +#include <common.h>
> +#include <bloblist.h>
> +#include <log.h>
> +#include <mapmem.h>
> +#include <spl.h>
> +
> +DECLARE_GLOBAL_DATA_PTR;
> +
> +struct bloblist_rec *bloblist_first_blob(struct bloblist_hdr *hdr)
> +{
> +	if (hdr->alloced <= hdr->hdr_size)
> +		return NULL;
> +	return (struct bloblist_rec *)((void *)hdr + hdr->hdr_size);
> +}
> +
> +struct bloblist_rec *bloblist_next_blob(struct bloblist_hdr *hdr,
> +					struct bloblist_rec *rec)
> +{
> +	ulong offset;
> +
> +	offset = (void *)rec - (void *)hdr;
> +	offset += rec->hdr_size + ALIGN(rec->size, BLOBLIST_ALIGN);
> +	if (offset >= hdr->alloced)
> +		return NULL;
> +	return (struct bloblist_rec *)((void *)hdr + offset);
> +}
> +
> +#define foreach_rec(_rec, _hdr) \
> +	for (_rec = bloblist_first_blob(_hdr); \
> +	     _rec; \
> +	     _rec = bloblist_next_blob(_hdr, _rec))
> +
> +static struct bloblist_rec *bloblist_findrec(uint tag)
> +{
> +	struct bloblist_hdr *hdr = gd->bloblist;
> +	struct bloblist_rec *rec;
> +
> +	if (!hdr)
> +		return NULL;
> +
> +	foreach_rec(rec, hdr) {
> +		if (rec->tag == tag)
> +			return rec;
> +	}
> +
> +	return NULL;
> +}
> +
> +static int bloblist_addrec(uint tag, int size, struct bloblist_rec **recp)
> +{
> +	struct bloblist_hdr *hdr = gd->bloblist;
> +	struct bloblist_rec *rec;
> +	int new_alloced;
> +
> +	new_alloced = hdr->alloced + sizeof(*rec) +
> +			ALIGN(size, BLOBLIST_ALIGN);
> +	if (new_alloced >= hdr->size) {
> +		log(LOGC_BLOBLIST, LOGL_ERR,
> +		    "Failed to allocate %x bytes size=%x, need size>=%x\n",
> +		    size, hdr->size, new_alloced);
> +		return log_msg_ret("bloblist add", -ENOSPC);
> +	}
> +	rec = (void *)hdr + hdr->alloced;
> +	hdr->alloced = new_alloced;
> +
> +	rec->tag = tag;
> +	rec->hdr_size = sizeof(*rec);
> +	rec->size = size;
> +	rec->spare = 0;
> +	*recp = rec;
> +
> +	return 0;
> +}
> +
> +static int bloblist_ensurerec(uint tag, struct bloblist_rec **recp, int size)
> +{
> +	struct bloblist_rec *rec;
> +
> +	rec = bloblist_findrec(tag);
> +	if (rec) {
> +		if (size && size != rec->size)
> +			return -ESPIPE;
> +	} else {
> +		int ret;
> +
> +		ret = bloblist_addrec(tag, size, &rec);
> +		if (ret)
> +			return ret;
> +	}
> +	*recp = rec;
> +
> +	return 0;
> +}
> +
> +void *bloblist_find(uint tag, int size)
> +{
> +	struct bloblist_rec *rec;
> +
> +	rec = bloblist_findrec(tag);
> +	if (!rec)
> +		return NULL;
> +	if (size && size != rec->size)
> +		return NULL;
> +
> +	return (void *)rec + rec->hdr_size;
> +}
> +
> +void *bloblist_add(uint tag, int size)
> +{
> +	struct bloblist_rec *rec;
> +
> +	if (bloblist_addrec(tag, size, &rec))
> +		return NULL;
> +
> +	return rec + 1;
> +}
> +
> +int bloblist_ensure_size(uint tag, int size, void **blobp)
> +{
> +	struct bloblist_rec *rec;
> +	int ret;
> +
> +	ret = bloblist_ensurerec(tag, &rec, size);
> +	if (ret)
> +		return ret;
> +	*blobp = (void *)rec + rec->hdr_size;
> +
> +	return 0;
> +}
> +
> +void *bloblist_ensure(uint tag, int size)
> +{
> +	struct bloblist_rec *rec;
> +
> +	if (bloblist_ensurerec(tag, &rec, size))
> +		return NULL;
> +
> +	return (void *)rec + rec->hdr_size;
> +}
> +
> +static u32 bloblist_calc_chksum(struct bloblist_hdr *hdr)
> +{
> +	struct bloblist_rec *rec;
> +	u32 chksum;
> +
> +	chksum = crc32(0, (unsigned char *)hdr,
> +		       offsetof(struct bloblist_hdr, chksum));
> +	foreach_rec(rec, hdr) {
> +		chksum = crc32(chksum, (void *)rec, rec->hdr_size);
> +		chksum = crc32(chksum, (void *)rec + rec->hdr_size, rec->size);
> +	}
> +
> +	return chksum;
> +}
> +
> +int bloblist_new(ulong addr, uint size, uint flags)
> +{
> +	struct bloblist_hdr *hdr;
> +
> +	if (size < sizeof(*hdr))
> +		return log_ret(-ENOSPC);
> +	if (addr & (BLOBLIST_ALIGN - 1))
> +		return log_ret(-EFAULT);
> +	hdr = map_sysmem(addr, size);
> +	memset(hdr, '\0', sizeof(*hdr));
> +	hdr->version = BLOBLIST_VERSION;
> +	hdr->hdr_size = sizeof(*hdr);
> +	hdr->flags = flags;
> +	hdr->magic = BLOBLIST_MAGIC;
> +	hdr->size = size;
> +	hdr->alloced = hdr->hdr_size;
> +	hdr->chksum = 0;
> +	gd->bloblist = hdr;
> +
> +	return 0;
> +}
> +
> +int bloblist_check(ulong addr, uint size)
> +{
> +	struct bloblist_hdr *hdr;
> +	u32 chksum;
> +
> +	hdr = map_sysmem(addr, sizeof(*hdr));
> +	if (hdr->magic != BLOBLIST_MAGIC)
> +		return log_msg_ret("Bad magic", -ENOENT);
> +	if (hdr->version != BLOBLIST_VERSION)
> +		return log_msg_ret("Bad version", -EPROTONOSUPPORT);
> +	if (size && hdr->size != size)
> +		return log_msg_ret("Bad size", -EFBIG);
> +	chksum = bloblist_calc_chksum(hdr);
> +	if (hdr->chksum != chksum) {
> +		log(LOGC_BLOBLIST, LOGL_ERR, "Checksum %x != %x\n", hdr->chksum,
> +		    chksum);
> +		return log_msg_ret("Bad checksum", -EIO);
> +	}
> +	gd->bloblist = hdr;
> +
> +	return 0;
> +}
> +
> +int bloblist_finish(void)
> +{
> +	struct bloblist_hdr *hdr = gd->bloblist;
> +
> +	hdr->chksum = bloblist_calc_chksum(hdr);
> +
> +	return 0;
> +}
> +
> +int bloblist_init(void)
> +{
> +	bool expected;
> +	int ret = -ENOENT;
> +
> +	/**
> +	 * Wed expect to find an existing bloblist in the first phase of U-Boot
> +	 * that runs
> +	 */
> +	expected = !u_boot_first_phase();
> +	if (expected)
> +		ret = bloblist_check(CONFIG_BLOBLIST_ADDR,
> +				     CONFIG_BLOBLIST_SIZE);
> +	if (ret) {
> +		log(LOGC_BLOBLIST, expected ? LOGL_WARNING : LOGL_DEBUG,
> +		    "Existing bloblist not found: creating new bloblist\n");
> +		ret = bloblist_new(CONFIG_BLOBLIST_ADDR, CONFIG_BLOBLIST_SIZE,
> +				   0);
> +	} else {
> +		log(LOGC_BLOBLIST, LOGL_DEBUG, "Found existing bloblist\n");
> +	}
> +
> +	return ret;
> +}
> diff --git a/include/bloblist.h b/include/bloblist.h
> new file mode 100644
> index 00000000000..2f529e02580
> --- /dev/null
> +++ b/include/bloblist.h
> @@ -0,0 +1,194 @@
> +// SPDX-License-Identifier: GPL-2.0+
> +/*
> + * This provides a standard way of passing information between boot phases
> + * (TPL -> SPL -> U-Boot proper.)
> + *
> + * A list of blobs of data, tagged with their owner. The list resides in memory
> + * and can be updated by SPL, U-Boot, etc.
> + *
> + * Copyright 2018 Google, Inc
> + * Written by Simon Glass <sjg@chromium.org>
> + */
> +
> +#ifndef __BLOBLIST_H
> +#define __BLOBLIST_H
> +
> +enum {
> +	BLOBLIST_VERSION	= 0,
> +	BLOBLIST_MAGIC		= 0xb00757a3,
> +	BLOBLIST_ALIGN		= 16,
> +};
> +
> +enum bloblist_tag_t {
> +	BLOBLISTT_NONE = 0,
> +
> +	BLOBLISTT_EC_HOSTEVENT,		/* Chromium OS EC host-event mask */
> +	BLOBLISTT_SPL_HANDOFF,		/* Hand-off info from SPL */
> +	BLOBLISTT_VBOOT_CTX,		/* Chromium OS verified boot context */
> +	BLOBLISTT_VBOOT_HANDOFF,	/* Chromium OS internal handoff info */

I guess it would be okay here to add even vendor-specific tags?

> +};
> +
> +/**
> + * struct bloblist_hdr - header for the bloblist
> + *
> + * This is stored at the start of the bloblist which is always on a 16-byte
> + * boundary. Records follow this header. The bloblist normally stays in the
> + * same place in memory as SPL and U-Boot execute, but it can be safely moved
> + * around.
> + *
> + * None of the bloblist structures contain pointers but it is possible to put
> + * pointers inside a bloblist record if desired. This is not encouraged,
> + * since it can make part of the the bloblist inaccessible if the pointer is

...the...

> + * no-longer valid. It is better to just store all the data inside a bloblist
> + * record.
> + *
> + * Each bloblist record is aligned toa 16-byte boundary and follows immediately

...to a 16-byte...

> + * from the last.
> + *
> + * @version: BLOBLIST_VERSION
> + * @hdr_size: Size of this header, normally sizeof(struct bloblist_hdr). The
> + *	first bloblist_rec starts at this offset from the start of the header
> + * @flags: Space for BLOBLISTF_... flags (none yet)
> + * @magic: BLOBLIST_MAGIC
> + * @size: Total size of all records (non-zero if valid) including this header.
> + *	The bloblist extends for this many bytes from the start of this header.
> + * @alloced: Total size allocated for this bloblist. When adding new records,
> + *	the bloblist can grow up to this size. This starts out as
> + *	sizeof(bloblist_hdr) since we need at least that much space to store a
> + *	valid bloblist
> + * @spare: Space space
> + * @chksum: CRC32 for the entire bloblist allocated area. Since any of the
> + *	blobs can be altered after being created, this checksum is only valid
> + *	when the bloblist is finalised before jumping to the next stage of boot.
> + *	Note: @chksum is last to make it easier to exclude it from the checksum
> + *	calculation.
> + */
> +struct bloblist_hdr {
> +	u32 version;
> +	u32 hdr_size;
> +	u32 flags;
> +	u32 magic;
> +
> +	u32 size;
> +	u32 alloced;
> +	u32 spare;
> +	u32 chksum;
> +};
> +
> +/**
> + * struct bloblist_rec - record for the bloblist
> + *
> + * NOTE: Only exported for testing purposes. Do not use this struct.
> + *
> + * The bloblist contains a number of records each consisting of this record
> + * structure followed by the data contained. Each records is 16-byte aligned.
> + *
> + * @tag: Tag indicating what the record contains
> + * @hdr_size: Size of this header, normally sizeof(struct bloblist_rec). The
> + *	record's data starts at this offset from the start of the record
> + * @size: Size of record in bytes, excluding the header size. This does not
> + *	need to be aligned (e.g. 3 is OK).
> + * @spare: Spare space for other things
> + */
> +struct bloblist_rec {
> +	u32 tag;
> +	u32 hdr_size;
> +	u32 size;
> +	u32 spare;
> +};
> +
> +/**
> + * bloblist_find() - Find a blob
> + *
> + * Searches the bloblist and returns the blob with the matching tag
> + *
> + * @tag:	Tag to search for (enum bloblist_tag_t)
> + * @size:	Expected size of the blob
> + * @return pointer to blob if found, or NULL if not found, or a blob was found
> + *	but it is the wrong size
> + */
> +void *bloblist_find(uint tag, int size);
> +
> +/**
> + * bloblist_add() - Add a new blob
> + *
> + * Add a new blob to the bloblist
> + *
> + * This should only be called if you konw there is no existing blob for a
> + * particular tag. It is typically safe to call in the first phase of U-Boot
> + * (e.g. TPL or SPL). After that, bloblist_ensure() should be used instead.
> + *
> + * @tag:	Tag to add (enum bloblist_tag_t)
> + * @size:	Size of the blob
> + * @return pointer to the newly added block, or NULL if there is not enough
> + *	space for the blob
> + */
> +void *bloblist_add(uint tag, int size);
> +
> +/**
> + * bloblist_ensure_size() - Find or add a blob
> + *
> + * Find an existing blob, or add a new one if not found
> + *
> + * @tag:	Tag to add (enum bloblist_tag_t)
> + * @size:	Size of the blob
> + * @blobp:	Returns a pointer to blob on success
> + * @return 0 if OK, -ENOSPC if it is missing and could not be added due to lack
> + *	of space, or -ESPIPE it exists but has the wrong size
> + */
> +int bloblist_ensure_size(uint tag, int size, void **blobp);
> +
> +/**
> + * bloblist_ensure() - Find or add a blob
> + *
> + * Find an existing blob, or add a new one if not found
> + *
> + * @tag:	Tag to add (enum bloblist_tag_t)
> + * @size:	Size of the blob
> + * @return pointer to blob, or NULL if it is missing and could not be added due
> + *	to lack of space, or it exists but has the wrong size
> + */
> +void *bloblist_ensure(uint tag, int size);
> +
> +/**
> + * bloblist_new() - Create a new, empty bloblist of a given size
> + *
> + * @addr: Address of bloblist
> + * @size: Initial size for bloblist
> + * @flags: Flags to use for bloblist
> + * @return 0 if OK, -EFAULT if addr is not aligned correctly, -ENOSPC is the
> + *	area is not large enough
> + */
> +int bloblist_new(ulong addr, uint size, uint flags);
> +
> +/**
> + * bloblist_check() - Check if a bloblist exists
> + *
> + * @addr: Address of bloblist
> + * @size: Expected size of blobsize, or 0 to detect the size
> + * @return 0 if OK, -ENOENT if the magic number doesn't match (indicating that
> + *	there problem is no bloblist at the given address), -EPROTONOSUPPORT
> + *	if the version does not match, -EIO if the checksum does not match,
> + *	-EFBIG if the expected size does not match the detected size
> + */
> +int bloblist_check(ulong addr, uint size);
> +
> +/**
> + * bloblist_finish() - Set up the bloblist for the next U-Boot part
> + *
> + * This sets the correct checksum for the bloblist. This ensures that the
> + * bloblist will be detected correctly by the next phase of U-Boot.
> + *
> + * @return 0
> + */
> +int bloblist_finish(void);
> +
> +/**
> + * bloblist_init() - Init the bloblist system with a single bloblist
> + *
> + * This uess CONFIG_BLOBLIST_ADDR and CONFIG_BLOBLIST_SIZE to set up a bloblist

...uses...


Acked-by: Andreas Dannenberg <dannenberg@ti.com>

--
Andreas Dannenberg
Texas Instruments Inc

> + * for use by U-Boot.
> + */
> +int bloblist_init(void);
> +
> +#endif /* __BLOBLIST_H */
> diff --git a/include/log.h b/include/log.h
> index 1146f423a7a..61411b72eac 100644
> --- a/include/log.h
> +++ b/include/log.h
> @@ -46,6 +46,7 @@ enum log_category_t {
>  	LOGC_DM,	/* Core driver-model */
>  	LOGC_DT,	/* Device-tree */
>  	LOGC_EFI,	/* EFI implementation */
> +	LOGC_BLOBLIST,	/* Bloblist */
>  
>  	LOGC_COUNT,
>  	LOGC_END,
> -- 
> 2.19.0.605.g01d371f741-goog
> 
> _______________________________________________
> U-Boot mailing list
> U-Boot@lists.denx.de
> https://lists.denx.de/listinfo/u-boot

Hi Andreas,

On 26 September 2018 at 21:54, Andreas Dannenberg <dannenberg@ti.com> wrote:
> Hi Simon,
> some quick comments/notes inlined...
>
> On Wed, Sep 26, 2018 at 03:55:01PM -0600, Simon Glass wrote:
>> At present there is no standard way in U-Boot to pass information from SPL
>> to U-Boot proper. But sometimes SPL wants to convey information to U-Boot
>> that U-Boot cannot easily figure out. For example, if SPL sets up SDRAM
>> then it might want to pass the size of SDRAM, or the location of each
>> bank, to U-Boot proper.
>>
>> Add a new 'bloblist' feature which provides this. A bloblist is set up in
>> the first phase of U-Boot that runs (i.e. TPL or SPL). The location of
>> this info may be in SRAM or CAR (x86 cache-as-RAM) or somewhere else.
>>
>> Information placed in this region is preserved (with a checksum) through
>> TPL and SPL and ends up in U-Boot. At this point it is copied into SDRAM
>> so it can be used after relocation.
>>
>
> Seems generally quite useful. For example on different TI platforms we
> read out various board-specific information from an EEPROM in SPL (in
> addition to DDR related stuff) which needs to be passed to U-Boot proper
> and for that we have established the concept of a "scratch pad SRAM"
> which essentially serves the same purpose but is very rudimentary for
> example with no protection against corruption whereas the bloblists can
> use CRC... very nice.

OK good. I was a bit unsure about whether CRC was worth it. But I can
see cases where something might go wrong.

Will take care of your comments, thanks.

Regards,
Simon