From: Simon Glass sjg@chromium.org

The new bloblist for v0.9 has version 1 so update this value.

Signed-off-by: Simon Glass sjg@chromium.org Co-developed-by: Raymond Mao raymond.mao@linaro.org Signed-off-by: Raymond Mao raymond.mao@linaro.org --- Changes in v2 - Update the bloblist alignment to align to FW handoff spec v0.9.

include/bloblist.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/bloblist.h b/include/bloblist.h index 30441f922b..d70a7bad2e 100644 --- a/include/bloblist.h +++ b/include/bloblist.h @@ -74,7 +74,7 @@ #include <mapmem.h>

enum { - BLOBLIST_VERSION = 0, + BLOBLIST_VERSION = 1, BLOBLIST_MAGIC = 0x6ed0ff,

BLOBLIST_ALIGN_LOG2 = 3,

From: Simon Glass sjg@chromium.org

There are no spare values in spec v0.9 so drop them.

For now they are still present in the headers, with an underscore, so that tests continue to pass.

Signed-off-by: Simon Glass sjg@chromium.org Signed-off-by: Raymond Mao raymond.mao@linaro.org --- common/bloblist.c | 1 - include/bloblist.h | 6 ++---- test/bloblist.c | 4 ---- 3 files changed, 2 insertions(+), 9 deletions(-)

diff --git a/common/bloblist.c b/common/bloblist.c index 4d01772c3b..691f86f600 100644 --- a/common/bloblist.c +++ b/common/bloblist.c @@ -163,7 +163,6 @@ static int bloblist_addrec(uint tag, int size, int align_log2, rec->tag = tag; rec->hdr_size = data_start - hdr->alloced; rec->size = size; - rec->spare = 0;

/* Zero the record data */ memset((void *)rec + rec_hdr_size(rec), '\0', rec->size); diff --git a/include/bloblist.h b/include/bloblist.h index 2b898d0c55..d46bf060d7 100644 --- a/include/bloblist.h +++ b/include/bloblist.h @@ -170,7 +170,6 @@ enum bloblist_tag_t { * @alloced: Total size allocated so far for this bloblist. This starts out as * sizeof(bloblist_hdr) since we need at least that much space to store a * valid bloblist - * @spare: Spare space (for future use) * @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. @@ -185,7 +184,7 @@ struct bloblist_hdr {

u32 size; u32 alloced; - u32 spare; + u32 _spare; u32 chksum; };

@@ -202,13 +201,12 @@ struct bloblist_hdr { * 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; + u32 _spare; };

/** diff --git a/test/bloblist.c b/test/bloblist.c index 36994c3dd4..9e51735d83 100644 --- a/test/bloblist.c +++ b/test/bloblist.c @@ -202,10 +202,6 @@ static int bloblist_test_checksum(struct unit_test_state *uts) ut_asserteq(-EFBIG, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE)); hdr->size++;

- hdr->spare++; - ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE)); - hdr->spare--; - hdr->chksum++; ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE)); hdr->chksum--;

From: Simon Glass sjg@chromium.org

Use a sinple 8-bit checksum for bloblist, as specified by the spec version 0.9

Signed-off-by: Simon Glass sjg@chromium.org Signed-off-by: Raymond Mao raymond.mao@linaro.org --- common/bloblist.c | 14 ++++++++------ include/bloblist.h | 5 ++--- 2 files changed, 10 insertions(+), 9 deletions(-)

diff --git a/common/bloblist.c b/common/bloblist.c index 691f86f600..70ec0c13e6 100644 --- a/common/bloblist.c +++ b/common/bloblist.c @@ -13,6 +13,7 @@ #include <malloc.h> #include <mapmem.h> #include <spl.h> +#include <tables_csum.h> #include <asm/global_data.h> #include <u-boot/crc.h>

@@ -317,14 +318,15 @@ int bloblist_resize(uint tag, int new_size) static u32 bloblist_calc_chksum(struct bloblist_hdr *hdr) { struct bloblist_rec *rec; - u32 chksum; + u8 chksum;

- chksum = crc32(0, (unsigned char *)hdr, - offsetof(struct bloblist_hdr, chksum)); + chksum = table_compute_checksum(hdr, hdr->hdr_size); + chksum += hdr->chksum; foreach_rec(rec, hdr) { - chksum = crc32(chksum, (void *)rec, rec_hdr_size(rec)); - chksum = crc32(chksum, (void *)rec + rec_hdr_size(rec), - rec->size); + chksum -= table_compute_checksum((void *)rec, + rec_hdr_size(rec)); + chksum -= table_compute_checksum((void *)rec + + rec_hdr_size(rec), rec->size); }

return chksum; diff --git a/include/bloblist.h b/include/bloblist.h index d46bf060d7..ab7a7fc299 100644 --- a/include/bloblist.h +++ b/include/bloblist.h @@ -170,11 +170,10 @@ enum bloblist_tag_t { * @alloced: Total size allocated so far for this bloblist. This starts out as * sizeof(bloblist_hdr) since we need at least that much space to store a * valid bloblist - * @chksum: CRC32 for the entire bloblist allocated area. Since any of the + * @chksum: checksum 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 that chksum is last to make it easier to exclude it from the - * checksum calculation. + * This is the value needed to make all checksummed bytes sum to 0 */ struct bloblist_hdr { u32 magic;

From: Simon Glass sjg@chromium.org

Spec v0.9 specifies that the entire bloblist area is checksummed, including unused portions. Update the code to follow this.

Signed-off-by: Simon Glass sjg@chromium.org Signed-off-by: Raymond Mao raymond.mao@linaro.org --- common/bloblist.c | 9 +-------- test/bloblist.c | 10 ++++++++-- 2 files changed, 9 insertions(+), 10 deletions(-)

diff --git a/common/bloblist.c b/common/bloblist.c index 70ec0c13e6..96e0a167c2 100644 --- a/common/bloblist.c +++ b/common/bloblist.c @@ -317,17 +317,10 @@ int bloblist_resize(uint tag, int new_size)

static u32 bloblist_calc_chksum(struct bloblist_hdr *hdr) { - struct bloblist_rec *rec; u8 chksum;

- chksum = table_compute_checksum(hdr, hdr->hdr_size); + chksum = table_compute_checksum(hdr, hdr->alloced); chksum += hdr->chksum; - foreach_rec(rec, hdr) { - chksum -= table_compute_checksum((void *)rec, - rec_hdr_size(rec)); - chksum -= table_compute_checksum((void *)rec + - rec_hdr_size(rec), rec->size); - }

return chksum; } diff --git a/test/bloblist.c b/test/bloblist.c index 9e51735d83..32256be772 100644 --- a/test/bloblist.c +++ b/test/bloblist.c @@ -226,12 +226,18 @@ static int bloblist_test_checksum(struct unit_test_state *uts) *data2 -= 1;

/* - * Changing data outside the range of valid data should not affect - * the checksum. + * Changing data outside the range of valid data should affect the + * checksum. */ ut_assertok(bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE)); data[TEST_SIZE]++; + ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE)); + data[TEST_SIZE]--; + ut_assertok(bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE)); + data2[TEST_SIZE2]++; + ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE)); + data[TEST_SIZE]--; ut_assertok(bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));

return 0;

From: Simon Glass sjg@chromium.org

Rather than setting the alignment using the header size, add an entirely new entry to cover the gap left by the alignment.

Signed-off-by: Simon Glass sjg@chromium.org Signed-off-by: Raymond Mao raymond.mao@linaro.org --- common/bloblist.c | 23 +++++++++++++++++++---- 1 file changed, 19 insertions(+), 4 deletions(-)

