From d8ef446fec1d5dde5a6238f452d04cda81f8752a Mon Sep 17 00:00:00 2001 From: Michal Simek Date: Fri, 7 Jan 2022 16:38:09 +0100 Subject: [PATCH 01/16] dm: core: Switch order of pinctrl and power domain calls The commit 3ad307784847 ("dm: core: device: enable power domain in probe") introduced enabling power domain when device is probed. By checking this sequence in Linux kernel was found that power domain is handled first followed by pinctrl setting. This patch is switching this order to follow Linux kernel that power domains are handled first follow by pinctrl setting. The issue was found on Xilinx Kria SOM where firmware is blocking setting up pin configuration/muxes without enabling power domain for the specific IP first. Signed-off-by: Michal Simek Reviewed-by: Simon Glass --- drivers/core/device.c | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/drivers/core/device.c b/drivers/core/device.c index 4873c47d10b..d917d4e82da 100644 --- a/drivers/core/device.c +++ b/drivers/core/device.c @@ -518,6 +518,14 @@ int device_probe(struct udevice *dev) dev_or_flags(dev, DM_FLAG_ACTIVATED); + if (CONFIG_IS_ENABLED(POWER_DOMAIN) && dev->parent && + (device_get_uclass_id(dev) != UCLASS_POWER_DOMAIN) && + !(drv->flags & DM_FLAG_DEFAULT_PD_CTRL_OFF)) { + ret = dev_power_domain_on(dev); + if (ret) + goto fail; + } + /* * Process pinctrl for everything except the root device, and * continue regardless of the result of pinctrl. Don't process pinctrl @@ -540,14 +548,6 @@ int device_probe(struct udevice *dev) dev->name, ret, errno_str(ret)); } - if (CONFIG_IS_ENABLED(POWER_DOMAIN) && dev->parent && - (device_get_uclass_id(dev) != UCLASS_POWER_DOMAIN) && - !(drv->flags & DM_FLAG_DEFAULT_PD_CTRL_OFF)) { - ret = dev_power_domain_on(dev); - if (ret) - goto fail; - } - if (CONFIG_IS_ENABLED(IOMMU) && dev->parent && (device_get_uclass_id(dev) != UCLASS_IOMMU)) { ret = dev_iommu_enable(dev); From dca7926c2cb82ff4aea665ed97e38520d39865a5 Mon Sep 17 00:00:00 2001 From: Brian Norris Date: Fri, 7 Jan 2022 15:15:55 -0800 Subject: [PATCH 02/16] patman: Support absolute and ~user-relative alias files Python doesn't naturally support tilde (~) as a user-home marker in paths, but git-config does. So we need to resolve it before continuing. We also shouldn't blindly join the top-level tree with the aliasesfile path, because it might be an absolute path. This resolves warnings like the following: Warning: Cannot find alias file '/path/to/source/tree/~/.git-email' Seen when git-config is like: $ git config sendemail.aliasesfile ~/.git-email Signed-off-by: Brian Norris Reviewed-by: Simon Glass Reviewed-by: Otavio Salvador --- tools/patman/gitutil.py | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/tools/patman/gitutil.py b/tools/patman/gitutil.py index 5e4c1128dcb..e1ef96df22e 100644 --- a/tools/patman/gitutil.py +++ b/tools/patman/gitutil.py @@ -616,9 +616,14 @@ def GetAliasFile(): """ fname = command.OutputOneLine('git', 'config', 'sendemail.aliasesfile', raise_on_error=False) - if fname: - fname = os.path.join(GetTopLevel(), fname.strip()) - return fname + if not fname: + return None + + fname = os.path.expanduser(fname.strip()) + if os.path.isabs(fname): + return fname + + return os.path.join(GetTopLevel(), fname) def GetDefaultUserName(): """Gets the user.name from .gitconfig file. From 880dbc5f808b65f62b47c78939e12d32c1701ed6 Mon Sep 17 00:00:00 2001 From: Heinrich Schuchardt Date: Tue, 11 Jan 2022 01:50:24 +0100 Subject: [PATCH 03/16] sandbox: compatibility of os_get_filesize() MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit U-Boot define loff_t as long long. But the header /usr/include/linux/types.h may not define it. This has lead to a build error on Alpine Linux. So let's use long long instead of loff_t for the size parameter of function os_get_filesize(). Reported-by: Milan P. Stanić Signed-off-by: Heinrich Schuchardt Tested-by: Milan P. Stanić Reviewed-by: Simon Glass --- arch/sandbox/cpu/os.c | 10 ++++++++-- include/os.h | 2 +- 2 files changed, 9 insertions(+), 3 deletions(-) diff --git a/arch/sandbox/cpu/os.c b/arch/sandbox/cpu/os.c index 6837bfceaf6..40ebe322ae0 100644 --- a/arch/sandbox/cpu/os.c +++ b/arch/sandbox/cpu/os.c @@ -624,7 +624,13 @@ const char *os_dirent_get_typename(enum os_dirent_t type) return os_dirent_typename[OS_FILET_UNKNOWN]; } -int os_get_filesize(const char *fname, loff_t *size) +/* + * For compatibility reasons avoid loff_t here. + * U-Boot defines loff_t as long long. + * But /usr/include/linux/types.h may not define it at all. + * Alpine Linux being one example. + */ +int os_get_filesize(const char *fname, long long *size) { struct stat buf; int ret; @@ -667,7 +673,7 @@ int os_read_ram_buf(const char *fname) { struct sandbox_state *state = state_get_current(); int fd, ret; - loff_t size; + long long size; ret = os_get_filesize(fname, &size); if (ret < 0) diff --git a/include/os.h b/include/os.h index 4cbcbd93a71..10e198cf503 100644 --- a/include/os.h +++ b/include/os.h @@ -266,7 +266,7 @@ const char *os_dirent_get_typename(enum os_dirent_t type); * @size: size of file is returned if no error * Return: 0 on success or -1 if an error ocurred */ -int os_get_filesize(const char *fname, loff_t *size); +int os_get_filesize(const char *fname, long long *size); /** * os_putc() - write a character to the controlling OS terminal From 5ecdd529ae38fecd35bfc41869058802c804a01e Mon Sep 17 00:00:00 2001 From: Andre Przywara Date: Tue, 11 Jan 2022 15:34:50 +0000 Subject: [PATCH 04/16] genboardscfg: limit to 240 jobs When genboardscfg.py is run on machines with 255 or more cores, the process will consume more than 1024 file descriptors, which is a common standard ulimit for user processes. As a consequence it will fail with a lenghty Python trace, with the almost hidden message: OSError: [Errno 24] Too many open files It's somewhat questionable whether that level of parallelity is actually useful for genboardscfg, so we limit the *default* number of jobs to the safe number of 240, to avoid the problem. If a user persists, she can still force a higher number via the -j parameter - hopefully having raised the ulimit accordingly beforehand. Signed-off-by: Andre Przywara Reviewed-by: Heinrich Schuchardt Reviewed-by: Simon Glass --- tools/genboardscfg.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/genboardscfg.py b/tools/genboardscfg.py index 4ee7aa1f891..07bf681d1d9 100755 --- a/tools/genboardscfg.py +++ b/tools/genboardscfg.py @@ -430,7 +430,7 @@ def main(): # Add options here parser.add_option('-f', '--force', action="store_true", default=False, help='regenerate the output even if it is new') - parser.add_option('-j', '--jobs', type='int', default=cpu_count, + parser.add_option('-j', '--jobs', type='int', default=min(cpu_count, 240), help='the number of jobs to run simultaneously') parser.add_option('-o', '--output', default=OUTPUT_FILE, help='output file [default=%s]' % OUTPUT_FILE) From 78aac05eb1de0f70f7643a575ff543211d2cc6f4 Mon Sep 17 00:00:00 2001 From: Simon Glass Date: Thu, 13 Jan 2022 06:47:55 -0700 Subject: [PATCH 05/16] stddef: Avoid warning with clang with offsetof() Some bright sparks have decided that a cast on a constant cannot be a constant, so offsetof() produces this warning on clang-10: include/intel_gnvs.h:113:1: error: static_assert expression is not an integral constant expression check_member(acpi_global_nvs, unused2, GNVS_CHROMEOS_ACPI_OFFSET); ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ include/linux/kernel.h:284:2: note: expanded from macro 'check_member' offsetof(struct structure, member) == (offset), \ ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ include/linux/stddef.h:20:32: note: expanded from macro 'offsetof' ^ include/intel_gnvs.h:113:1: note: cast that performs the conversions of a reinterpret_cast is ot allowed in a constant expression include/linux/stddef.h:20:33: note: expanded from macro 'offsetof' Fix it by using the compiler built-in version, if available. This syncs the function to the same implementation as Linux v5.16 in this header file. Signed-off-by: Simon Glass --- include/linux/stddef.h | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/include/linux/stddef.h b/include/linux/stddef.h index c540f6100d4..a7f546fdfe5 100644 --- a/include/linux/stddef.h +++ b/include/linux/stddef.h @@ -1,6 +1,8 @@ #ifndef _LINUX_STDDEF_H #define _LINUX_STDDEF_H +#include + #undef NULL #if defined(__cplusplus) #define NULL 0 @@ -14,7 +16,11 @@ #ifndef __CHECKER__ #undef offsetof -#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER) +#ifdef __compiler_offsetof +#define offsetof(TYPE, MEMBER) __compiler_offsetof(TYPE, MEMBER) +#else +#define offsetof(TYPE, MEMBER) ((size_t)&((TYPE *)0)->MEMBER) +#endif #endif #endif From f350f67764fe2c18b92da38eec75be359fc825ec Mon Sep 17 00:00:00 2001 From: Simon Glass Date: Wed, 12 Jan 2022 19:26:15 -0700 Subject: [PATCH 06/16] fdt: Drop SPL_BUILD macro This old macro is not needed anymore since we can use IS_ENABLED() now. Drop it. Signed-off-by: Simon Glass --- drivers/serial/serial-uclass.c | 3 ++- include/fdtdec.h | 6 ------ 2 files changed, 2 insertions(+), 7 deletions(-) diff --git a/drivers/serial/serial-uclass.c b/drivers/serial/serial-uclass.c index 30d44214d7d..96a1cb65ba2 100644 --- a/drivers/serial/serial-uclass.c +++ b/drivers/serial/serial-uclass.c @@ -104,7 +104,8 @@ static void serial_find_console_or_panic(void) } } } - if (!SPL_BUILD || !CONFIG_IS_ENABLED(OF_CONTROL) || !blob) { + if (!IS_ENABLED(CONFIG_SPL_BUILD) || !CONFIG_IS_ENABLED(OF_CONTROL) || + !blob) { /* * Try to use CONFIG_CONS_INDEX if available (it is numbered * from 1!). diff --git a/include/fdtdec.h b/include/fdtdec.h index 09525ce510a..15f2d2bbbaa 100644 --- a/include/fdtdec.h +++ b/include/fdtdec.h @@ -49,12 +49,6 @@ struct fdt_memory { struct bd_info; -#ifdef CONFIG_SPL_BUILD -#define SPL_BUILD 1 -#else -#define SPL_BUILD 0 -#endif - /** * enum fdt_source_t - indicates where the devicetree came from * From ff3bd4983c1fe53975e44668619b07e10f8a0cd9 Mon Sep 17 00:00:00 2001 From: Simon Glass Date: Wed, 12 Jan 2022 19:26:16 -0700 Subject: [PATCH 07/16] bloblist: Put the magic number first It seems best to put the magic number right at the start of the bloblist header, so it is easier to check. This is how devicetree works. Make this change now, before other projects make use of bloblist. Other changes may be needed / discussed, but that is TBD. Add a checker function as well. Signed-off-by: Simon Glass --- include/bloblist.h | 25 +++++++++++++++++++++++-- test/bloblist.c | 7 +++++++ 2 files changed, 30 insertions(+), 2 deletions(-) diff --git a/include/bloblist.h b/include/bloblist.h index 9f007c7a94d..29ea5a768a6 100644 --- a/include/bloblist.h +++ b/include/bloblist.h @@ -13,6 +13,8 @@ #ifndef __BLOBLIST_H #define __BLOBLIST_H +#include + enum { BLOBLIST_VERSION = 0, BLOBLIST_MAGIC = 0xb00757a3, @@ -59,11 +61,11 @@ enum bloblist_tag_t { * Each bloblist record is aligned to a 16-byte boundary and follows immediately * from the last. * + * @magic: BLOBLIST_MAGIC * @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 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. @@ -78,10 +80,10 @@ enum bloblist_tag_t { * calculation. */ struct bloblist_hdr { + u32 magic; u32 version; u32 hdr_size; u32 flags; - u32 magic; u32 size; u32 alloced; @@ -111,6 +113,25 @@ struct bloblist_rec { u32 spare; }; +/** + * bloblist_check_magic() - return a bloblist if the magic matches + * + * @addr: Address to check + * @return pointer to bloblist, if the magic matches, else NULL + */ +static inline void *bloblist_check_magic(ulong addr) +{ + u32 *ptr; + + if (!addr) + return NULL; + ptr = map_sysmem(addr, 0); + if (*ptr != BLOBLIST_MAGIC) + return NULL; + + return ptr; +} + /** * bloblist_find() - Find a blob * diff --git a/test/bloblist.c b/test/bloblist.c index b48be38dc3e..525e94b7217 100644 --- a/test/bloblist.c +++ b/test/bloblist.c @@ -71,7 +71,9 @@ 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, 0)); + ut_asserteq_ptr(hdr, bloblist_check_magic(TEST_ADDR)); hdr->version++; ut_asserteq(-EPROTONOSUPPORT, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE)); @@ -83,6 +85,11 @@ static int bloblist_test_init(struct unit_test_state *uts) ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE)); ut_assertok(bloblist_finish()); ut_assertok(bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE)); + + hdr->magic++; + ut_asserteq_ptr(NULL, bloblist_check_magic(TEST_ADDR)); + hdr->magic--; + hdr->flags++; ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE)); From 7f3b79af548264ea2f482eaeffee6b1d716ce274 Mon Sep 17 00:00:00 2001 From: Simon Glass Date: Wed, 12 Jan 2022 19:26:17 -0700 Subject: [PATCH 08/16] bloblist: Rename the SPL tag Add a U_BOOT prefix to this tag since it is specific to the U-Boot project. Signed-off-by: Simon Glass --- arch/x86/cpu/broadwell/cpu_from_spl.c | 4 ++-- common/bloblist.c | 2 +- common/board_f.c | 2 +- common/spl/spl.c | 4 ++-- include/bloblist.h | 2 +- 5 files changed, 7 insertions(+), 7 deletions(-) diff --git a/arch/x86/cpu/broadwell/cpu_from_spl.c b/arch/x86/cpu/broadwell/cpu_from_spl.c index e5f62e7187c..df5a9675ee4 100644 --- a/arch/x86/cpu/broadwell/cpu_from_spl.c +++ b/arch/x86/cpu/broadwell/cpu_from_spl.c @@ -23,7 +23,7 @@ int dram_init(void) { struct spl_handoff *ho; - ho = bloblist_find(BLOBLISTT_SPL_HANDOFF, sizeof(*ho)); + ho = bloblist_find(BLOBLISTT_U_BOOT_SPL_HANDOFF, sizeof(*ho)); if (!ho) return log_msg_ret("Missing SPL hand-off info", -ENOENT); handoff_load_dram_size(ho); @@ -56,7 +56,7 @@ int dram_init_banksize(void) { struct spl_handoff *ho; - ho = bloblist_find(BLOBLISTT_SPL_HANDOFF, sizeof(*ho)); + ho = bloblist_find(BLOBLISTT_U_BOOT_SPL_HANDOFF, sizeof(*ho)); if (!ho) return log_msg_ret("Missing SPL hand-off info", -ENOENT); handoff_load_dram_banks(ho); diff --git a/common/bloblist.c b/common/bloblist.c index 01b04103d91..89b415d6178 100644 --- a/common/bloblist.c +++ b/common/bloblist.c @@ -32,7 +32,7 @@ DECLARE_GLOBAL_DATA_PTR; static const char *const tag_name[] = { [BLOBLISTT_NONE] = "(none)", [BLOBLISTT_EC_HOSTEVENT] = "EC host event", - [BLOBLISTT_SPL_HANDOFF] = "SPL hand-off", + [BLOBLISTT_U_BOOT_SPL_HANDOFF] = "SPL hand-off", [BLOBLISTT_VBOOT_CTX] = "Chrome OS vboot context", [BLOBLISTT_VBOOT_HANDOFF] = "Chrome OS vboot hand-off", [BLOBLISTT_ACPI_GNVS] = "ACPI GNVS", diff --git a/common/board_f.c b/common/board_f.c index dd69c3b6b77..a68760092ac 100644 --- a/common/board_f.c +++ b/common/board_f.c @@ -283,7 +283,7 @@ static int setup_mon_len(void) static int setup_spl_handoff(void) { #if CONFIG_IS_ENABLED(HANDOFF) - gd->spl_handoff = bloblist_find(BLOBLISTT_SPL_HANDOFF, + gd->spl_handoff = bloblist_find(BLOBLISTT_U_BOOT_SPL_HANDOFF, sizeof(struct spl_handoff)); debug("Found SPL hand-off info %p\n", gd->spl_handoff); #endif diff --git a/common/spl/spl.c b/common/spl/spl.c index 4c101ec5d34..f51d1f32052 100644 --- a/common/spl/spl.c +++ b/common/spl/spl.c @@ -408,7 +408,7 @@ static int setup_spl_handoff(void) { struct spl_handoff *ho; - ho = bloblist_ensure(BLOBLISTT_SPL_HANDOFF, sizeof(struct spl_handoff)); + ho = bloblist_ensure(BLOBLISTT_U_BOOT_SPL_HANDOFF, sizeof(struct spl_handoff)); if (!ho) return -ENOENT; @@ -425,7 +425,7 @@ static int write_spl_handoff(void) struct spl_handoff *ho; int ret; - ho = bloblist_find(BLOBLISTT_SPL_HANDOFF, sizeof(struct spl_handoff)); + ho = bloblist_find(BLOBLISTT_U_BOOT_SPL_HANDOFF, sizeof(struct spl_handoff)); if (!ho) return -ENOENT; handoff_save_dram(ho); diff --git a/include/bloblist.h b/include/bloblist.h index 29ea5a768a6..d4d48f76ff4 100644 --- a/include/bloblist.h +++ b/include/bloblist.h @@ -27,7 +27,7 @@ enum bloblist_tag_t { /* Vendor-specific tags are permitted here */ BLOBLISTT_EC_HOSTEVENT, /* Chromium OS EC host-event mask */ - BLOBLISTT_SPL_HANDOFF, /* Hand-off info from SPL */ + BLOBLISTT_U_BOOT_SPL_HANDOFF, /* Hand-off info from SPL */ BLOBLISTT_VBOOT_CTX, /* Chromium OS verified boot context */ BLOBLISTT_VBOOT_HANDOFF, /* Chromium OS internal handoff info */ /* From f9abc1cac1130279b486c51056b2e6fba99633b1 Mon Sep 17 00:00:00 2001 From: Simon Glass Date: Wed, 12 Jan 2022 19:26:18 -0700 Subject: [PATCH 09/16] bloblist: Drop unused tags The EC event log tag is no-longer used. The vboot handoff is now handled by the vboot context instead. Drop these unused tags. Signed-off-by: Simon Glass --- common/bloblist.c | 4 +--- include/bloblist.h | 2 -- test/bloblist.c | 4 ++-- 3 files changed, 3 insertions(+), 7 deletions(-) diff --git a/common/bloblist.c b/common/bloblist.c index 89b415d6178..784eff61dea 100644 --- a/common/bloblist.c +++ b/common/bloblist.c @@ -31,10 +31,8 @@ DECLARE_GLOBAL_DATA_PTR; static const char *const tag_name[] = { [BLOBLISTT_NONE] = "(none)", - [BLOBLISTT_EC_HOSTEVENT] = "EC host event", - [BLOBLISTT_U_BOOT_SPL_HANDOFF] = "SPL hand-off", + [BLOBLISTT_U_BOOT_SPL_HANDOFF] = "SPL hand-off", [BLOBLISTT_VBOOT_CTX] = "Chrome OS vboot context", - [BLOBLISTT_VBOOT_HANDOFF] = "Chrome OS vboot hand-off", [BLOBLISTT_ACPI_GNVS] = "ACPI GNVS", [BLOBLISTT_INTEL_VBT] = "Intel Video-BIOS table", [BLOBLISTT_TPM2_TCG_LOG] = "TPM v2 log space", diff --git a/include/bloblist.h b/include/bloblist.h index d4d48f76ff4..fac25907c07 100644 --- a/include/bloblist.h +++ b/include/bloblist.h @@ -26,10 +26,8 @@ enum bloblist_tag_t { BLOBLISTT_NONE = 0, /* Vendor-specific tags are permitted here */ - BLOBLISTT_EC_HOSTEVENT, /* Chromium OS EC host-event mask */ BLOBLISTT_U_BOOT_SPL_HANDOFF, /* Hand-off info from SPL */ BLOBLISTT_VBOOT_CTX, /* Chromium OS verified boot context */ - BLOBLISTT_VBOOT_HANDOFF, /* Chromium OS internal handoff info */ /* * Advanced Configuration and Power Interface Global Non-Volatile * Sleeping table. This forms part of the ACPI tables passed to Linux. diff --git a/test/bloblist.c b/test/bloblist.c index 525e94b7217..2e8e23d77dd 100644 --- a/test/bloblist.c +++ b/test/bloblist.c @@ -289,9 +289,9 @@ static int bloblist_test_cmd_list(struct unit_test_state *uts) console_record_reset(); run_command("bloblist list", 0); ut_assert_nextline("Address Size Tag Name"); - ut_assert_nextline("%08lx %8x 1 EC host event", + ut_assert_nextline("%08lx %8x 1 SPL hand-off", (ulong)map_to_sysmem(data), TEST_SIZE); - ut_assert_nextline("%08lx %8x 2 SPL hand-off", + ut_assert_nextline("%08lx %8x 2 Chrome OS vboot context", (ulong)map_to_sysmem(data2), TEST_SIZE2); ut_assert_console_end(); ut_unsilence_console(uts); From f16ec77784b4a2ffdba82bc4044581131aea44e4 Mon Sep 17 00:00:00 2001 From: Simon Glass Date: Wed, 12 Jan 2022 19:26:19 -0700 Subject: [PATCH 10/16] bloblist: Use explicit numbering for the tags At present if someone adds a tag in the middle of the list it works well enough within a U-Boot build. But if these tags are used in another project, or with an older version of SPL, the numbers make become inconsistent. Use explicit tag numbers that never change, to resolve this problem. Allocate areas for existing U-Boot tags and set up an area for use by projects and vendors, as well as for private use. Keep tags above 0x10000 unallocated for now. Update bloblist_tag_name() and the tests to work with this new setup. Signed-off-by: Simon Glass --- common/bloblist.c | 45 ++++++++++++++++++++++++------------- include/bloblist.h | 56 +++++++++++++++++++++++++++++++++++++--------- test/bloblist.c | 12 +++++----- 3 files changed, 82 insertions(+), 31 deletions(-) diff --git a/common/bloblist.c b/common/bloblist.c index 784eff61dea..baf1d371b71 100644 --- a/common/bloblist.c +++ b/common/bloblist.c @@ -29,24 +29,39 @@ DECLARE_GLOBAL_DATA_PTR; -static const char *const tag_name[] = { - [BLOBLISTT_NONE] = "(none)", - [BLOBLISTT_U_BOOT_SPL_HANDOFF] = "SPL hand-off", - [BLOBLISTT_VBOOT_CTX] = "Chrome OS vboot context", - [BLOBLISTT_ACPI_GNVS] = "ACPI GNVS", - [BLOBLISTT_INTEL_VBT] = "Intel Video-BIOS table", - [BLOBLISTT_TPM2_TCG_LOG] = "TPM v2 log space", - [BLOBLISTT_TCPA_LOG] = "TPM log space", - [BLOBLISTT_ACPI_TABLES] = "ACPI tables for x86", - [BLOBLISTT_SMBIOS_TABLES] = "SMBIOS tables for x86", +static struct tag_name { + enum bloblist_tag_t tag; + const char *name; +} tag_name[] = { + { BLOBLISTT_NONE, "(none)" }, + + /* BLOBLISTT_AREA_FIRMWARE_TOP */ + + /* BLOBLISTT_AREA_FIRMWARE */ + { BLOBLISTT_ACPI_GNVS, "ACPI GNVS" }, + { BLOBLISTT_INTEL_VBT, "Intel Video-BIOS table" }, + { BLOBLISTT_TPM2_TCG_LOG, "TPM v2 log space" }, + { BLOBLISTT_TCPA_LOG, "TPM log space" }, + { BLOBLISTT_ACPI_TABLES, "ACPI tables for x86" }, + { BLOBLISTT_SMBIOS_TABLES, "SMBIOS tables for x86" }, + { BLOBLISTT_VBOOT_CTX, "Chrome OS vboot context" }, + + /* BLOBLISTT_PROJECT_AREA */ + { BLOBLISTT_U_BOOT_SPL_HANDOFF, "SPL hand-off" }, + + /* BLOBLISTT_VENDOR_AREA */ }; const char *bloblist_tag_name(enum bloblist_tag_t tag) { - if (tag < 0 || tag >= BLOBLISTT_COUNT) - return "invalid"; + int i; - return tag_name[tag]; + for (i = 0; i < ARRAY_SIZE(tag_name); i++) { + if (tag_name[i].tag == tag) + return tag_name[i].name; + } + + return "invalid"; } static struct bloblist_rec *bloblist_first_blob(struct bloblist_hdr *hdr) @@ -381,10 +396,10 @@ void bloblist_show_list(void) struct bloblist_hdr *hdr = gd->bloblist; struct bloblist_rec *rec; - printf("%-8s %8s Tag Name\n", "Address", "Size"); + printf("%-8s %8s Tag Name\n", "Address", "Size"); for (rec = bloblist_first_blob(hdr); rec; rec = bloblist_next_blob(hdr, rec)) { - printf("%08lx %8x %3d %s\n", + printf("%08lx %8x %4x %s\n", (ulong)map_to_sysmem((void *)rec + rec->hdr_size), rec->size, rec->tag, bloblist_tag_name(rec->tag)); } diff --git a/include/bloblist.h b/include/bloblist.h index fac25907c07..5de4545160e 100644 --- a/include/bloblist.h +++ b/include/bloblist.h @@ -25,21 +25,57 @@ enum { enum bloblist_tag_t { BLOBLISTT_NONE = 0, - /* Vendor-specific tags are permitted here */ - BLOBLISTT_U_BOOT_SPL_HANDOFF, /* Hand-off info from SPL */ - BLOBLISTT_VBOOT_CTX, /* Chromium OS verified boot context */ + /* + * Standard area to allocate blobs used across firmware components, for + * things that are very commonly used, particularly in multiple + * projects. + */ + BLOBLISTT_AREA_FIRMWARE_TOP = 0x1, + + /* Standard area to allocate blobs used across firmware components */ + BLOBLISTT_AREA_FIRMWARE = 0x100, /* * Advanced Configuration and Power Interface Global Non-Volatile * Sleeping table. This forms part of the ACPI tables passed to Linux. */ - BLOBLISTT_ACPI_GNVS, - BLOBLISTT_INTEL_VBT, /* Intel Video-BIOS table */ - BLOBLISTT_TPM2_TCG_LOG, /* TPM v2 log space */ - BLOBLISTT_TCPA_LOG, /* TPM log space */ - BLOBLISTT_ACPI_TABLES, /* ACPI tables for x86 */ - BLOBLISTT_SMBIOS_TABLES, /* SMBIOS tables for x86 */ + BLOBLISTT_ACPI_GNVS = 0x100, + BLOBLISTT_INTEL_VBT = 0x101, /* Intel Video-BIOS table */ + BLOBLISTT_TPM2_TCG_LOG = 0x102, /* TPM v2 log space */ + BLOBLISTT_TCPA_LOG = 0x103, /* TPM log space */ + BLOBLISTT_ACPI_TABLES = 0x104, /* ACPI tables for x86 */ + BLOBLISTT_SMBIOS_TABLES = 0x105, /* SMBIOS tables for x86 */ + BLOBLISTT_VBOOT_CTX = 0x106, /* Chromium OS verified boot context */ - BLOBLISTT_COUNT + /* + * Project-specific tags are permitted here. Projects can be open source + * or not, but the format of the data must be fuily documented in an + * open source project, including all fields, bits, etc. Naming should + * be: BLOBLISTT__ + */ + BLOBLISTT_PROJECT_AREA = 0x8000, + BLOBLISTT_U_BOOT_SPL_HANDOFF = 0x8000, /* Hand-off info from SPL */ + + /* + * Vendor-specific tags are permitted here. Projects can be open source + * or not, but the format of the data must be fuily documented in an + * open source project, including all fields, bits, etc. Naming should + * be BLOBLISTT__ + */ + BLOBLISTT_VENDOR_AREA = 0xc000, + + /* Tags after this are not allocated for now */ + BLOBLISTT_EXPANSION = 0x10000, + + /* + * Tags from here are on reserved for private use within a single + * firmware binary (i.e. a single executable or phase of a project). + * These tags can be passed between binaries within a local + * implementation, but cannot be used in upstream code. Allocate a + * tag in one of the areas above if you want that. + * + * This area may move in future. + */ + BLOBLISTT_PRIVATE_AREA = 0xffff0000, }; /** diff --git a/test/bloblist.c b/test/bloblist.c index 2e8e23d77dd..c5788d5cd82 100644 --- a/test/bloblist.c +++ b/test/bloblist.c @@ -19,9 +19,9 @@ DECLARE_GLOBAL_DATA_PTR; UNIT_TEST(_name, _flags, bloblist_test) enum { - TEST_TAG = 1, - TEST_TAG2 = 2, - TEST_TAG_MISSING = 3, + TEST_TAG = BLOBLISTT_U_BOOT_SPL_HANDOFF, + TEST_TAG2 = BLOBLISTT_VBOOT_CTX, + TEST_TAG_MISSING = 0x10000, TEST_SIZE = 10, TEST_SIZE2 = 20, @@ -288,10 +288,10 @@ static int bloblist_test_cmd_list(struct unit_test_state *uts) ut_silence_console(uts); console_record_reset(); run_command("bloblist list", 0); - ut_assert_nextline("Address Size Tag Name"); - ut_assert_nextline("%08lx %8x 1 SPL hand-off", + ut_assert_nextline("Address Size Tag Name"); + ut_assert_nextline("%08lx %8x 8000 SPL hand-off", (ulong)map_to_sysmem(data), TEST_SIZE); - ut_assert_nextline("%08lx %8x 2 Chrome OS vboot context", + ut_assert_nextline("%08lx %8x 106 Chrome OS vboot context", (ulong)map_to_sysmem(data2), TEST_SIZE2); ut_assert_console_end(); ut_unsilence_console(uts); From 1d8bbd76f097a2be4021668ce379f9c88a5d38fc Mon Sep 17 00:00:00 2001 From: Simon Glass Date: Wed, 12 Jan 2022 19:26:20 -0700 Subject: [PATCH 11/16] bloblist: Use LOG_CATEGORY to simply logging Use the convenience functions to improve readability. Signed-off-by: Simon Glass --- common/bloblist.c | 21 ++++++++++----------- 1 file changed, 10 insertions(+), 11 deletions(-) diff --git a/common/bloblist.c b/common/bloblist.c index baf1d371b71..b5fea12b697 100644 --- a/common/bloblist.c +++ b/common/bloblist.c @@ -4,6 +4,8 @@ * Written by Simon Glass */ +#define LOG_CATEGORY LOGC_BLOBLIST + #include #include #include @@ -133,9 +135,8 @@ static int bloblist_addrec(uint tag, int size, int align, new_alloced = data_start + ALIGN(size, 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); + log_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; @@ -249,14 +250,13 @@ static int bloblist_resize_rec(struct bloblist_hdr *hdr, expand_by = ALIGN(new_size - rec->size, BLOBLIST_ALIGN); new_alloced = ALIGN(hdr->alloced + expand_by, BLOBLIST_ALIGN); if (new_size < 0) { - log(LOGC_BLOBLIST, LOGL_DEBUG, - "Attempt to shrink blob size below 0 (%x)\n", new_size); + 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(LOGC_BLOBLIST, LOGL_ERR, - "Failed to allocate %x bytes size=%x, need size=%x\n", - new_size, hdr->size, new_alloced); + log_err("Failed to allocate %x bytes size=%x, need size=%x\n", + new_size, hdr->size, new_alloced); return log_msg_ret("alloc", -ENOSPC); } @@ -347,8 +347,7 @@ int bloblist_check(ulong addr, uint 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); + log_err("Checksum %x != %x\n", hdr->chksum, chksum); return log_msg_ret("Bad checksum", -EIO); } gd->bloblist = hdr; @@ -446,7 +445,7 @@ int bloblist_init(void) } ret = bloblist_new(addr, CONFIG_BLOBLIST_SIZE, 0); } else { - log(LOGC_BLOBLIST, LOGL_DEBUG, "Found existing bloblist\n"); + log_debug("Found existing bloblist\n"); } return ret; From 5938d654dec74ba42ab06f06d6e0c89b006099b8 Mon Sep 17 00:00:00 2001 From: Simon Glass Date: Wed, 12 Jan 2022 19:26:21 -0700 Subject: [PATCH 12/16] bloblist: Use 'phase' consistently for bloblists We typically refer to the different U-Boot builds that a board runs through as phases. This avoids confusion with the word 'stage' which is used with bootstage, for example. Fix up some bloblist Kconfig help which uses the wrong term. Signed-off-by: Simon Glass --- common/Kconfig | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/common/Kconfig b/common/Kconfig index 0892d9be362..ca136b1ac7f 100644 --- a/common/Kconfig +++ b/common/Kconfig @@ -717,7 +717,7 @@ config BLOBLIST 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. + through to the next phase of the boot. config SPL_BLOBLIST bool "Support for a bloblist in SPL" @@ -746,7 +746,7 @@ config BLOBLIST_SIZE 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. + proper), and this sane bloblist is used for subsequent phases. config BLOBLIST_ALLOC bool "Allocate bloblist" @@ -760,7 +760,7 @@ config BLOBLIST_ADDR default 0xc000 if SANDBOX 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. + which runs. Subsequent U-Boot phases typically use the same address. This is not used if BLOBLIST_ALLOC is selected. From 99047f5d7f9cb013f7040edd7d20a70cc30646b5 Mon Sep 17 00:00:00 2001 From: Simon Glass Date: Wed, 12 Jan 2022 19:26:22 -0700 Subject: [PATCH 13/16] bloblist: Refactor Kconfig to support alloc or fixed At present we do support allocating the bloblist but the Kconfig is a bit strange, since we still have to specify an address in that case. Partly this is because it is a pain to have CONFIG options that disappears when its dependency is enabled. It means that we must have #ifdefs in the code, either in the C code or header file. Make use of IF_ENABLED_INT() and its friend to solve that problem, so we can separate out the location of bloblist into a choice. Put the address and size into variables so we can log the result. Add the options for SPL as well, so we can use CONFIG_IS_ENABLED(). Signed-off-by: Simon Glass --- common/Kconfig | 91 +++++++++++++++++++++++++++++++++++++++++----- common/bloblist.c | 39 ++++++++++++-------- include/bloblist.h | 10 +++++ 3 files changed, 116 insertions(+), 24 deletions(-) diff --git a/common/Kconfig b/common/Kconfig index ca136b1ac7f..82cd864baf9 100644 --- a/common/Kconfig +++ b/common/Kconfig @@ -738,15 +738,17 @@ config TPL_BLOBLIST if BLOBLIST -config BLOBLIST_SIZE - hex "Size of bloblist" - depends on BLOBLIST - default 0x400 +choice + prompt "Bloblist location" 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 phases. + Select the location of the bloblist, via various means. + +config BLOBLIST_FIXED + bool "Place bloblist at a fixed address in memory" + help + Select this to used a fixed memory address for the bloblist. If the + bloblist exists at this address from a previous phase, it used as is. + If not it is created at this address in U-Boot. config BLOBLIST_ALLOC bool "Allocate bloblist" @@ -755,18 +757,31 @@ config BLOBLIST_ALLOC specify a fixed address on systems where this is unknown or can change at runtime. +endchoice + config BLOBLIST_ADDR hex "Address of bloblist" default 0xc000 if SANDBOX + depends on BLOBLIST_FIXED help Sets the address of the bloblist, set up by the first part of U-Boot which runs. Subsequent U-Boot phases typically use the same address. This is not used if BLOBLIST_ALLOC is selected. +config BLOBLIST_SIZE + hex "Size of 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 phases. + config BLOBLIST_SIZE_RELOC hex "Size of bloblist after relocation" - default BLOBLIST_SIZE + default BLOBLIST_SIZE if BLOBLIST_FIXED || BLOBLIST_ALLOC + default 0 if BLOBLIST_PASSAGE help Sets the size of the bloblist in bytes after relocation. Since U-Boot has a lot more memory available then, it is possible to use a larger @@ -775,6 +790,64 @@ config BLOBLIST_SIZE_RELOC endif # BLOBLIST +if SPL_BLOBLIST + +choice + prompt "Bloblist location in SPL" + help + Select the location of the bloblist, via various means. Typically + you should use the same value for SPL as for U-Boot, since they need + to look in the same place. But if BLOBLIST_ALLOC is used, then a + fresh bloblist will be created each time, since there is no shared + address (between phases) for the bloblist. + +config SPL_BLOBLIST_FIXED + bool "Place bloblist at a fixed address in memory" + help + Select this to used a fixed memory address for the bloblist. If the + bloblist exists at this address from a previous phase, it used as is. + If not it is created at this address in SPL. + +config SPL_BLOBLIST_ALLOC + bool "Allocate bloblist" + help + Allocate the bloblist using malloc(). This avoids the need to + specify a fixed address on systems where this is unknown or can + change at runtime. + +endchoice + +endif # SPL_BLOBLIST + +if TPL_BLOBLIST + +choice + prompt "Bloblist location in TPL" + help + Select the location of the bloblist, via various means. Typically + you should use the same value for SPL as for U-Boot, since they need + to look in the same place. But if BLOBLIST_ALLOC is used, then a + fresh bloblist will be created each time, since there is no shared + address (between phases) for the bloblist. + +config TPL_BLOBLIST_FIXED + bool "Place bloblist at a fixed address in memory" + help + Select this to used a fixed memory address for the bloblist. If the + bloblist exists at this address from a previous phase, it used as is. + If not it is created at this address in TPL. + +config TPL_BLOBLIST_ALLOC + bool "Allocate bloblist" + help + Allocate the bloblist using malloc(). This avoids the need to + specify a fixed address on systems where this is unknown or can + change at runtime. + +endchoice + +endif # TPL_BLOBLIST + endmenu source "common/spl/Kconfig" diff --git a/common/bloblist.c b/common/bloblist.c index b5fea12b697..0049bb9a395 100644 --- a/common/bloblist.c +++ b/common/bloblist.c @@ -4,6 +4,7 @@ * Written by Simon Glass */ +#define LOG_DEBUG #define LOG_CATEGORY LOGC_BLOBLIST #include @@ -360,6 +361,8 @@ 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, + (ulong)map_to_sysmem(hdr)); return 0; } @@ -415,8 +418,9 @@ void bloblist_reloc(void *to, uint to_size, void *from, uint from_size) int bloblist_init(void) { - bool expected; int ret = -ENOENT; + ulong addr, size; + bool expected; /** * Wed expect to find an existing bloblist in the first phase of U-Boot @@ -425,27 +429,32 @@ int bloblist_init(void) expected = !u_boot_first_phase(); if (spl_prev_phase() == PHASE_TPL && !IS_ENABLED(CONFIG_TPL_BLOBLIST)) expected = false; - if (expected) - ret = bloblist_check(CONFIG_BLOBLIST_ADDR, - CONFIG_BLOBLIST_SIZE); + addr = 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", + addr, ret); + } else { + /* Get the real size, if it is not what we expected */ + size = gd->bloblist->size; + } + } if (ret) { - ulong addr; - - log(LOGC_BLOBLIST, expected ? LOGL_WARNING : LOGL_DEBUG, - "Existing bloblist not found: creating new bloblist\n"); - if (IS_ENABLED(CONFIG_BLOBLIST_ALLOC)) { - void *ptr = memalign(BLOBLIST_ALIGN, - CONFIG_BLOBLIST_SIZE); + if (CONFIG_IS_ENABLED(BLOBLIST_ALLOC)) { + void *ptr = memalign(BLOBLIST_ALIGN, size); if (!ptr) return log_msg_ret("alloc", -ENOMEM); addr = map_to_sysmem(ptr); - } else { - addr = CONFIG_BLOBLIST_ADDR; } - ret = bloblist_new(addr, CONFIG_BLOBLIST_SIZE, 0); + log_debug("Creating new bloblist size %lx at %lx\n", size, + addr); + ret = bloblist_new(addr, size, 0); } else { - log_debug("Found existing bloblist\n"); + log_debug("Found existing bloblist size %lx at %lx\n", size, + addr); } return ret; diff --git a/include/bloblist.h b/include/bloblist.h index 5de4545160e..13f2b3f1009 100644 --- a/include/bloblist.h +++ b/include/bloblist.h @@ -147,6 +147,16 @@ struct bloblist_rec { u32 spare; }; +/* access CONFIG_BLOBLIST_ADDR, dealing with it possibly not being defined */ +static inline ulong bloblist_addr(void) +{ +#ifdef CONFIG_BLOBLIST_FIXED + return CONFIG_BLOBLIST_ADDR; +#else + return 0; +#endif +} + /** * bloblist_check_magic() - return a bloblist if the magic matches * From e50a24a0456c07d28c0d589e061dd0576f6bb917 Mon Sep 17 00:00:00 2001 From: Simon Glass Date: Wed, 12 Jan 2022 19:26:23 -0700 Subject: [PATCH 14/16] bloblist: Add functions to obtain base address and size Add a few convenience functions to obtain useful information about the bloblist. Signed-off-by: Simon Glass --- common/bloblist.c | 12 ++++++++++++ include/bloblist.h | 14 ++++++++++++++ test/bloblist.c | 2 ++ 3 files changed, 28 insertions(+) diff --git a/common/bloblist.c b/common/bloblist.c index 0049bb9a395..1ed9172d897 100644 --- a/common/bloblist.c +++ b/common/bloblist.c @@ -367,6 +367,18 @@ int bloblist_finish(void) return 0; } +ulong bloblist_get_base(void) +{ + return map_to_sysmem(gd->bloblist); +} + +ulong bloblist_get_size(void) +{ + struct bloblist_hdr *hdr = gd->bloblist; + + return hdr->size; +} + void bloblist_get_stats(ulong *basep, ulong *sizep, ulong *allocedp) { struct bloblist_hdr *hdr = gd->bloblist; diff --git a/include/bloblist.h b/include/bloblist.h index 13f2b3f1009..d9e108d8618 100644 --- a/include/bloblist.h +++ b/include/bloblist.h @@ -302,6 +302,20 @@ int bloblist_finish(void); */ void bloblist_get_stats(ulong *basep, ulong *sizep, ulong *allocedp); +/** + * bloblist_get_base() - Get the base address of the bloblist + * + * @returns base address of bloblist + */ +ulong bloblist_get_base(void); + +/** + * bloblist_get_size() - Get the size of the bloblist + * + * @returns the size in bytes + */ +ulong bloblist_get_size(void); + /** * bloblist_show_stats() - Show information about the bloblist * diff --git a/test/bloblist.c b/test/bloblist.c index c5788d5cd82..720be7e244f 100644 --- a/test/bloblist.c +++ b/test/bloblist.c @@ -107,6 +107,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(TEST_ADDR, bloblist_get_base()); ut_asserteq(map_to_sysmem(hdr), TEST_ADDR); /* Add a record and check that we can find it */ From 20a149353097967cfac3ec1a77eab08215427b0d Mon Sep 17 00:00:00 2001 From: Simon Glass Date: Wed, 12 Jan 2022 19:26:24 -0700 Subject: [PATCH 15/16] bloblist: doc: Bring in the API documentation FIx up various minor errors and add the API documentation to the bloblist docs, since it is quite useful to see it in the same place. Signed-off-by: Simon Glass --- doc/develop/bloblist.rst | 8 +++- include/bloblist.h | 79 +++++++++++++++++++++++----------------- 2 files changed, 52 insertions(+), 35 deletions(-) diff --git a/doc/develop/bloblist.rst b/doc/develop/bloblist.rst index 47274cf8e26..572aa65d764 100644 --- a/doc/develop/bloblist.rst +++ b/doc/develop/bloblist.rst @@ -31,7 +31,7 @@ Blobs While each blob in the bloblist can be of any length, bloblists are designed to hold small amounts of data, typically a few KB at most. It is not possible to change the length of a blob once it has been written. Each blob is normally -created from a C structure which can beused to access its fields. +created from a C structure which can be used to access its fields. Blob tags @@ -93,6 +93,12 @@ This should move to using bloblist, to avoid having its own mechanism for passing information between U-Boot parts. +API documentation +----------------- + +.. kernel-doc:: include/bloblist.h + + Simon Glass sjg@chromium.org 12-Aug-2018 diff --git a/include/bloblist.h b/include/bloblist.h index d9e108d8618..798babe9235 100644 --- a/include/bloblist.h +++ b/include/bloblist.h @@ -86,8 +86,8 @@ enum bloblist_tag_t { * 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, + * None of the bloblist headers themselves 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 bloblist inaccessible if the pointer is * no-longer valid. It is better to just store all the data inside a bloblist * record. @@ -99,7 +99,7 @@ enum bloblist_tag_t { * @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) + * @flags: Space for BLOBLISTF... flags (none yet) * @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. @@ -110,8 +110,8 @@ enum bloblist_tag_t { * @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. + * Note that chksum is last to make it easier to exclude it from the + * checksum calculation. */ struct bloblist_hdr { u32 magic; @@ -128,11 +128,11 @@ struct bloblist_hdr { /** * 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. * + * 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 @@ -161,7 +161,7 @@ static inline ulong bloblist_addr(void) * bloblist_check_magic() - return a bloblist if the magic matches * * @addr: Address to check - * @return pointer to bloblist, if the magic matches, else NULL + * Return: pointer to bloblist, if the magic matches, else NULL */ static inline void *bloblist_check_magic(ulong addr) { @@ -183,8 +183,8 @@ static inline void *bloblist_check_magic(ulong addr) * * @tag: Tag to search for (enum bloblist_tag_t) * @size: Expected size of the blob, or 0 for any size - * @return pointer to blob if found, or NULL if not found, or a blob was found - * but it is the wrong size + * 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); @@ -200,8 +200,8 @@ void *bloblist_find(uint tag, int size); * @tag: Tag to add (enum bloblist_tag_t) * @size: Size of the blob * @align: Alignment of the blob (in bytes), 0 for default - * @return pointer to the newly added block, or NULL if there is not enough - * space for 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, int align); @@ -214,8 +214,8 @@ void *bloblist_add(uint tag, int size, int align); * @size: Size of the blob * @blobp: Returns a pointer to blob on success * @align: Alignment of the blob (in bytes), 0 for default - * @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 + * 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, int align, void **blobp); @@ -226,8 +226,8 @@ int bloblist_ensure_size(uint tag, int size, int align, void **blobp); * * @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 + * 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); @@ -239,8 +239,8 @@ void *bloblist_ensure(uint tag, int size); * @tag: Tag to add (enum bloblist_tag_t) * @sizep: Size of the blob to create; returns size of actual 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 + * Return: 0 if OK, -ENOSPC if it is missing and could not be added due to lack + * of space */ int bloblist_ensure_size_ret(uint tag, int *sizep, void **blobp); @@ -252,8 +252,8 @@ int bloblist_ensure_size_ret(uint tag, int *sizep, void **blobp); * * @tag: Tag to add (enum bloblist_tag_t) * @new_size: New size of the blob (>0 to expand, <0 to contract) - * @return 0 if OK, -ENOSPC if the bloblist does not have enough space, -ENOENT - * if the tag is not found + * Return: 0 if OK, -ENOSPC if the bloblist does not have enough space, -ENOENT + * if the tag is not found */ int bloblist_resize(uint tag, int new_size); @@ -263,8 +263,8 @@ int bloblist_resize(uint tag, int new_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 + * 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); @@ -273,11 +273,11 @@ int bloblist_new(ulong addr, uint size, uint flags); * * @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, -ENOSPC - * if the size is not large enough to hold the headers + * 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, -ENOSPC + * if the size is not large enough to hold the headers */ int bloblist_check(ulong addr, uint size); @@ -287,7 +287,7 @@ int bloblist_check(ulong addr, uint size); * 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 + * Return: 0 */ int bloblist_finish(void); @@ -305,14 +305,14 @@ void bloblist_get_stats(ulong *basep, ulong *sizep, ulong *allocedp); /** * bloblist_get_base() - Get the base address of the bloblist * - * @returns base address of bloblist + * Return: base address of bloblist */ ulong bloblist_get_base(void); /** * bloblist_get_size() - Get the size of the bloblist * - * @returns the size in bytes + * Return: the size in bytes */ ulong bloblist_get_size(void); @@ -334,7 +334,7 @@ void bloblist_show_list(void); * bloblist_tag_name() - Get the name for a tag * * @tag: Tag to check - * @return name of tag, or "invalid" if an invalid tag is provided + * Return: name of tag, or "invalid" if an invalid tag is provided */ const char *bloblist_tag_name(enum bloblist_tag_t tag); @@ -342,7 +342,7 @@ const char *bloblist_tag_name(enum bloblist_tag_t tag); * bloblist_reloc() - Relocate the bloblist and optionally resize it * * @to: Pointer to new bloblist location (must not overlap old location) - * @to:size: New size for bloblist (must be larger than from_size) + * @to_size: New size for bloblist (must be larger than from_size) * @from: Pointer to bloblist to relocate * @from_size: Size of bloblist to relocate */ @@ -351,8 +351,19 @@ void bloblist_reloc(void *to, uint to_size, void *from, uint from_size); /** * bloblist_init() - Init the bloblist system with a single bloblist * - * This uses CONFIG_BLOBLIST_ADDR and CONFIG_BLOBLIST_SIZE to set up a bloblist - * for use by U-Boot. + * This locates and sets up the blocklist for use. + * + * If CONFIG_BLOBLIST_FIXED is selected, it uses CONFIG_BLOBLIST_ADDR and + * CONFIG_BLOBLIST_SIZE to set up a bloblist for use by U-Boot. + * + * If CONFIG_BLOBLIST_ALLOC is selected, it allocates memory for a bloblist of + * size CONFIG_BLOBLIST_SIZE. + * + * If CONFIG_BLOBLIST_PASSAGE is selected, it uses the bloblist in the incoming + * standard passage. The size is detected automatically so CONFIG_BLOBLIST_SIZE + * can be 0. + * + * Return: 0 if OK, -ve on error */ int bloblist_init(void); From 6c9e3d1fc085977b5b38dfe610f65d1a7f48081b Mon Sep 17 00:00:00 2001 From: Simon Glass Date: Wed, 12 Jan 2022 19:26:25 -0700 Subject: [PATCH 16/16] bloblist: Relicense to allow BSD-3-Clause This implementation is intended to be copied to other projects and modified, to as to foster a standard means of communcating runtime information between firmware projects. The GPL-2 license is too restrictive for some projects, e.g. those intended as reference implementations rather than designed for collaborative open-source development. Update the license to make this easier to share. Signed-off-by: Simon Glass --- common/bloblist.c | 2 +- include/bloblist.h | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/common/bloblist.c b/common/bloblist.c index 1ed9172d897..056b50c2cb6 100644 --- a/common/bloblist.c +++ b/common/bloblist.c @@ -1,4 +1,4 @@ -// SPDX-License-Identifier: GPL-2.0+ +// SPDX-License-Identifier: GPL-2.0+ BSD-3-Clause /* * Copyright 2018 Google, Inc * Written by Simon Glass diff --git a/include/bloblist.h b/include/bloblist.h index 798babe9235..173129b0273 100644 --- a/include/bloblist.h +++ b/include/bloblist.h @@ -1,4 +1,4 @@ -/* SPDX-License-Identifier: GPL-2.0+ */ +/* SPDX-License-Identifier: GPL-2.0+ BSD-3-Clause */ /* * This provides a standard way of passing information between boot phases * (TPL -> SPL -> U-Boot proper.)