Add support for VBE simple, which permits firmware update of a single image stored in MMC or another block device.
Signed-off-by: Simon Glass sjg@chromium.org ---
boot/Kconfig | 12 ++ boot/Makefile | 1 + boot/vbe_simple.c | 304 +++++++++++++++++++++++++++++++ test/py/tests/test_event_dump.py | 2 +- 4 files changed, 318 insertions(+), 1 deletion(-) create mode 100644 boot/vbe_simple.c
diff --git a/boot/Kconfig b/boot/Kconfig index 2bda221a68e..4a42b1b410a 100644 --- a/boot/Kconfig +++ b/boot/Kconfig @@ -394,6 +394,18 @@ config BOOTMETH_VBE supports selection of various firmware components, seleciton of an OS to boot as well as updating these using fwupd.
+if BOOTMETH_VBE + +config BOOTMETH_VBE_SIMPLE + bool "Bootdev support for VBE 'simple' method" + default y + help + Enables support for VBE 'simple' boot. This allows updating a single + firmware image in boot media such as MMC. It does not support any sort + of rollback, recovery or A/B boot. + +endif # BOOTMETH_VBE + config BOOTMETH_SANDBOX def_bool y depends on SANDBOX diff --git a/boot/Makefile b/boot/Makefile index dd74bf5bc93..eef3ae223c0 100644 --- a/boot/Makefile +++ b/boot/Makefile @@ -49,3 +49,4 @@ obj-$(CONFIG_SPL_LOAD_FIT) += common_fit.o endif
obj-$(CONFIG_$(SPL_TPL_)BOOTMETH_VBE) += vbe.o +obj-$(CONFIG_$(SPL_TPL_)BOOTMETH_VBE_SIMPLE) += vbe_simple.o diff --git a/boot/vbe_simple.c b/boot/vbe_simple.c new file mode 100644 index 00000000000..7ba8778f2b2 --- /dev/null +++ b/boot/vbe_simple.c @@ -0,0 +1,304 @@ +// SPDX-License-Identifier: GPL-2.0+ +/* + * Verified Boot for Embedded (VBE) 'simple' method + * + * Copyright 2022 Google LLC + * Written by Simon Glass sjg@chromium.org + */ + +#include <common.h> +#include <log.h> +#include <memalign.h> +#include <part.h> +#include <bootmeth.h> +#include <dm.h> +#include <mmc.h> +#include <vbe.h> +#include <version_string.h> +#include <dm/device-internal.h> +#include <dm/ofnode.h> +#include <u-boot/crc.h> + +enum { + MAX_VERSION_LEN = 256, + + NVD_HDR_VER_SHIFT = 0, + NVD_HDR_VER_MASK = 0xf, + NVD_HDR_SIZE_SHIFT = 4, + NVD_HDR_SIZE_MASK = 0xf << NVD_HDR_SIZE_SHIFT, + + /* Firmware key-version is in the top 16 bits of fw_ver */ + FWVER_KEY_SHIFT = 16, + FWVER_FW_MASK = 0xffff, + + NVD_HDR_VER_CUR = 1, /* current version */ +}; + +/** struct simple_priv - information read from the device tree */ +struct simple_priv { + u32 area_start; + u32 area_size; + u32 skip_offset; + u32 state_offset; + u32 state_size; + u32 version_offset; + u32 version_size; + const char *storage; +}; + +/** struct simple_state - state information read from media + * + * @fw_version: Firmware version string + * @fw_vernum: Firmware version number + */ +struct simple_state { + char fw_version[MAX_VERSION_LEN]; + u32 fw_vernum; +}; + +/** struct simple_nvdata - storage format for non-volatile data */ +struct simple_nvdata { + u8 crc8; + u8 hdr; + u16 spare1; + u32 fw_vernum; + u8 spare2[0x38]; +}; + +static int simple_read_version(struct udevice *dev, struct blk_desc *desc, + u8 *buf, struct simple_state *state) +{ + struct simple_priv *priv = dev_get_priv(dev); + int start; + + if (priv->version_size > MMC_MAX_BLOCK_LEN) + return log_msg_ret("ver", -E2BIG); + + start = priv->area_start + priv->version_offset; + if (start & (MMC_MAX_BLOCK_LEN - 1)) + return log_msg_ret("get", -EBADF); + start /= MMC_MAX_BLOCK_LEN; + + if (blk_dread(desc, start, 1, buf) != 1) + return log_msg_ret("read", -EIO); + strlcpy(state->fw_version, buf, MAX_VERSION_LEN); + log_debug("version=%s\n", state->fw_version); + + return 0; +} + +static int simple_read_nvdata(struct udevice *dev, struct blk_desc *desc, + u8 *buf, struct simple_state *state) +{ + struct simple_priv *priv = dev_get_priv(dev); + uint hdr_ver, hdr_size, size, crc; + const struct simple_nvdata *nvd; + int start; + + if (priv->state_size > MMC_MAX_BLOCK_LEN) + return log_msg_ret("state", -E2BIG); + + start = priv->area_start + priv->state_offset; + if (start & (MMC_MAX_BLOCK_LEN - 1)) + return log_msg_ret("get", -EBADF); + start /= MMC_MAX_BLOCK_LEN; + + if (blk_dread(desc, start, 1, buf) != 1) + return log_msg_ret("read", -EIO); + nvd = (struct simple_nvdata *)buf; + hdr_ver = (nvd->hdr & NVD_HDR_VER_MASK) >> NVD_HDR_VER_SHIFT; + hdr_size = (nvd->hdr & NVD_HDR_SIZE_MASK) >> NVD_HDR_SIZE_SHIFT; + if (hdr_ver != NVD_HDR_VER_CUR) + return log_msg_ret("hdr", -EPERM); + size = 1 << hdr_size; + if (size > sizeof(*nvd)) + return log_msg_ret("sz", -ENOEXEC); + + crc = crc8(0, buf + 1, size - 1); + if (crc != nvd->crc8) + return log_msg_ret("crc", -EPERM); + state->fw_vernum = nvd->fw_vernum; + + log_debug("version=%s\n", state->fw_version); + + return 0; +} + +static int simple_read_state(struct udevice *dev, struct simple_state *state) +{ + ALLOC_CACHE_ALIGN_BUFFER(u8, buf, MMC_MAX_BLOCK_LEN); + struct simple_priv *priv = dev_get_priv(dev); + struct blk_desc *desc; + char devname[16]; + const char *end; + int devnum; + int ret; + + /* First figure out the block device */ + log_debug("storage=%s\n", priv->storage); + devnum = trailing_strtoln_end(priv->storage, NULL, &end); + if (devnum == -1) + return log_msg_ret("num", -ENODEV); + if (end - priv->storage >= sizeof(devname)) + return log_msg_ret("end", -E2BIG); + strlcpy(devname, priv->storage, end - priv->storage + 1); + log_debug("dev=%s, %x\n", devname, devnum); + + desc = blk_get_dev(devname, devnum); + if (!desc) + return log_msg_ret("get", -ENXIO); + + ret = simple_read_version(dev, desc, buf, state); + if (ret) + return log_msg_ret("ver", ret); + + ret = simple_read_nvdata(dev, desc, buf, state); + if (ret) + return log_msg_ret("nvd", ret); + + return 0; +} + +static int simple_get_state_desc(struct udevice *dev, char *buf, int maxsize) +{ + struct simple_state state; + int ret; + + ret = simple_read_state(dev, &state); + if (ret) + return log_msg_ret("read", ret); + + if (maxsize < 30) + return -ENOSPC; + snprintf(buf, maxsize, "Version: %s\nVernum: %x/%x", state.fw_version, + state.fw_vernum >> FWVER_KEY_SHIFT, + state.fw_vernum & FWVER_FW_MASK); + + return 0; +} + +static struct bootmeth_ops bootmeth_vbe_simple_ops = { + .get_state_desc = simple_get_state_desc, + .read_file = bootmeth_common_read_file, +}; + +int vbe_simple_fixup_node(ofnode node, struct simple_state *state) +{ + char *version; + int ret; + + version = strdup(state->fw_version); + if (!version) + return log_msg_ret("ver", -ENOMEM); + + ret = ofnode_write_string(node, "cur-version", version); + if (ret) + return log_msg_ret("ver", ret); + ret = ofnode_write_u32(node, "cur-vernum", state->fw_vernum); + if (ret) + return log_msg_ret("ver", ret); + ret = ofnode_write_string(node, "bootloader-version", version_string); + if (ret) + return log_msg_ret("fix", ret); + + return 0; +} + +/** + * bootmeth_vbe_simple_ft_fixup() - Write out all VBE simple data to the DT + * + * @ctx: Context for event + * @event: Event to process + * @return 0 if OK, -ve on error + */ +static int bootmeth_vbe_simple_ft_fixup(void *ctx, struct event *event) +{ + oftree tree = event->data.ft_fixup.tree; + struct udevice *dev; + ofnode node; + int ret; + + /* + * Ideally we would have driver model support for fixups, but that does + * not exist yet. It is a step too far to try to do this before VBE is + * in place. + */ + for (ret = vbe_find_first_device(&dev); dev; + ret = vbe_find_next_device(&dev)) { + struct simple_state state; + + if (strcmp("vbe_simple", dev->driver->name)) + continue; + + /* Check if there is a node to fix up */ + node = ofnode_path_root(tree, "/chosen/fwupd"); + if (!ofnode_valid(node)) + continue; + node = ofnode_find_subnode(node, dev->name); + if (!ofnode_valid(node)) + continue; + + log_debug("Fixing up: %s\n", dev->name); + ret = device_probe(dev); + if (ret) + return log_msg_ret("probe", ret); + ret = simple_read_state(dev, &state); + if (ret) + return log_msg_ret("read", ret); + + ret = vbe_simple_fixup_node(node, &state); + if (ret) + return log_msg_ret("fix", ret); + } + + return 0; +} +EVENT_SPY(EVT_FT_FIXUP, bootmeth_vbe_simple_ft_fixup); + +static int bootmeth_vbe_simple_probe(struct udevice *dev) +{ + struct simple_priv *priv = dev_get_priv(dev); + + memset(priv, '\0', sizeof(*priv)); + if (dev_read_u32(dev, "area-start", &priv->area_start) || + dev_read_u32(dev, "area-size", &priv->area_size) || + dev_read_u32(dev, "version-offset", &priv->version_offset) || + dev_read_u32(dev, "version-size", &priv->version_size) || + dev_read_u32(dev, "state-offset", &priv->state_offset) || + dev_read_u32(dev, "state-size", &priv->state_size)) + return log_msg_ret("read", -EINVAL); + dev_read_u32(dev, "skip-offset", &priv->skip_offset); + priv->storage = strdup(dev_read_string(dev, "storage")); + if (!priv->storage) + return log_msg_ret("str", -EINVAL); + + return 0; +} + +static int bootmeth_vbe_simple_bind(struct udevice *dev) +{ + struct bootmeth_uc_plat *plat = dev_get_uclass_plat(dev); + + plat->desc = IS_ENABLED(CONFIG_BOOTSTD_FULL) ? + "VBE simple" : "vbe-simple"; + + return 0; +} + +#if CONFIG_IS_ENABLED(OF_REAL) +static const struct udevice_id generic_simple_vbe_simple_ids[] = { + { .compatible = "fwupd,vbe-simple" }, + { } +}; +#endif + +U_BOOT_DRIVER(vbe_simple) = { + .name = "vbe_simple", + .id = UCLASS_BOOTMETH, + .of_match = of_match_ptr(generic_simple_vbe_simple_ids), + .ops = &bootmeth_vbe_simple_ops, + .bind = bootmeth_vbe_simple_bind, + .probe = bootmeth_vbe_simple_probe, + .flags = DM_FLAG_PRE_RELOC, + .priv_auto = sizeof(struct simple_priv), +}; diff --git a/test/py/tests/test_event_dump.py b/test/py/tests/test_event_dump.py index 17001777247..bc54149e8f2 100644 --- a/test/py/tests/test_event_dump.py +++ b/test/py/tests/test_event_dump.py @@ -16,6 +16,6 @@ def test_event_dump(u_boot_console): out = util.run_and_log(cons, ['scripts/event_dump.py', sandbox]) expect = '''.*Event type Id Source location -------------------- ------------------------------ ------------------------------ -EVT_FT_FIXUP bootmeth_vbe_simple_ft_fixup boot/vbe_simple.c:.* +EVT_FT_FIXUP bootmeth_vbe_simple_ft_fixup .*boot/vbe_simple.c:.* EVT_MISC_INIT_F sandbox_misc_init_f .*arch/sandbox/cpu/start.c:''' assert re.match(expect, out, re.MULTILINE) is not None