diff --git a/common/bloblist.c b/common/bloblist.c index 96e0a167c2..59a092d4cd 100644 --- a/common/bloblist.c +++ b/common/bloblist.c @@ -140,7 +140,7 @@ static int bloblist_addrec(uint tag, int size, int align_log2, { struct bloblist_hdr *hdr = gd->bloblist; struct bloblist_rec *rec; - int data_start, new_alloced; + int data_start, aligned_start, new_alloced;

if (!align_log2) align_log2 = BLOBLIST_ALIGN_LOG2; @@ -149,10 +149,25 @@ static int bloblist_addrec(uint tag, int size, int align_log2, data_start = map_to_sysmem(hdr) + hdr->alloced + sizeof(*rec);

/* Align the address and then calculate the offset from ->alloced */ - data_start = ALIGN(data_start, 1U << align_log2) - map_to_sysmem(hdr); + aligned_start = ALIGN(data_start, 1U << align_log2) - data_start; + + /* If we need to create a dummy record, create it */ + if (aligned_start) { + int void_size = aligned_start - sizeof(*rec); + struct bloblist_rec *vrec; + int ret; + + ret = bloblist_addrec(BLOBLISTT_VOID, void_size, 0, &vrec); + if (ret) + return log_msg_ret("void", ret); + + /* start the record after that */ + data_start = map_to_sysmem(hdr) + hdr->alloced + sizeof(*vrec); + }

/* Calculate the new allocated total */ - new_alloced = data_start + ALIGN(size, 1U << align_log2); + new_alloced = data_start - map_to_sysmem(hdr) + + ALIGN(size, 1U << align_log2);

if (new_alloced > hdr->size) { log_err("Failed to allocate %x bytes size=%x, need size=%x\n", @@ -162,7 +177,7 @@ static int bloblist_addrec(uint tag, int size, int align_log2, rec = (void *)hdr + hdr->alloced;

rec->tag = tag; - rec->hdr_size = data_start - hdr->alloced; + rec->hdr_size = sizeof(struct bloblist_rec); rec->size = size;

/* Zero the record data */

From: Simon Glass sjg@chromium.org

The v0.9 spec provides for an 8-byte header for each blob, with fewer fields. The blob start address should be aligned to the alignment specified by the bloblist header. Update the implementation to match this.

Signed-off-by: Simon Glass sjg@chromium.org Co-developed-by: Raymond Mao raymond.mao@linaro.org Signed-off-by: Raymond Mao raymond.mao@linaro.org --- Changes in v2 - Update the blob start address to align to the alignment required by the bloblist header. - Define the macros of bloblist header size and bloblist record header size as the size of their structures.

common/bloblist.c | 17 +++++++++-------- include/bloblist.h | 33 ++++++++++++++++++++++----------- test/bloblist.c | 16 ++++++++-------- 3 files changed, 39 insertions(+), 27 deletions(-)

diff --git a/common/bloblist.c b/common/bloblist.c index 59a092d4cd..55a7e1f591 100644 --- a/common/bloblist.c +++ b/common/bloblist.c @@ -85,12 +85,14 @@ static struct bloblist_rec *bloblist_first_blob(struct bloblist_hdr *hdr)

static inline uint rec_hdr_size(struct bloblist_rec *rec) { - return rec->hdr_size; + return (rec->tag_and_hdr_size & BLOBLISTR_HDR_SIZE_MASK) >> + BLOBLISTR_HDR_SIZE_SHIFT; }

static inline uint rec_tag(struct bloblist_rec *rec) { - return rec->tag; + return (rec->tag_and_hdr_size & BLOBLISTR_TAG_MASK) >> + BLOBLISTR_TAG_SHIFT; }

static ulong bloblist_blob_end_ofs(struct bloblist_hdr *hdr, @@ -99,7 +101,7 @@ static ulong bloblist_blob_end_ofs(struct bloblist_hdr *hdr, ulong offset;

offset = (void *)rec - (void *)hdr; - offset += rec_hdr_size(rec) + ALIGN(rec->size, BLOBLIST_ALIGN); + offset += rec_hdr_size(rec) + ALIGN(rec->size, 1 << hdr->align_log2);

return offset; } @@ -143,7 +145,7 @@ static int bloblist_addrec(uint tag, int size, int align_log2, int data_start, aligned_start, new_alloced;

if (!align_log2) - align_log2 = BLOBLIST_ALIGN_LOG2; + align_log2 = BLOBLIST_BLOB_ALIGN_LOG2;

/* Figure out where the new data will start */ data_start = map_to_sysmem(hdr) + hdr->alloced + sizeof(*rec); @@ -176,8 +178,7 @@ static int bloblist_addrec(uint tag, int size, int align_log2, } rec = (void *)hdr + hdr->alloced;

- rec->tag = tag; - rec->hdr_size = sizeof(struct bloblist_rec); + rec->tag_and_hdr_size = tag | sizeof(*rec) << BLOBLISTR_HDR_SIZE_SHIFT; rec->size = size;

/* Zero the record data */ @@ -281,8 +282,8 @@ static int bloblist_resize_rec(struct bloblist_hdr *hdr, int new_alloced; /* New value for @hdr->alloced */ ulong next_ofs; /* Offset of the record after @rec */

- expand_by = ALIGN(new_size - rec->size, BLOBLIST_ALIGN); - new_alloced = ALIGN(hdr->alloced + expand_by, BLOBLIST_ALIGN); + expand_by = ALIGN(new_size - rec->size, BLOBLIST_BLOB_ALIGN); + new_alloced = ALIGN(hdr->alloced + expand_by, BLOBLIST_BLOB_ALIGN); if (new_size < 0) { log_debug("Attempt to shrink blob size below 0 (%x)\n", new_size); diff --git a/include/bloblist.h b/include/bloblist.h index ab7a7fc299..745bcdd227 100644 --- a/include/bloblist.h +++ b/include/bloblist.h @@ -24,11 +24,11 @@ * which would add to code size. For Thumb-2 the code size needed in SPL is * approximately 940 bytes (e.g. for chromebook_bob). * - * 5. Bloblist uses 16-byte alignment internally and is designed to start on a - * 16-byte boundary. Its headers are multiples of 16 bytes. This makes it easier - * to deal with data structures which need this level of alignment, such as ACPI - * tables. For use in SPL and TPL the alignment can be relaxed, since it can be - * relocated to an aligned address in U-Boot proper. + * 5. Bloblist uses 8-byte alignment internally and is designed to start on a + * 8-byte boundary. Its headers are 8 bytes long. It is possible to achieve + * larger alignment (e.g. 16 bytes) by adding a dummy header, For use in SPL and + * TPL the alignment can be relaxed, since it can be relocated to an aligned + * address in U-Boot proper. * * 6. Bloblist is designed to be passed to Linux as reserved memory. While linux * doesn't understand the bloblist header, it can be passed the indivdual blobs. @@ -77,6 +77,9 @@ enum { BLOBLIST_VERSION = 1, BLOBLIST_MAGIC = 0x6ed0ff,

+ BLOBLIST_BLOB_ALIGN_LOG2 = 3, + BLOBLIST_BLOB_ALIGN = 1 << BLOBLIST_BLOB_ALIGN_LOG2, + BLOBLIST_ALIGN_LOG2 = 3, BLOBLIST_ALIGN = 1 << BLOBLIST_ALIGN_LOG2, }; @@ -195,17 +198,25 @@ struct bloblist_hdr { * * NOTE: Only exported for testing purposes. Do not use this struct. * - * @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 + * @tag_and_hdr_size: Tag indicating what the record contains (bottom 24 bits), and + * size of this header (top 8 bits), 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). */ struct bloblist_rec { - u32 tag; - u32 hdr_size; + u32 tag_and_hdr_size; u32 size; - u32 _spare; +}; + +enum { + BLOBLISTR_TAG_SHIFT = 0, + BLOBLISTR_TAG_MASK = 0xffffffU << BLOBLISTR_TAG_SHIFT, + BLOBLISTR_HDR_SIZE_SHIFT = 24, + BLOBLISTR_HDR_SIZE_MASK = 0xffU << BLOBLISTR_HDR_SIZE_SHIFT, + + BLOBLIST_HDR_SIZE = sizeof(struct bloblist_hdr), + BLOBLIST_REC_HDR_SIZE = sizeof(struct bloblist_rec), };

/** diff --git a/test/bloblist.c b/test/bloblist.c index 32256be772..7e65f30518 100644 --- a/test/bloblist.c +++ b/test/bloblist.c @@ -261,8 +261,8 @@ static int bloblist_test_cmd_info(struct unit_test_state *uts) run_command("bloblist info", 0); ut_assert_nextline("base: %lx", (ulong)map_to_sysmem(hdr)); ut_assert_nextline("size: 400 1 KiB"); - ut_assert_nextline("alloced: 70 112 Bytes"); - ut_assert_nextline("free: 390 912 Bytes"); + ut_assert_nextline("alloced: 58 88 Bytes"); + ut_assert_nextline("free: 3a8 936 Bytes"); ut_assert_console_end(); ut_unsilence_console(uts);

@@ -320,12 +320,12 @@ static int bloblist_test_align(struct unit_test_state *uts) data = bloblist_add(i, size, 0); ut_assertnonnull(data); addr = map_to_sysmem(data); - ut_asserteq(0, addr & (BLOBLIST_ALIGN - 1)); + ut_asserteq(0, addr & (BLOBLIST_BLOB_ALIGN - 1));

/* Only the bytes in the blob data should be zeroed */ for (j = 0; j < size; j++) ut_asserteq(0, data[j]); - for (; j < BLOBLIST_ALIGN; j++) + for (; j < BLOBLIST_BLOB_ALIGN; j++) ut_asserteq(ERASE_BYTE, data[j]); }

@@ -340,7 +340,7 @@ static int bloblist_test_align(struct unit_test_state *uts) }

/* Check alignment with an bloblist starting on a smaller alignment */ - hdr = map_sysmem(TEST_ADDR + BLOBLIST_ALIGN, TEST_BLOBLIST_SIZE); + hdr = map_sysmem(TEST_ADDR + BLOBLIST_BLOB_ALIGN, TEST_BLOBLIST_SIZE); memset(hdr, ERASE_BYTE, TEST_BLOBLIST_SIZE); memset(hdr, '\0', sizeof(*hdr)); ut_assertok(bloblist_new(TEST_ADDR + BLOBLIST_ALIGN, @@ -349,7 +349,7 @@ static int bloblist_test_align(struct unit_test_state *uts) data = bloblist_add(1, 5, BLOBLIST_ALIGN_LOG2 + 1); ut_assertnonnull(data); addr = map_to_sysmem(data); - ut_asserteq(0, addr & (BLOBLIST_ALIGN * 2 - 1)); + ut_asserteq(0, addr & (BLOBLIST_BLOB_ALIGN * 2 - 1));

return 0; } @@ -437,7 +437,7 @@ static int bloblist_test_grow(struct unit_test_state *uts) hdr = ptr; ut_asserteq(sizeof(struct bloblist_hdr) + sizeof(struct bloblist_rec) * 2 + small_size * 2 + - BLOBLIST_ALIGN, + BLOBLIST_BLOB_ALIGN, hdr->alloced);

return 0; @@ -572,7 +572,7 @@ static int bloblist_test_resize_last(struct unit_test_state *uts) ut_asserteq((u8)ERASE_BYTE, *((u8 *)hdr + alloced_val + 4));

/* Check that the new top of the allocated blobs has not been touched */ - alloced_val += BLOBLIST_ALIGN; + alloced_val += BLOBLIST_BLOB_ALIGN; ut_asserteq(alloced_val, hdr->alloced); ut_asserteq((u8)ERASE_BYTE, *((u8 *)hdr + hdr->alloced));

From: Simon Glass sjg@chromium.org

The v0.9 spec provides for a 16-byte header with fewer fields. Update the implementation to match this.

This also adds an alignment field.

Signed-off-by: Simon Glass sjg@chromium.org Signed-off-by: Raymond Mao raymond.mao@linaro.org --- include/bloblist.h | 26 +++++++++++++------------- test/bloblist.c | 6 +++--- 2 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/include/bloblist.h b/include/bloblist.h index 745bcdd227..57625ea004 100644 --- a/include/bloblist.h +++ b/include/bloblist.h @@ -164,30 +164,30 @@ enum bloblist_tag_t { * from the last. * * @magic: BLOBLIST_MAGIC + * @chksum: checksum 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. + * This is the value needed to make all chechksummed bytes sum to 0 * @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 - * @size: Total size of the bloblist (non-zero if valid) including this header. - * The bloblist extends for this many bytes from the start of this header. - * When adding new records, the bloblist can grow up to this size. + * @align_log2: Power of two of the maximum alignment required by this list * @alloced: Total size allocated so far for this bloblist. This starts out as * sizeof(bloblist_hdr) since we need at least that much space to store a * valid bloblist - * @chksum: checksum 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. - * This is the value needed to make all checksummed bytes sum to 0 + * @size: Total size of the bloblist (non-zero if valid) including this header. + * The bloblist extends for this many bytes from the start of this header. + * When adding new records, the bloblist can grow up to this size. */ struct bloblist_hdr { u32 magic; - u32 version; - u32 hdr_size; - u32 _flags; + u8 chksum; + u8 version; + u8 hdr_size; + u8 align_log2;

- u32 size; u32 alloced; - u32 _spare; - u32 chksum; + u32 size; };

/** diff --git a/test/bloblist.c b/test/bloblist.c index 7e65f30518..be237c6155 100644 --- a/test/bloblist.c +++ b/test/bloblist.c @@ -78,7 +78,7 @@ static int bloblist_test_init(struct unit_test_state *uts) ut_asserteq(-EPROTONOSUPPORT, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));

- ut_asserteq(-ENOSPC, bloblist_new(TEST_ADDR, 0x10)); + ut_asserteq(-ENOSPC, bloblist_new(TEST_ADDR, 0xc)); ut_asserteq(-EFAULT, bloblist_new(1, TEST_BLOBLIST_SIZE)); ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE));

@@ -261,8 +261,8 @@ static int bloblist_test_cmd_info(struct unit_test_state *uts) run_command("bloblist info", 0); ut_assert_nextline("base: %lx", (ulong)map_to_sysmem(hdr)); ut_assert_nextline("size: 400 1 KiB"); - ut_assert_nextline("alloced: 58 88 Bytes"); - ut_assert_nextline("free: 3a8 936 Bytes"); + ut_assert_nextline("alloced: 48 72 Bytes"); + ut_assert_nextline("free: 3b8 952 Bytes"); ut_assert_console_end(); ut_unsilence_console(uts);

From: Simon Glass sjg@chromium.org

Allow the alignment to be specified when creating a bloblist.

Signed-off-by: Simon Glass sjg@chromium.org Signed-off-by: Raymond Mao raymond.mao@linaro.org --- common/bloblist.c | 5 +++-- include/bloblist.h | 3 ++- test/bloblist.c | 40 ++++++++++++++++++++++------------------ 3 files changed, 27 insertions(+), 21 deletions(-)

diff --git a/common/bloblist.c b/common/bloblist.c index 55a7e1f591..0d482ecd71 100644 --- a/common/bloblist.c +++ b/common/bloblist.c @@ -341,7 +341,7 @@ static u32 bloblist_calc_chksum(struct bloblist_hdr *hdr) return chksum; }

-int bloblist_new(ulong addr, uint size) +int bloblist_new(ulong addr, uint size, uint align_log2) { struct bloblist_hdr *hdr;

@@ -356,6 +356,7 @@ int bloblist_new(ulong addr, uint size) hdr->magic = BLOBLIST_MAGIC; hdr->size = size; hdr->alloced = hdr->hdr_size; + hdr->align_log2 = align_log2 ?: BLOBLIST_BLOB_ALIGN_LOG2; hdr->chksum = 0; gd->bloblist = hdr;

@@ -499,7 +500,7 @@ int bloblist_init(void) } log_debug("Creating new bloblist size %lx at %lx\n", size, addr); - ret = bloblist_new(addr, size); + ret = bloblist_new(addr, size, 0); } else { log_debug("Found existing bloblist size %lx at %lx\n", size, addr); diff --git a/include/bloblist.h b/include/bloblist.h index 57625ea004..c419c0d923 100644 --- a/include/bloblist.h +++ b/include/bloblist.h @@ -324,10 +324,11 @@ int bloblist_resize(uint tag, int new_size); * * @addr: Address of bloblist * @size: Initial size for bloblist + * @align_log2: Log base 2 of maximum alignment provided by this 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); +int bloblist_new(ulong addr, uint size, uint align_log2);

/** * bloblist_check() - Check if a bloblist exists diff --git a/test/bloblist.c b/test/bloblist.c index be237c6155..b72603ba9a 100644 --- a/test/bloblist.c +++ b/test/bloblist.c @@ -72,15 +72,15 @@ static int bloblist_test_init(struct unit_test_state *uts) hdr = clear_bloblist(); ut_asserteq(-ENOENT, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE)); ut_asserteq_ptr(NULL, bloblist_check_magic(TEST_ADDR)); - ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE)); + ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE, 0)); ut_asserteq_ptr(hdr, bloblist_check_magic(TEST_ADDR)); hdr->version++; ut_asserteq(-EPROTONOSUPPORT, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));

- ut_asserteq(-ENOSPC, bloblist_new(TEST_ADDR, 0xc)); - ut_asserteq(-EFAULT, bloblist_new(1, TEST_BLOBLIST_SIZE)); - ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE)); + ut_asserteq(-ENOSPC, bloblist_new(TEST_ADDR, 0xc, 0)); + ut_asserteq(-EFAULT, bloblist_new(1, TEST_BLOBLIST_SIZE, 0)); + ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE, 0));

ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE)); ut_assertok(bloblist_finish()); @@ -103,7 +103,7 @@ static int bloblist_test_blob(struct unit_test_state *uts) /* At the start there should be no records */ hdr = clear_bloblist(); ut_assertnull(bloblist_find(TEST_TAG, TEST_BLOBLIST_SIZE)); - ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE)); + ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE, 0)); ut_asserteq(TEST_BLOBLIST_SIZE, bloblist_get_size()); ut_asserteq(TEST_ADDR, bloblist_get_base()); ut_asserteq(map_to_sysmem(hdr), TEST_ADDR); @@ -141,7 +141,7 @@ static int bloblist_test_blob_ensure(struct unit_test_state *uts)

/* At the start there should be no records */ clear_bloblist(); - ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE)); + ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE, 0));

/* Test with an empty bloblist */ size = TEST_SIZE; @@ -173,7 +173,7 @@ static int bloblist_test_bad_blob(struct unit_test_state *uts) void *data;

hdr = clear_bloblist(); - ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE)); + ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE, 0)); data = hdr + 1; data += sizeof(struct bloblist_rec); ut_asserteq_addr(data, bloblist_ensure(TEST_TAG, TEST_SIZE)); @@ -189,7 +189,7 @@ static int bloblist_test_checksum(struct unit_test_state *uts) char *data, *data2;

