[J-u-boot.git] / boot / vbe_simple.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * Verified Boot for Embedded (VBE) 'simple' method
 *
 * Copyright 2022 Google LLC
 * Written by Simon Glass <[email protected]>
 */

#define LOG_CATEGORY LOGC_BOOT

#include <common.h>
#include <bootdev.h>
#include <bootflow.h>
#include <bootmeth.h>
#include <dm.h>
#include <log.h>
#include <memalign.h>
#include <mmc.h>
#include <vbe.h>
#include <dm/device-internal.h>
#include <dm/ofnode.h>
#include <u-boot/crc.h>
#include "vbe_simple.h"

/** 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;
}

int vbe_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 vbe_simple_get_state_desc(struct udevice *dev, char *buf,
				     int maxsize)
{
	struct simple_state state;
	int ret;

	ret = vbe_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 int vbe_simple_read_bootflow(struct udevice *dev, struct bootflow *bflow)
{
	int ret;

	if (CONFIG_IS_ENABLED(BOOTMETH_VBE_SIMPLE_FW)) {
		if (vbe_phase() == VBE_PHASE_FIRMWARE) {
			ret = vbe_simple_read_bootflow_fw(dev, bflow);
			if (ret)
				return log_msg_ret("fw", ret);
			return 0;
		}
	}

	return -EINVAL;
}

static int vbe_simple_read_file(struct udevice *dev, struct bootflow *bflow,
				const char *file_path, ulong addr, ulong *sizep)
{
	int ret;

	if (vbe_phase() == VBE_PHASE_OS) {
		ret = bootmeth_common_read_file(dev, bflow, file_path, addr,
						sizep);
		if (ret)
			return log_msg_ret("os", ret);
	}

	/* To be implemented */
	return -EINVAL;
}

static struct bootmeth_ops bootmeth_vbe_simple_ops = {
	.get_state_desc	= vbe_simple_get_state_desc,
	.read_bootflow	= vbe_simple_read_bootflow,
	.read_file	= vbe_simple_read_file,
};

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";
	plat->flags = BOOTMETHF_GLOBAL;

	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),
};
Commit	Line	Data
cb47e21a SG	1	// SPDX-License-Identifier: GPL-2.0+
	2	/*
	3	* Verified Boot for Embedded (VBE) 'simple' method
	4	*
	5	* Copyright 2022 Google LLC
	6	* Written by Simon Glass <[email protected]>
	7	*/
	8
87c97cb1 SG	9	#define LOG_CATEGORY LOGC_BOOT
87c97cb1 SG	10
cb47e21a	11	#include <common.h>
d2b22ae2	12	#include <bootdev.h>
cb47e21a SG	13	#include <bootflow.h>
	14	#include <bootmeth.h>
	15	#include <dm.h>
d2b22ae2 SG	16	#include <log.h>
d2b22ae2 SG	17	#include <memalign.h>
cb47e21a SG	18	#include <mmc.h>
cb47e21a SG	19	#include <vbe.h>
cb47e21a SG	20	#include <dm/device-internal.h>
	21	#include <dm/ofnode.h>
	22	#include <u-boot/crc.h>
