1 // SPDX-License-Identifier: GPL-2.0+
3 * Verified Boot for Embedded (VBE) 'simple' method
5 * Copyright 2022 Google LLC
6 * Written by Simon Glass <sjg@chromium.org>
9 #define LOG_CATEGORY LOGC_BOOT
20 #include <version_string.h>
21 #include <dm/device-internal.h>
22 #include <dm/ofnode.h>
23 #include <u-boot/crc.h>
26 MAX_VERSION_LEN = 256,
28 NVD_HDR_VER_SHIFT = 0,
29 NVD_HDR_VER_MASK = 0xf,
30 NVD_HDR_SIZE_SHIFT = 4,
31 NVD_HDR_SIZE_MASK = 0xf << NVD_HDR_SIZE_SHIFT,
33 /* Firmware key-version is in the top 16 bits of fw_ver */
35 FWVER_FW_MASK = 0xffff,
37 NVD_HDR_VER_CUR = 1, /* current version */
40 /** struct simple_priv - information read from the device tree */
52 /** struct simple_state - state information read from media
54 * @fw_version: Firmware version string
55 * @fw_vernum: Firmware version number
58 char fw_version[MAX_VERSION_LEN];
62 /** struct simple_nvdata - storage format for non-volatile data */
63 struct simple_nvdata {
71 static int simple_read_version(struct udevice *dev, struct blk_desc *desc,
72 u8 *buf, struct simple_state *state)
74 struct simple_priv *priv = dev_get_priv(dev);
77 if (priv->version_size > MMC_MAX_BLOCK_LEN)
78 return log_msg_ret("ver", -E2BIG);
80 start = priv->area_start + priv->version_offset;
81 if (start & (MMC_MAX_BLOCK_LEN - 1))
82 return log_msg_ret("get", -EBADF);
83 start /= MMC_MAX_BLOCK_LEN;
85 if (blk_dread(desc, start, 1, buf) != 1)
86 return log_msg_ret("read", -EIO);
87 strlcpy(state->fw_version, buf, MAX_VERSION_LEN);
88 log_debug("version=%s\n", state->fw_version);
93 static int simple_read_nvdata(struct udevice *dev, struct blk_desc *desc,
94 u8 *buf, struct simple_state *state)
96 struct simple_priv *priv = dev_get_priv(dev);
97 uint hdr_ver, hdr_size, size, crc;
98 const struct simple_nvdata *nvd;
101 if (priv->state_size > MMC_MAX_BLOCK_LEN)
102 return log_msg_ret("state", -E2BIG);
104 start = priv->area_start + priv->state_offset;
105 if (start & (MMC_MAX_BLOCK_LEN - 1))
106 return log_msg_ret("get", -EBADF);
107 start /= MMC_MAX_BLOCK_LEN;
109 if (blk_dread(desc, start, 1, buf) != 1)
110 return log_msg_ret("read", -EIO);
111 nvd = (struct simple_nvdata *)buf;
112 hdr_ver = (nvd->hdr & NVD_HDR_VER_MASK) >> NVD_HDR_VER_SHIFT;
113 hdr_size = (nvd->hdr & NVD_HDR_SIZE_MASK) >> NVD_HDR_SIZE_SHIFT;
114 if (hdr_ver != NVD_HDR_VER_CUR)
115 return log_msg_ret("hdr", -EPERM);
116 size = 1 << hdr_size;
117 if (size > sizeof(*nvd))
118 return log_msg_ret("sz", -ENOEXEC);
120 crc = crc8(0, buf + 1, size - 1);
121 if (crc != nvd->crc8)
122 return log_msg_ret("crc", -EPERM);
123 state->fw_vernum = nvd->fw_vernum;
125 log_debug("version=%s\n", state->fw_version);
130 static int simple_read_state(struct udevice *dev, struct simple_state *state)
132 ALLOC_CACHE_ALIGN_BUFFER(u8, buf, MMC_MAX_BLOCK_LEN);
133 struct simple_priv *priv = dev_get_priv(dev);
134 struct blk_desc *desc;
140 /* First figure out the block device */
141 log_debug("storage=%s\n", priv->storage);
142 devnum = trailing_strtoln_end(priv->storage, NULL, &end);
144 return log_msg_ret("num", -ENODEV);
145 if (end - priv->storage >= sizeof(devname))
146 return log_msg_ret("end", -E2BIG);
147 strlcpy(devname, priv->storage, end - priv->storage + 1);
148 log_debug("dev=%s, %x\n", devname, devnum);
150 desc = blk_get_dev(devname, devnum);
152 return log_msg_ret("get", -ENXIO);
154 ret = simple_read_version(dev, desc, buf, state);
156 return log_msg_ret("ver", ret);
158 ret = simple_read_nvdata(dev, desc, buf, state);
160 return log_msg_ret("nvd", ret);
165 static int vbe_simple_get_state_desc(struct udevice *dev, char *buf,
168 struct simple_state state;
171 ret = simple_read_state(dev, &state);
173 return log_msg_ret("read", ret);
177 snprintf(buf, maxsize, "Version: %s\nVernum: %x/%x", state.fw_version,
178 state.fw_vernum >> FWVER_KEY_SHIFT,
179 state.fw_vernum & FWVER_FW_MASK);
184 static int vbe_simple_read_bootflow(struct udevice *dev, struct bootflow *bflow)
186 /* To be implemented */
191 static struct bootmeth_ops bootmeth_vbe_simple_ops = {
192 .get_state_desc = vbe_simple_get_state_desc,
193 .read_bootflow = vbe_simple_read_bootflow,
194 .read_file = bootmeth_common_read_file,
197 int vbe_simple_fixup_node(ofnode node, struct simple_state *state)
202 version = strdup(state->fw_version);
204 return log_msg_ret("dup", -ENOMEM);
206 ret = ofnode_write_string(node, "cur-version", version);
208 return log_msg_ret("ver", ret);
209 ret = ofnode_write_u32(node, "cur-vernum", state->fw_vernum);
211 return log_msg_ret("num", ret);
212 ret = ofnode_write_string(node, "bootloader-version", version_string);
214 return log_msg_ret("bl", ret);
220 * bootmeth_vbe_simple_ft_fixup() - Write out all VBE simple data to the DT
222 * @ctx: Context for event
223 * @event: Event to process
224 * @return 0 if OK, -ve on error
226 static int bootmeth_vbe_simple_ft_fixup(void *ctx, struct event *event)
228 oftree tree = event->data.ft_fixup.tree;
232 * Ideally we would have driver model support for fixups, but that does
233 * not exist yet. It is a step too far to try to do this before VBE is
236 for (vbe_find_first_device(&dev); dev; vbe_find_next_device(&dev)) {
237 struct simple_state state;
238 ofnode node, subnode;
241 if (strcmp("vbe_simple", dev->driver->name))
244 /* Check if there is a node to fix up */
245 node = oftree_path(tree, "/chosen/fwupd");
246 if (!ofnode_valid(node))
248 subnode = ofnode_find_subnode(node, dev->name);
249 if (!ofnode_valid(subnode))
252 log_debug("Fixing up: %s\n", dev->name);
253 ret = device_probe(dev);
255 return log_msg_ret("probe", ret);
256 ret = simple_read_state(dev, &state);
258 return log_msg_ret("read", ret);
260 ret = vbe_simple_fixup_node(subnode, &state);
262 return log_msg_ret("fix", ret);
267 EVENT_SPY(EVT_FT_FIXUP, bootmeth_vbe_simple_ft_fixup);
269 static int bootmeth_vbe_simple_probe(struct udevice *dev)
271 struct simple_priv *priv = dev_get_priv(dev);
273 memset(priv, '\0', sizeof(*priv));
274 if (dev_read_u32(dev, "area-start", &priv->area_start) ||
275 dev_read_u32(dev, "area-size", &priv->area_size) ||
276 dev_read_u32(dev, "version-offset", &priv->version_offset) ||
277 dev_read_u32(dev, "version-size", &priv->version_size) ||
278 dev_read_u32(dev, "state-offset", &priv->state_offset) ||
279 dev_read_u32(dev, "state-size", &priv->state_size))
280 return log_msg_ret("read", -EINVAL);
281 dev_read_u32(dev, "skip-offset", &priv->skip_offset);
282 priv->storage = strdup(dev_read_string(dev, "storage"));
284 return log_msg_ret("str", -EINVAL);
289 static int bootmeth_vbe_simple_bind(struct udevice *dev)
291 struct bootmeth_uc_plat *plat = dev_get_uclass_plat(dev);
293 plat->desc = IS_ENABLED(CONFIG_BOOTSTD_FULL) ?
294 "VBE simple" : "vbe-simple";
295 plat->flags = BOOTMETHF_GLOBAL;
300 #if CONFIG_IS_ENABLED(OF_REAL)
301 static const struct udevice_id generic_simple_vbe_simple_ids[] = {
302 { .compatible = "fwupd,vbe-simple" },
307 U_BOOT_DRIVER(vbe_simple) = {
308 .name = "vbe_simple",
309 .id = UCLASS_BOOTMETH,
310 .of_match = of_match_ptr(generic_simple_vbe_simple_ids),
311 .ops = &bootmeth_vbe_simple_ops,
312 .bind = bootmeth_vbe_simple_bind,
313 .probe = bootmeth_vbe_simple_probe,
314 .flags = DM_FLAG_PRE_RELOC,
315 .priv_auto = sizeof(struct simple_priv),