hdr = clear_bloblist(); - ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE)); + ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE, 0)); ut_assertok(bloblist_finish()); ut_assertok(bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));

@@ -206,6 +206,10 @@ static int bloblist_test_checksum(struct unit_test_state *uts) ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE)); hdr->chksum--;

+ hdr->align_log2++; + ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE)); + hdr->align_log2--; + /* Make sure the checksum changes when we add blobs */ data = bloblist_add(TEST_TAG, TEST_SIZE, 0); ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE)); @@ -251,7 +255,7 @@ static int bloblist_test_cmd_info(struct unit_test_state *uts) char *data, *data2;

hdr = clear_bloblist(); - ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE)); + ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE, 0)); data = bloblist_ensure(TEST_TAG, TEST_SIZE); data2 = bloblist_ensure(TEST_TAG2, TEST_SIZE2);

@@ -277,7 +281,7 @@ static int bloblist_test_cmd_list(struct unit_test_state *uts) char *data, *data2;

hdr = clear_bloblist(); - ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE)); + ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE, 0)); data = bloblist_ensure(TEST_TAG, TEST_SIZE); data2 = bloblist_ensure(TEST_TAG2, TEST_SIZE2);

@@ -307,7 +311,7 @@ static int bloblist_test_align(struct unit_test_state *uts)