d2b22ae2	23	#include "vbe_simple.h"
cb47e21a	24
cb47e21a SG	25	/** struct simple_nvdata - storage format for non-volatile data */
	26	struct simple_nvdata {
	27	u8 crc8;
	28	u8 hdr;
	29	u16 spare1;
	30	u32 fw_vernum;
	31	u8 spare2[0x38];
	32	};
	33
	34	static int simple_read_version(struct udevice dev, struct blk_desc desc,
	35	u8 buf, struct simple_state state)
	36	{
	37	struct simple_priv *priv = dev_get_priv(dev);
	38	int start;
	39
	40	if (priv->version_size > MMC_MAX_BLOCK_LEN)
	41	return log_msg_ret("ver", -E2BIG);
	42
	43	start = priv->area_start + priv->version_offset;
	44	if (start & (MMC_MAX_BLOCK_LEN - 1))
	45	return log_msg_ret("get", -EBADF);
	46	start /= MMC_MAX_BLOCK_LEN;
	47
	48	if (blk_dread(desc, start, 1, buf) != 1)
	49	return log_msg_ret("read", -EIO);
	50	strlcpy(state->fw_version, buf, MAX_VERSION_LEN);
	51	log_debug("version=%s\n", state->fw_version);
	52
	53	return 0;
	54	}
	55
	56	static int simple_read_nvdata(struct udevice dev, struct blk_desc desc,
	57	u8 buf, struct simple_state state)
	58	{
	59	struct simple_priv *priv = dev_get_priv(dev);
	60	uint hdr_ver, hdr_size, size, crc;
	61	const struct simple_nvdata *nvd;
	62	int start;
	63
	64	if (priv->state_size > MMC_MAX_BLOCK_LEN)
	65	return log_msg_ret("state", -E2BIG);
	66
	67	start = priv->area_start + priv->state_offset;
	68	if (start & (MMC_MAX_BLOCK_LEN - 1))
	69	return log_msg_ret("get", -EBADF);
	70	start /= MMC_MAX_BLOCK_LEN;
	71
	72	if (blk_dread(desc, start, 1, buf) != 1)
	73	return log_msg_ret("read", -EIO);
	74	nvd = (struct simple_nvdata *)buf;
	75	hdr_ver = (nvd->hdr & NVD_HDR_VER_MASK) >> NVD_HDR_VER_SHIFT;
	76	hdr_size = (nvd->hdr & NVD_HDR_SIZE_MASK) >> NVD_HDR_SIZE_SHIFT;
	77	if (hdr_ver != NVD_HDR_VER_CUR)
	78	return log_msg_ret("hdr", -EPERM);
	79	size = 1 << hdr_size;
	80	if (size > sizeof(*nvd))
	81	return log_msg_ret("sz", -ENOEXEC);
	82
	83	crc = crc8(0, buf + 1, size - 1);
	84	if (crc != nvd->crc8)
	85	return log_msg_ret("crc", -EPERM);
	86	state->fw_vernum = nvd->fw_vernum;
	87
	88	log_debug("version=%s\n", state->fw_version);
89
90	return 0;
91	}
92
c263e21b	93	int vbe_simple_read_state(struct udevice dev, struct simple_state state)
cb47e21a SG	94	{
	95	ALLOC_CACHE_ALIGN_BUFFER(u8, buf, MMC_MAX_BLOCK_LEN);
	96	struct simple_priv *priv = dev_get_priv(dev);
	97	struct blk_desc *desc;
	98	char devname[16];
	99	const char *end;
	100	int devnum;
	101	int ret;
	102
	103	/* First figure out the block device */
	104	log_debug("storage=%s\n", priv->storage);
	105	devnum = trailing_strtoln_end(priv->storage, NULL, &end);
	106	if (devnum == -1)
	107	return log_msg_ret("num", -ENODEV);
	108	if (end - priv->storage >= sizeof(devname))
	109	return log_msg_ret("end", -E2BIG);
	110	strlcpy(devname, priv->storage, end - priv->storage + 1);
	111	log_debug("dev=%s, %x\n", devname, devnum);
	112
	113	desc = blk_get_dev(devname, devnum);
	114	if (!desc)
	115	return log_msg_ret("get", -ENXIO);
	116
	117	ret = simple_read_version(dev, desc, buf, state);
	118	if (ret)
	119	return log_msg_ret("ver", ret);
	120
	121	ret = simple_read_nvdata(dev, desc, buf, state);
	122	if (ret)
	123	return log_msg_ret("nvd", ret);
	124
	125	return 0;
	126	}
	127
	128	static int vbe_simple_get_state_desc(struct udevice dev, char buf,
	129	int maxsize)
	130	{
	131	struct simple_state state;
	132	int ret;
	133
c263e21b	134	ret = vbe_simple_read_state(dev, &state);
cb47e21a SG	135	if (ret)
	136	return log_msg_ret("read", ret);
	137
	138	if (maxsize < 30)
	139	return -ENOSPC;
	140	snprintf(buf, maxsize, "Version: %s\nVernum: %x/%x", state.fw_version,
	141	state.fw_vernum >> FWVER_KEY_SHIFT,
	142	state.fw_vernum & FWVER_FW_MASK);
	143
	144	return 0;
	145	}
	146
	147	static int vbe_simple_read_bootflow(struct udevice dev, struct bootflow bflow)
	148	{
d2b22ae2 SG	149	int ret;
d2b22ae2 SG	150
327883c3 BM	151	if (CONFIG_IS_ENABLED(BOOTMETH_VBE_SIMPLE_FW)) {
	152	if (vbe_phase() == VBE_PHASE_FIRMWARE) {
	153	ret = vbe_simple_read_bootflow_fw(dev, bflow);
	154	if (ret)
	155	return log_msg_ret("fw", ret);
	156	return 0;
	157	}
d2b22ae2	158	}
cb47e21a SG	159
	160	return -EINVAL;
	161	}
	162