/* At the start there should be no records */ hdr = clear_bloblist(); - ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE)); + ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE, 0)); ut_assertnull(bloblist_find(TEST_TAG, TEST_BLOBLIST_SIZE));

/* Check the default alignment */ @@ -344,7 +348,7 @@ static int bloblist_test_align(struct unit_test_state *uts) memset(hdr, ERASE_BYTE, TEST_BLOBLIST_SIZE); memset(hdr, '\0', sizeof(*hdr)); ut_assertok(bloblist_new(TEST_ADDR + BLOBLIST_ALIGN, - TEST_BLOBLIST_SIZE)); + TEST_BLOBLIST_SIZE, 0));

data = bloblist_add(1, 5, BLOBLIST_ALIGN_LOG2 + 1); ut_assertnonnull(data); @@ -365,7 +369,7 @@ static int bloblist_test_reloc(struct unit_test_state *uts) ulong new_addr; ulong new_size;

- ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE)); + ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE, 0)); old_ptr = map_sysmem(TEST_ADDR, TEST_BLOBLIST_SIZE);

/* Add one blob and then one that won't fit */ @@ -404,7 +408,7 @@ static int bloblist_test_grow(struct unit_test_state *uts) memset(hdr, ERASE_BYTE, TEST_BLOBLIST_SIZE);

/* Create two blobs */ - ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE)); + ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE, 0)); blob1 = bloblist_add(TEST_TAG, small_size, 0); ut_assertnonnull(blob1); ut_assertok(check_zero(blob1, small_size)); @@ -456,7 +460,7 @@ static int bloblist_test_shrink(struct unit_test_state *uts) ptr = map_sysmem(TEST_ADDR, TEST_BLOBLIST_SIZE);

/* Create two blobs */ - ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE)); + ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE, 0)); blob1 = bloblist_add(TEST_TAG, small_size, 0); ut_assertnonnull(blob1); strcpy(blob1, test1_str); @@ -506,7 +510,7 @@ static int bloblist_test_resize_fail(struct unit_test_state *uts) ptr = map_sysmem(TEST_ADDR, TEST_BLOBLIST_SIZE);

/* Create two blobs */ - ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE)); + ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE, 0)); blob1 = bloblist_add(TEST_TAG, small_size, 0); ut_assertnonnull(blob1);

@@ -543,7 +547,7 @@ static int bloblist_test_resize_last(struct unit_test_state *uts) hdr = ptr;

/* Create two blobs */ - ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE)); + ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE, 0)); blob1 = bloblist_add(TEST_TAG, small_size, 0); ut_assertnonnull(blob1);

@@ -588,7 +592,7 @@ static int bloblist_test_blob_maxsize(struct unit_test_state *uts)

/* At the start there should be no records */ clear_bloblist(); - ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE)); + ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE, 0));

/* Add a blob that takes up all space */ size = TEST_BLOBLIST_SIZE - sizeof(struct bloblist_hdr) -

From: Simon Glass sjg@chromium.org

Align the documentation with the v0.9 spec.

Signed-off-by: Simon Glass sjg@chromium.org Signed-off-by: Raymond Mao raymond.mao@linaro.org --- doc/develop/bloblist.rst | 4 +++- include/bloblist.h | 1 + 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/doc/develop/bloblist.rst b/doc/develop/bloblist.rst index 81643c7674..28431039ad 100644 --- a/doc/develop/bloblist.rst +++ b/doc/develop/bloblist.rst @@ -14,6 +14,8 @@ structure defined by the code that owns it. For the design goals of bloblist, please see the comments at the top of the `bloblist.h` header file.

+Bloblist is an implementation with the `Firmware Handoff`_ protocol. + Passing state through the boot process --------------------------------------

@@ -99,7 +101,7 @@ API documentation -----------------

.. kernel-doc:: include/bloblist.h - +.. _`Firmware Handoff`: https://github.com/FirmwareHandoff/firmware_handoff

Simon Glass sjg@chromium.org diff --git a/include/bloblist.h b/include/bloblist.h index c419c0d923..148a94fcd1 100644 --- a/include/bloblist.h +++ b/include/bloblist.h @@ -66,6 +66,7 @@ * * Copyright 2018 Google, Inc * Written by Simon Glass sjg@chromium.org + * Adjusted July 2023 to match Firmware handoff specification, Release 0.9 */

#ifndef __BLOBLIST_H

From: Simon Glass sjg@chromium.org

Standard passage provides for a bloblist to be passed from one firmware phase to the next. That can be used to pass the devicetree along as well. If CONFIG_OF_BOARD is defined, a board custom routine will provide a bloblist or a specified memory address to retrieve the devicetree at runtime. A devicetree from a bloblist is prioritized than the one from specified memory region.

Tests for this will be added as part of the Universal Payload work.

Signed-off-by: Simon Glass sjg@chromium.org Co-developed-by: Raymond Mao raymond.mao@linaro.org Signed-off-by: Raymond Mao raymond.mao@linaro.org --- Changes in v2 - New patch file created for v2. Amended from the original patch "[v2,30/32] fdt: Allow the devicetree to come from a bloblist". Remove CONFIG_OF_BLOBLIST and FDTSRC_BLOBLIST, a DTB from a previous loader is defined by CONFIG_OF_BOARD. The DTB can be located either in the bloblist or from a specified memory address.

doc/develop/devicetree/control.rst | 8 +++-- dts/Kconfig | 9 ++++-- include/fdtdec.h | 3 +- lib/fdtdec.c | 52 +++++++++++++++++++++++------- 4 files changed, 53 insertions(+), 19 deletions(-)

diff --git a/doc/develop/devicetree/control.rst b/doc/develop/devicetree/control.rst index cbb65c9b17..a7f0f87841 100644 --- a/doc/develop/devicetree/control.rst +++ b/doc/develop/devicetree/control.rst @@ -104,9 +104,11 @@ in u-boot.bin so you can still just flash u-boot.bin onto your board. If you are using CONFIG_SPL_FRAMEWORK, then u-boot.img will be built to include the device tree binary.

-If CONFIG_OF_BOARD is defined, a board-specific routine will provide the -devicetree at runtime, for example if an earlier bootloader stage creates -it and passes it to U-Boot. +If CONFIG_OF_BOARD is defined, a board-specific routine will provide a bloblist +or a specified memory region to retrieve the devicetree at runtime, for example +if an earlier bootloader stage creates it and passes it to U-Boot. +A devicetree from a bloblist is prioritized than the one from a specified memory +region.

If CONFIG_SANDBOX is defined, then it will be read from a file on startup. Use the -d flag to U-Boot to specify the file to read, -D for the diff --git a/dts/Kconfig b/dts/Kconfig index 00c0aeff89..4faf4ba633 100644 --- a/dts/Kconfig +++ b/dts/Kconfig @@ -110,8 +110,13 @@ config OF_BOARD default y if SANDBOX || OF_HAS_PRIOR_STAGE help If this option is enabled, the device tree is provided at runtime by - a custom function called board_fdt_blob_setup(). The board must - implement this function if it wishes to provide special behaviour. + bloblist via a custom function called board_bloblist_from_boot_arg() + or a memory region from a custom function called + board_fdt_blob_setup(). The board must implement either these + functions if it wishes to provide special behaviour. + + A devicetree from a bloblist is prioritized then the one from a + specified memory region if the board provides both methods.

With this option, the device tree build by U-Boot may be overridden or ignored. See OF_HAS_PRIOR_STAGE. diff --git a/include/fdtdec.h b/include/fdtdec.h index bd1149f46d..0824fe1359 100644 --- a/include/fdtdec.h +++ b/include/fdtdec.h @@ -72,14 +72,13 @@ struct bd_info; * U-Boot is packaged as an ELF file, e.g. for debugging purposes * @FDTSRC_ENV: Provided by the fdtcontroladdr environment variable. This should * be used for debugging/development only - * @FDTSRC_NONE: No devicetree at all */ enum fdt_source_t { FDTSRC_SEPARATE, FDTSRC_FIT, FDTSRC_BOARD, FDTSRC_EMBED, - FDTSRC_ENV, + FDTSRC_ENV };

/* diff --git a/lib/fdtdec.c b/lib/fdtdec.c index 7a69167648..025baca4a4 100644 --- a/lib/fdtdec.c +++ b/lib/fdtdec.c @@ -7,7 +7,11 @@ */

#ifndef USE_HOSTCC + +#define LOG_CATEGORY LOGC_DT + #include <common.h> +#include <bloblist.h> #include <boot_fit.h> #include <display_options.h> #include <dm.h> @@ -86,7 +90,7 @@ static const char *const fdt_src_name[] = { [FDTSRC_FIT] = "fit", [FDTSRC_BOARD] = "board", [FDTSRC_EMBED] = "embed", - [FDTSRC_ENV] = "env", + [FDTSRC_ENV] = "env" };