d2b22ae2 SG	163	static int vbe_simple_read_file(struct udevice dev, struct bootflow bflow,
	164	const char file_path, ulong addr, ulong sizep)
	165	{
	166	int ret;
	167
	168	if (vbe_phase() == VBE_PHASE_OS) {
	169	ret = bootmeth_common_read_file(dev, bflow, file_path, addr,
	170	sizep);
	171	if (ret)
	172	return log_msg_ret("os", ret);
	173	}
	174
	175	/* To be implemented */
	176	return -EINVAL;
	177	}
	178
cb47e21a SG	179	static struct bootmeth_ops bootmeth_vbe_simple_ops = {
	180	.get_state_desc = vbe_simple_get_state_desc,
	181	.read_bootflow = vbe_simple_read_bootflow,
d2b22ae2	182	.read_file = vbe_simple_read_file,
cb47e21a SG	183	};
cb47e21a SG	184
cb47e21a SG	185	static int bootmeth_vbe_simple_probe(struct udevice *dev)
	186	{
	187	struct simple_priv *priv = dev_get_priv(dev);
	188
	189	memset(priv, '\0', sizeof(*priv));
	190	if (dev_read_u32(dev, "area-start", &priv->area_start) \|\|
	191	dev_read_u32(dev, "area-size", &priv->area_size) \|\|
	192	dev_read_u32(dev, "version-offset", &priv->version_offset) \|\|
	193	dev_read_u32(dev, "version-size", &priv->version_size) \|\|
	194	dev_read_u32(dev, "state-offset", &priv->state_offset) \|\|
	195	dev_read_u32(dev, "state-size", &priv->state_size))
	196	return log_msg_ret("read", -EINVAL);
	197	dev_read_u32(dev, "skip-offset", &priv->skip_offset);
	198	priv->storage = strdup(dev_read_string(dev, "storage"));
	199	if (!priv->storage)
	200	return log_msg_ret("str", -EINVAL);
	201
	202	return 0;
	203	}
	204
	205	static int bootmeth_vbe_simple_bind(struct udevice *dev)
	206	{
	207	struct bootmeth_uc_plat *plat = dev_get_uclass_plat(dev);
	208
	209	plat->desc = IS_ENABLED(CONFIG_BOOTSTD_FULL) ?
	210	"VBE simple" : "vbe-simple";
	211	plat->flags = BOOTMETHF_GLOBAL;
	212
	213	return 0;
	214	}
	215
	216	#if CONFIG_IS_ENABLED(OF_REAL)
	217	static const struct udevice_id generic_simple_vbe_simple_ids[] = {
	218	{ .compatible = "fwupd,vbe-simple" },
	219	{ }
	220	};
	221	#endif
	222
	223	U_BOOT_DRIVER(vbe_simple) = {
	224	.name = "vbe_simple",
	225	.id = UCLASS_BOOTMETH,
	226	.of_match = of_match_ptr(generic_simple_vbe_simple_ids),
	227	.ops = &bootmeth_vbe_simple_ops,
	228	.bind = bootmeth_vbe_simple_bind,
	229	.probe = bootmeth_vbe_simple_probe,
	230	.flags = DM_FLAG_PRE_RELOC,
	231	.priv_auto = sizeof(struct simple_priv),
	232	};