const char *fdtdec_get_srcname(void) @@ -1665,21 +1669,45 @@ int fdtdec_setup(void) { int ret;

- /* The devicetree is typically appended to U-Boot */ - if (IS_ENABLED(CONFIG_OF_SEPARATE)) { - gd->fdt_blob = fdt_find_separate(); - gd->fdt_src = FDTSRC_SEPARATE; - } else { /* embed dtb in ELF file for testing / development */ - gd->fdt_blob = dtb_dt_embedded(); - gd->fdt_src = FDTSRC_EMBED; - } - - /* Allow the board to override the fdt address. */ + /* + * The devicetree is typically appended to U-Boot. + * Option 1: From bloblist. + * Option 2: From a specified memory address. + */ if (IS_ENABLED(CONFIG_OF_BOARD)) { - gd->fdt_blob = board_fdt_blob_setup(&ret); + /* + * DTB is from board. + * Either from bloblist or a platform specified memory. + */ + ret = bloblist_maybe_init(); if (ret) return ret; + + /* Check if a DTB exists in bloblist first */ + if (IS_ENABLED(CONFIG_BLOBLIST)) { + gd->fdt_blob = bloblist_find(BLOBLISTT_CONTROL_FDT, 0); + if (gd->fdt_blob) { + log_info("Fdt from bloblist at 0x%lx\n", + (unsigned long)gd->fdt_blob); + } + } + if (!gd->fdt_blob) { + /* Apply DTB from a platform specified memory */ + gd->fdt_blob = board_fdt_blob_setup(&ret); + if (ret) + return ret; + log_info("Fdt from memory at 0x%lx\n", + (unsigned long)gd->fdt_blob); + } gd->fdt_src = FDTSRC_BOARD; + } else { + if (IS_ENABLED(CONFIG_OF_SEPARATE)) { + gd->fdt_blob = fdt_find_separate(); + gd->fdt_src = FDTSRC_SEPARATE; + } else { /* embed dtb in ELF file for testing / development */ + gd->fdt_blob = dtb_dt_embedded(); + gd->fdt_src = FDTSRC_EMBED; + } }

/* Allow the early environment to override the fdt address */

Align used_size and total_size of the bloblist header to the definition of the FW Handoff spec v0.9. Update the related bloblist APIs and UT testcases.

Signed-off-by: Raymond Mao raymond.mao@linaro.org --- Changes in v2 - New patch file created for v2.

common/bloblist.c | 86 +++++++++++++++++++++++++++------------------- include/bloblist.h | 26 ++++++++------ test/bloblist.c | 35 ++++++++++--------- 3 files changed, 84 insertions(+), 63 deletions(-)

diff --git a/common/bloblist.c b/common/bloblist.c index 0d482ecd71..91d69e9439 100644 --- a/common/bloblist.c +++ b/common/bloblist.c @@ -78,7 +78,7 @@ const char *bloblist_tag_name(enum bloblist_tag_t tag)

static struct bloblist_rec *bloblist_first_blob(struct bloblist_hdr *hdr) { - if (hdr->alloced <= hdr->hdr_size) + if (hdr->used_size <= hdr->hdr_size) return NULL; return (struct bloblist_rec *)((void *)hdr + hdr->hdr_size); } @@ -111,7 +111,7 @@ static struct bloblist_rec *bloblist_next_blob(struct bloblist_hdr *hdr, { ulong offset = bloblist_blob_end_ofs(hdr, rec);

- if (offset >= hdr->alloced) + if (offset >= hdr->used_size) return NULL; return (struct bloblist_rec *)((void *)hdr + offset); } @@ -148,9 +148,9 @@ static int bloblist_addrec(uint tag, int size, int align_log2, align_log2 = BLOBLIST_BLOB_ALIGN_LOG2;

/* Figure out where the new data will start */ - data_start = map_to_sysmem(hdr) + hdr->alloced + sizeof(*rec); + data_start = map_to_sysmem(hdr) + hdr->used_size + sizeof(*rec);

- /* Align the address and then calculate the offset from ->alloced */ + /* Align the address and then calculate the offset from used size */ aligned_start = ALIGN(data_start, 1U << align_log2) - data_start;

/* If we need to create a dummy record, create it */ @@ -164,19 +164,20 @@ static int bloblist_addrec(uint tag, int size, int align_log2, return log_msg_ret("void", ret);

/* start the record after that */ - data_start = map_to_sysmem(hdr) + hdr->alloced + sizeof(*vrec); + data_start = map_to_sysmem(hdr) + hdr->used_size + sizeof(*vrec); }

/* Calculate the new allocated total */ new_alloced = data_start - map_to_sysmem(hdr) + ALIGN(size, 1U << align_log2);

- if (new_alloced > hdr->size) { - log_err("Failed to allocate %x bytes size=%x, need size=%x\n", - size, hdr->size, new_alloced); + if (new_alloced > hdr->total_size) { + log_err("Failed to allocate %x bytes\n", size); + log_err("Used size=%x, total size=%x\n", + hdr->used_size, hdr->total_size); return log_msg_ret("bloblist add", -ENOSPC); } - rec = (void *)hdr + hdr->alloced; + rec = (void *)hdr + hdr->used_size;

rec->tag_and_hdr_size = tag | sizeof(*rec) << BLOBLISTR_HDR_SIZE_SHIFT; rec->size = size; @@ -184,7 +185,7 @@ static int bloblist_addrec(uint tag, int size, int align_log2, /* Zero the record data */ memset((void *)rec + rec_hdr_size(rec), '\0', rec->size);

- hdr->alloced = new_alloced; + hdr->used_size = new_alloced; *recp = rec;

return 0; @@ -279,29 +280,30 @@ static int bloblist_resize_rec(struct bloblist_hdr *hdr, int new_size) { int expand_by; /* Number of bytes to expand by (-ve to contract) */ - int new_alloced; /* New value for @hdr->alloced */ + int new_alloced; ulong next_ofs; /* Offset of the record after @rec */

expand_by = ALIGN(new_size - rec->size, BLOBLIST_BLOB_ALIGN); - new_alloced = ALIGN(hdr->alloced + expand_by, BLOBLIST_BLOB_ALIGN); + new_alloced = ALIGN(hdr->used_size + expand_by, BLOBLIST_BLOB_ALIGN); if (new_size < 0) { log_debug("Attempt to shrink blob size below 0 (%x)\n", new_size); return log_msg_ret("size", -EINVAL); } - if (new_alloced > hdr->size) { - log_err("Failed to allocate %x bytes size=%x, need size=%x\n", - new_size, hdr->size, new_alloced); + if (new_alloced > hdr->total_size) { + log_err("Failed to allocate %x bytes\n", new_size); + log_err("Used size=%x, total size=%x\n", + hdr->used_size, hdr->total_size); return log_msg_ret("alloc", -ENOSPC); }

/* Move the following blobs up or down, if this is not the last */ next_ofs = bloblist_blob_end_ofs(hdr, rec); - if (next_ofs != hdr->alloced) { + if (next_ofs != hdr->used_size) { memmove((void *)hdr + next_ofs + expand_by, (void *)hdr + next_ofs, new_alloced - next_ofs); } - hdr->alloced = new_alloced; + hdr->used_size = new_alloced;

/* Zero the new part of the blob */ if (expand_by > 0) { @@ -335,7 +337,7 @@ static u32 bloblist_calc_chksum(struct bloblist_hdr *hdr) { u8 chksum;

- chksum = table_compute_checksum(hdr, hdr->alloced); + chksum = table_compute_checksum(hdr, hdr->used_size); chksum += hdr->chksum;

return chksum; @@ -354,9 +356,9 @@ int bloblist_new(ulong addr, uint size, uint align_log2) hdr->version = BLOBLIST_VERSION; hdr->hdr_size = sizeof(*hdr); hdr->magic = BLOBLIST_MAGIC; - hdr->size = size; - hdr->alloced = hdr->hdr_size; + hdr->used_size = hdr->hdr_size; hdr->align_log2 = align_log2 ?: BLOBLIST_BLOB_ALIGN_LOG2; + hdr->total_size = size; hdr->chksum = 0; gd->bloblist = hdr;

@@ -373,8 +375,13 @@ int bloblist_check(ulong addr, uint size) 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); + if (!hdr->total_size || (size && hdr->total_size != size)) + return log_msg_ret("Bad total size", -EFBIG); + if (hdr->used_size > hdr->total_size) + return log_msg_ret("Bad used size", -ENOENT); + if (hdr->hdr_size != sizeof(struct bloblist_hdr)) + return log_msg_ret("Bad header size", -ENOENT); + chksum = bloblist_calc_chksum(hdr); if (hdr->chksum != chksum) { log_err("Checksum %x != %x\n", hdr->chksum, chksum); @@ -390,7 +397,7 @@ int bloblist_finish(void) struct bloblist_hdr *hdr = gd->bloblist;

hdr->chksum = bloblist_calc_chksum(hdr); - log_debug("Finished bloblist size %lx at %lx\n", (ulong)hdr->size, + log_debug("Finished bloblist size %lx at %lx\n", (ulong)hdr->used_size, (ulong)map_to_sysmem(hdr));

return 0; @@ -405,33 +412,40 @@ ulong bloblist_get_size(void) { struct bloblist_hdr *hdr = gd->bloblist;

- return hdr->size; + return hdr->used_size; +} + +ulong bloblist_get_total_size(void) +{ + struct bloblist_hdr *hdr = gd->bloblist; + + return hdr->total_size; }

-void bloblist_get_stats(ulong *basep, ulong *sizep, ulong *allocedp) +void bloblist_get_stats(ulong *basep, ulong *tsizep, ulong *usizep) { struct bloblist_hdr *hdr = gd->bloblist;

*basep = map_to_sysmem(gd->bloblist); - *sizep = hdr->size; - *allocedp = hdr->alloced; + *tsizep = hdr->total_size; + *usizep = hdr->used_size; }

static void show_value(const char *prompt, ulong value) { - printf("%s:%*s %-5lx ", prompt, 8 - (int)strlen(prompt), "", value); + printf("%s:%*s %-5lx ", prompt, 10 - (int)strlen(prompt), "", value); print_size(value, "\n"); }

void bloblist_show_stats(void) { - ulong base, size, alloced; + ulong base, tsize, usize;

- bloblist_get_stats(&base, &size, &alloced); - printf("base: %lx\n", base); - show_value("size", size); - show_value("alloced", alloced); - show_value("free", size - alloced); + bloblist_get_stats(&base, &tsize, &usize); + printf("base: %lx\n", base); + show_value("total size", tsize); + show_value("used size", usize); + show_value("free", tsize - usize); }

void bloblist_show_list(void) @@ -455,7 +469,7 @@ void bloblist_reloc(void *to, uint to_size, void *from, uint from_size)

memcpy(to, from, from_size); hdr = to; - hdr->size = to_size; + hdr->total_size = to_size; }

int bloblist_init(void) @@ -485,7 +499,7 @@ int bloblist_init(void) addr, ret); } else { /* Get the real size, if it is not what we expected */ - size = gd->bloblist->size; + size = gd->bloblist->total_size; } } if (ret) { diff --git a/include/bloblist.h b/include/bloblist.h index 148a94fcd1..0f5afec9f4 100644 --- a/include/bloblist.h +++ b/include/bloblist.h @@ -173,12 +173,12 @@ enum bloblist_tag_t { * @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 * @align_log2: Power of two of the maximum alignment required by this list - * @alloced: Total size allocated so far for this bloblist. This starts out as + * @used_size: Size allocated so far for this bloblist. This starts out as * sizeof(bloblist_hdr) since we need at least that much space to store a * valid bloblist - * @size: Total size of the bloblist (non-zero if valid) including this header. - * The bloblist extends for this many bytes from the start of this header. - * When adding new records, the bloblist can grow up to this size. + * @total_size: The number of total bytes that the bloblist can occupy. + * Any blob producer must check if there is sufficient space before adding + * a record to the bloblist. */ struct bloblist_hdr { u32 magic; @@ -186,9 +186,8 @@ struct bloblist_hdr { u8 version; u8 hdr_size; u8 align_log2; - - u32 alloced; - u32 size; + u32 used_size; + u32 total_size; };

/** @@ -360,10 +359,10 @@ int bloblist_finish(void); * This returns useful information about the bloblist * * @basep: Returns base address of bloblist - * @sizep: Returns the number of bytes used in the bloblist - * @allocedp: Returns the total space allocated to the bloblist + * @tsizep: Returns the total number of bytes of the bloblist + * @usizep: Returns the number of used bytes of the bloblist */ -void bloblist_get_stats(ulong *basep, ulong *sizep, ulong *allocedp); +void bloblist_get_stats(ulong *basep, ulong *tsizep, ulong *usizep);

/** * bloblist_get_base() - Get the base address of the bloblist @@ -379,6 +378,13 @@ ulong bloblist_get_base(void); */ ulong bloblist_get_size(void);

+/** + * bloblist_get_total_size() - Get the total size of the bloblist + * + * Return: the size in bytes + */ +ulong bloblist_get_total_size(void); + /** * bloblist_show_stats() - Show information about the bloblist * diff --git a/test/bloblist.c b/test/bloblist.c index b72603ba9a..dd8e228ea2 100644 --- a/test/bloblist.c +++ b/test/bloblist.c @@ -104,7 +104,8 @@ static int bloblist_test_blob(struct unit_test_state *uts) hdr = clear_bloblist(); ut_assertnull(bloblist_find(TEST_TAG, TEST_BLOBLIST_SIZE)); ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE, 0)); - ut_asserteq(TEST_BLOBLIST_SIZE, bloblist_get_size()); + ut_asserteq(sizeof(struct bloblist_hdr), bloblist_get_size()); + ut_asserteq(TEST_BLOBLIST_SIZE, bloblist_get_total_size()); ut_asserteq(TEST_ADDR, bloblist_get_base()); ut_asserteq(map_to_sysmem(hdr), TEST_ADDR);

@@ -198,9 +199,9 @@ static int bloblist_test_checksum(struct unit_test_state *uts) * change the size or alloced fields, since that will crash the code. * It has to rely on these being correct. */ - hdr->size--; + hdr->total_size--; ut_asserteq(-EFBIG, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE)); - hdr->size++; + hdr->total_size++;

hdr->chksum++; ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE)); @@ -263,10 +264,10 @@ static int bloblist_test_cmd_info(struct unit_test_state *uts) ut_silence_console(uts); console_record_reset(); run_command("bloblist info", 0); - ut_assert_nextline("base: %lx", (ulong)map_to_sysmem(hdr)); - ut_assert_nextline("size: 400 1 KiB"); - ut_assert_nextline("alloced: 48 72 Bytes"); - ut_assert_nextline("free: 3b8 952 Bytes"); + ut_assert_nextline("base: %lx", (ulong)map_to_sysmem(hdr)); + ut_assert_nextline("total size: 400 1 KiB"); + ut_assert_nextline("used size: 48 72 Bytes"); + ut_assert_nextline("free: 3b8 952 Bytes"); ut_assert_console_end(); ut_unsilence_console(uts);

@@ -420,7 +421,7 @@ static int bloblist_test_grow(struct unit_test_state *uts)

ut_asserteq(sizeof(struct bloblist_hdr) + sizeof(struct bloblist_rec) * 2 + small_size * 2, - hdr->alloced); + hdr->used_size);

/* Resize the first one */ ut_assertok(bloblist_resize(TEST_TAG, small_size + 4)); @@ -442,7 +443,7 @@ static int bloblist_test_grow(struct unit_test_state *uts) ut_asserteq(sizeof(struct bloblist_hdr) + sizeof(struct bloblist_rec) * 2 + small_size * 2 + BLOBLIST_BLOB_ALIGN, - hdr->alloced); + hdr->used_size);

return 0; } @@ -472,7 +473,7 @@ static int bloblist_test_shrink(struct unit_test_state *uts) hdr = ptr; ut_asserteq(sizeof(struct bloblist_hdr) + sizeof(struct bloblist_rec) * 2 + small_size * 2, - hdr->alloced); + hdr->used_size);

/* Resize the first one */ new_size = small_size - BLOBLIST_ALIGN - 4; @@ -492,7 +493,7 @@ static int bloblist_test_shrink(struct unit_test_state *uts) ut_asserteq(sizeof(struct bloblist_hdr) + sizeof(struct bloblist_rec) * 2 + small_size * 2 - BLOBLIST_ALIGN, - hdr->alloced); + hdr->used_size);

return 0; } @@ -520,12 +521,12 @@ static int bloblist_test_resize_fail(struct unit_test_state *uts) hdr = ptr; ut_asserteq(sizeof(struct bloblist_hdr) + sizeof(struct bloblist_rec) * 2 + small_size * 2, - hdr->alloced); + hdr->used_size);

/* Resize the first one, to check the boundary conditions */ ut_asserteq(-EINVAL, bloblist_resize(TEST_TAG, -1));

- new_size = small_size + (hdr->size - hdr->alloced); + new_size = small_size + (hdr->total_size - hdr->used_size); ut_asserteq(-ENOSPC, bloblist_resize(TEST_TAG, new_size + 1)); ut_assertok(bloblist_resize(TEST_TAG, new_size));

@@ -557,9 +558,9 @@ static int bloblist_test_resize_last(struct unit_test_state *uts) /* Check the byte after the last blob */ alloced_val = sizeof(struct bloblist_hdr) + sizeof(struct bloblist_rec) * 2 + small_size * 2; - ut_asserteq(alloced_val, hdr->alloced); + ut_asserteq(alloced_val, hdr->used_size); ut_asserteq_ptr((void *)hdr + alloced_val, blob2 + small_size); - ut_asserteq((u8)ERASE_BYTE, *((u8 *)hdr + hdr->alloced)); + ut_asserteq((u8)ERASE_BYTE, *((u8 *)hdr + hdr->used_size));

/* Resize the second one, checking nothing changes */ ut_asserteq(0, bloblist_resize(TEST_TAG2, small_size + 4)); @@ -577,8 +578,8 @@ static int bloblist_test_resize_last(struct unit_test_state *uts)

/* Check that the new top of the allocated blobs has not been touched */ alloced_val += BLOBLIST_BLOB_ALIGN; - ut_asserteq(alloced_val, hdr->alloced); - ut_asserteq((u8)ERASE_BYTE, *((u8 *)hdr + hdr->alloced)); + ut_asserteq(alloced_val, hdr->used_size); + ut_asserteq((u8)ERASE_BYTE, *((u8 *)hdr + hdr->used_size));

return 0; }

Add platform custom function to get bloblist from boot arguments. Check whether boot arguments aligns with the register conventions defined in FW Handoff spec v0.9. Add bloblist related options into qemu default config.

Signed-off-by: Raymond Mao raymond.mao@linaro.org --- Changes in v2 - New patch file created for v2.

board/emulation/qemu-arm/Makefile | 1 + board/emulation/qemu-arm/lowlevel_init.S | 19 +++++++++ board/emulation/qemu-arm/qemu-arm.c | 54 ++++++++++++++++++++++++ configs/qemu_arm64_defconfig | 3 ++ configs/qemu_arm_defconfig | 3 ++ 5 files changed, 80 insertions(+) create mode 100644 board/emulation/qemu-arm/lowlevel_init.S

diff --git a/board/emulation/qemu-arm/Makefile b/board/emulation/qemu-arm/Makefile index a22d1237ff..12821e7083 100644 --- a/board/emulation/qemu-arm/Makefile +++ b/board/emulation/qemu-arm/Makefile @@ -1,3 +1,4 @@ # SPDX-License-Identifier: GPL-2.0+

obj-y += qemu-arm.o +obj-$(CONFIG_OF_BOARD) += lowlevel_init.o diff --git a/board/emulation/qemu-arm/lowlevel_init.S b/board/emulation/qemu-arm/lowlevel_init.S new file mode 100644 index 0000000000..d72d7c938a --- /dev/null +++ b/board/emulation/qemu-arm/lowlevel_init.S @@ -0,0 +1,19 @@ +/* SPDX-License-Identifier: BSD-2-Clause */ +/* + * Copyright (c) 2023, Linaro Limited + */ + +#include <config.h> + +.global save_boot_params +save_boot_params: +#ifdef CONFIG_ARM64 + adr x9, qemu_saved_args + stp x0, x1, [x9] + /* Increment the address by 16 bytes for the next pair of values */ + stp x2, x3, [x9, #16] +#else + ldr r12, =qemu_saved_args + stm r12, {r0, r1, r2, r3} +#endif + b save_boot_params_ret diff --git a/board/emulation/qemu-arm/qemu-arm.c b/board/emulation/qemu-arm/qemu-arm.c index 942f1fff57..a3892630d8 100644 --- a/board/emulation/qemu-arm/qemu-arm.c +++ b/board/emulation/qemu-arm/qemu-arm.c @@ -4,6 +4,9 @@ */

#include <common.h> +#if IS_ENABLED(CONFIG_OF_BOARD) && IS_ENABLED(CONFIG_BLOBLIST) +#include <bloblist.h> +#endif #include <cpu_func.h> #include <dm.h> #include <efi.h> @@ -102,6 +105,16 @@ static struct mm_region qemu_arm64_mem_map[] = { struct mm_region *mem_map = qemu_arm64_mem_map; #endif

+#if IS_ENABLED(CONFIG_OF_BOARD) +/* Boot parameters saved from lowlevel_init.S */ +struct { + unsigned long arg0; + unsigned long arg1; + unsigned long arg2; + unsigned long arg3; +} qemu_saved_args __section(".data"); +#endif + int board_init(void) { return 0; @@ -144,6 +157,47 @@ void *board_fdt_blob_setup(int *err) return (void *)CFG_SYS_SDRAM_BASE; }

+int board_bloblist_from_boot_arg(unsigned long __maybe_unused addr, + unsigned long __maybe_unused size) +{ + int ret = -ENOENT; + +#if IS_ENABLED(CONFIG_OF_BOARD) && IS_ENABLED(CONFIG_BLOBLIST) + unsigned long fdt; + + ret = bloblist_check(qemu_saved_args.arg3, 0); + if (ret) + return ret; + + bloblist_show_stats(); + bloblist_show_list(); + if (gd->bloblist->total_size > size) { + gd->bloblist = NULL; /* Reset the gd bloblist pointer */ + log_err("Bloblist total size:%d, board reserved size:%ld\n", + gd->bloblist->total_size, size); + return -ENOSPC; + } + + /* Check the register conventions */ + fdt = (unsigned long)bloblist_find(BLOBLISTT_CONTROL_FDT, 0); + if (IS_ENABLED(CONFIG_ARM64)) { + if (fdt != qemu_saved_args.arg0 || qemu_saved_args.arg2 != 0) + ret = -EIO; + } else { + if (fdt != qemu_saved_args.arg2 || qemu_saved_args.arg0 != 0) + ret = -EIO; + } + + if (ret) + gd->bloblist = NULL; /* Reset the gd bloblist pointer */ + else + memmove((void *)addr, (void *)qemu_saved_args.arg3, + gd->bloblist->total_size); +#endif + + return ret; +} + void enable_caches(void) { icache_enable(); diff --git a/configs/qemu_arm64_defconfig b/configs/qemu_arm64_defconfig index 5fdf496a45..60fabb5db7 100644 --- a/configs/qemu_arm64_defconfig +++ b/configs/qemu_arm64_defconfig @@ -71,3 +71,6 @@ CONFIG_USB_EHCI_HCD=y CONFIG_USB_EHCI_PCI=y CONFIG_SEMIHOSTING=y CONFIG_TPM=y +CONFIG_BLOBLIST=y +CONFIG_BLOBLIST_ADDR=0x40004000 +CONFIG_BLOBLIST_SIZE=0x4000 diff --git a/configs/qemu_arm_defconfig b/configs/qemu_arm_defconfig index 1347b86f34..d8a94ad038 100644 --- a/configs/qemu_arm_defconfig +++ b/configs/qemu_arm_defconfig @@ -71,3 +71,6 @@ CONFIG_TPM2_MMIO=y CONFIG_USB_EHCI_HCD=y CONFIG_USB_EHCI_PCI=y CONFIG_TPM=y +CONFIG_BLOBLIST=y +CONFIG_BLOBLIST_ADDR=0x40004000 +CONFIG_BLOBLIST_SIZE=0x4000

During bloblist initialization, when CONFIG_OF_BOARD is defined, invoke the platform custom function to load the bloblist via boot arguments from the previous loader. If the bloblist exists, copy it into the fixed bloblist memory region.

Signed-off-by: Raymond Mao raymond.mao@linaro.org --- Changes in v2 - New patch file created for v2.

common/bloblist.c | 29 +++++++++++++---------------- include/bloblist.h | 14 ++++++++++++++ 2 files changed, 27 insertions(+), 16 deletions(-)

diff --git a/common/bloblist.c b/common/bloblist.c index 91d69e9439..251093ecfa 100644 --- a/common/bloblist.c +++ b/common/bloblist.c @@ -477,15 +477,8 @@ int bloblist_init(void) bool fixed = IS_ENABLED(CONFIG_BLOBLIST_FIXED); int ret = -ENOENT; ulong addr, size; - bool expected; - - /** - * We don't expect to find an existing bloblist in the first phase of - * U-Boot that runs. Also we have no way to receive the address of an - * allocated bloblist from a previous stage, so it must be at a fixed - * address. - */ - expected = fixed && !u_boot_first_phase(); + bool expected = fixed; + if (spl_prev_phase() == PHASE_TPL && !IS_ENABLED(CONFIG_TPL_BLOBLIST)) expected = false; if (fixed) @@ -493,14 +486,17 @@ int bloblist_init(void) CONFIG_BLOBLIST_ADDR); size = CONFIG_BLOBLIST_SIZE; if (expected) { - ret = bloblist_check(addr, size); - if (ret) { - log_warning("Expected bloblist at %lx not found (err=%d)\n", + if (IS_ENABLED(CONFIG_OF_BOARD)) + /* Get the bloblist from previous loader */ + ret = board_bloblist_from_boot_arg(addr, size); + else + ret = bloblist_check(addr, size); + + if (ret) + log_warning("Bloblist at %lx not found, err=%d\n", addr, ret); - } else { - /* Get the real size, if it is not what we expected */ + else size = gd->bloblist->total_size; - } } if (ret) { if (CONFIG_IS_ENABLED(BLOBLIST_ALLOC)) { @@ -510,7 +506,8 @@ int bloblist_init(void) return log_msg_ret("alloc", -ENOMEM); addr = map_to_sysmem(ptr); } else if (!fixed) { - return log_msg_ret("!fixed", ret); + return log_msg_ret("BLOBLIST_FIXED is not enabled", + ret); } log_debug("Creating new bloblist size %lx at %lx\n", size, addr); diff --git a/include/bloblist.h b/include/bloblist.h index 0f5afec9f4..e65cd27b90 100644 --- a/include/bloblist.h +++ b/include/bloblist.h @@ -438,6 +438,20 @@ void bloblist_reloc(void *to, uint to_size, void *from, uint from_size); */ int bloblist_init(void);

+#if CONFIG_IS_ENABLED(ARCH_QEMU) +int board_bloblist_from_boot_arg(unsigned long addr, unsigned long size); +#else +/* + * A board need to implement this custom function if it needs to retrieve + * bloblist from a previous loader + */ +static inline int board_bloblist_from_boot_arg(unsigned long __always_unused addr, + unsigned long __always_unused size) +{ + return -1; +} +#endif + #if CONFIG_IS_ENABLED(BLOBLIST) /** * bloblist_maybe_init() - Init the bloblist system if not already done