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

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

#define LOG_CATEGORY LOGC_BOOT

#include <common.h>
#include <bloblist.h>
#include <bootdev.h>
#include <bootflow.h>
#include <bootmeth.h>
#include <bootstage.h>
#include <dm.h>
#include <image.h>
#include <log.h>
#include <mapmem.h>
#include <memalign.h>
#include <mmc.h>
#include <spl.h>
#include <vbe.h>
#include <dm/device-internal.h>
#include "vbe_simple.h"

/**
 * vbe_simple_read_bootflow_fw() - Create a bootflow for firmware
 *
 * Locates and loads the firmware image (FIT) needed for the next phase. The FIT
 * should ideally use external data, to reduce the amount of it that needs to be
 * read.
 *
 * @bdev: bootdev device containing the firmwre
 * @meth: VBE simple bootmeth
 * @blow: Place to put the created bootflow, on success
 * @return 0 if OK, -ve on error
 */
int vbe_simple_read_bootflow_fw(struct udevice *dev, struct bootflow *bflow)
{
	ALLOC_CACHE_ALIGN_BUFFER(u8, sbuf, MMC_MAX_BLOCK_LEN);
	struct udevice *media = dev_get_parent(bflow->dev);
	struct udevice *meth = bflow->method;
	struct simple_priv *priv = dev_get_priv(meth);
	const char *fit_uname, *fit_uname_config;
	struct bootm_headers images = {};
	ulong offset, size, blknum, addr, len, load_addr, num_blks;
	enum image_phase_t phase;
	struct blk_desc *desc;
	struct udevice *blk;
	int node, ret;
	void *buf;

	log_debug("media=%s\n", media->name);
	ret = blk_get_from_parent(media, &blk);
	if (ret)
		return log_msg_ret("med", ret);
	log_debug("blk=%s\n", blk->name);
	desc = dev_get_uclass_plat(blk);

	offset = priv->area_start + priv->skip_offset;

	/* read in one block to find the FIT size */
	blknum =  offset / desc->blksz;
	log_debug("read at %lx, blknum %lx\n", offset, blknum);
	ret = blk_read(blk, blknum, 1, sbuf);
	if (ret < 0)
		return log_msg_ret("rd", ret);

	ret = fdt_check_header(sbuf);
	if (ret < 0)
		return log_msg_ret("fdt", -EINVAL);
	size = fdt_totalsize(sbuf);
	if (size > priv->area_size)
		return log_msg_ret("fdt", -E2BIG);
	log_debug("FIT size %lx\n", size);

	/*
	 * Load the FIT into the SPL memory. This is typically a FIT with
	 * external data, so this is quite small, perhaps a few KB.
	 */
	addr = CONFIG_VAL(TEXT_BASE);
	buf = map_sysmem(addr, size);
	num_blks = DIV_ROUND_UP(size, desc->blksz);
	log_debug("read %lx, %lx blocks to %lx / %p\n", size, num_blks, addr,
		  buf);
	ret = blk_read(blk, blknum, num_blks, buf);
	if (ret < 0)
		return log_msg_ret("rd", ret);

	/* figure out the phase to load */
	phase = IS_ENABLED(CONFIG_VPL_BUILD) ? IH_PHASE_SPL : IH_PHASE_U_BOOT;

	/*
	 * Load the image from the FIT. We ignore any load-address information
	 * so in practice this simply locates the image in the external-data
	 * region and returns its address and size. Since we only loaded the FIT
	 * itself, only a part of the image will be present, at best.
	 */
	fit_uname = NULL;
	fit_uname_config = NULL;
	log_debug("loading FIT\n");
	ret = fit_image_load(&images, addr, &fit_uname, &fit_uname_config,
			     IH_ARCH_SANDBOX, image_ph(phase, IH_TYPE_FIRMWARE),
			     BOOTSTAGE_ID_FIT_SPL_START, FIT_LOAD_IGNORED,
			     &load_addr, &len);
	if (ret < 0)
		return log_msg_ret("ld", ret);
	node = ret;
	log_debug("loaded to %lx\n", load_addr);

	/* For FIT external data, read in the external data */
	if (load_addr + len > addr + size) {
		ulong base, full_size;
		void *base_buf;

		/* Find the start address to load from */
		base = ALIGN_DOWN(load_addr, desc->blksz);

		/*
		 * Get the total number of bytes to load, taking care of
		 * block alignment
		 */
		full_size = load_addr + len - base;

		/*
		 * Get the start block number, number of blocks and the address
		 * to load to, then load the blocks
		 */
		blknum = (offset + base - addr) / desc->blksz;
		num_blks = DIV_ROUND_UP(full_size, desc->blksz);
		base_buf = map_sysmem(base, full_size);
		ret = blk_read(blk, blknum, num_blks, base_buf);
		log_debug("read %lx %lx, %lx blocks to %lx / %p: ret=%d\n",
			  blknum, full_size, num_blks, base, base_buf, ret);
		if (ret < 0)
			return log_msg_ret("rd", ret);
	}

	/* set up the bootflow with the info we obtained */
	bflow->name = strdup(fdt_get_name(buf, node, NULL));
	if (!bflow->name)
		return log_msg_ret("name", -ENOMEM);
	bflow->blk = blk;
	bflow->buf = map_sysmem(load_addr, len);
	bflow->size = len;

	return 0;
}

static int simple_load_from_image(struct spl_image_info *spl_image,
				  struct spl_boot_device *bootdev)
{
	struct udevice *meth, *bdev;
	struct simple_priv *priv;
	struct bootflow bflow;
	struct vbe_handoff *handoff;
	int ret;

	if (spl_phase() != PHASE_VPL && spl_phase() != PHASE_SPL)
		return -ENOENT;

	ret = bloblist_ensure_size(BLOBLISTT_VBE, sizeof(struct vbe_handoff),
				   0, (void **)&handoff);
	if (ret)
		return log_msg_ret("ro", ret);

	vbe_find_first_device(&meth);
	if (!meth)
		return log_msg_ret("vd", -ENODEV);
	log_debug("vbe dev %s\n", meth->name);
	ret = device_probe(meth);
	if (ret)
		return log_msg_ret("probe", ret);

	priv = dev_get_priv(meth);
	log_debug("simple %s\n", priv->storage);
	ret = bootdev_find_by_label(priv->storage, &bdev, NULL);
	if (ret)
		return log_msg_ret("bd", ret);
	log_debug("bootdev %s\n", bdev->name);

	bootflow_init(&bflow, bdev, meth);
	ret = bootmeth_read_bootflow(meth, &bflow);
	log_debug("\nfw ret=%d\n", ret);
	if (ret)
		return log_msg_ret("rd", ret);

	/* jump to the image */
	spl_image->flags = SPL_SANDBOXF_ARG_IS_BUF;
	spl_image->arg = bflow.buf;
	spl_image->size = bflow.size;
	log_debug("Image: %s at %p size %x\n", bflow.name, bflow.buf,
		  bflow.size);

	/* this is not used from now on, so free it */
	bootflow_free(&bflow);

	/* Record that VBE was used in this phase */
	handoff->phases |= 1 << spl_phase();

	return 0;
}
SPL_LOAD_IMAGE_METHOD("vbe_simple", 5, BOOT_DEVICE_VBE,
		      simple_load_from_image);
Commit	Line	Data
d2b22ae2 SG	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* Verified Boot for Embedded (VBE) loading firmware phases
	4	*
	5	* Copyright 2022 Google LLC
	6	* Written by Simon Glass <[email protected]>
	7	*/
	8
	9	#define LOG_CATEGORY LOGC_BOOT
	10
	11	#include <common.h>
d8b7c34f	12	#include <bloblist.h>
d2b22ae2 SG	13	#include <bootdev.h>
	14	#include <bootflow.h>
	15	#include <bootmeth.h>
	16	#include <bootstage.h>
	17	#include <dm.h>
	18	#include <image.h>
	19	#include <log.h>
	20	#include <mapmem.h>
	21	#include <memalign.h>
	22	#include <mmc.h>
	23	#include <spl.h>
	24	#include <vbe.h>
	25	#include <dm/device-internal.h>
	26	#include "vbe_simple.h"
	27
	28	/**
	29	* vbe_simple_read_bootflow_fw() - Create a bootflow for firmware
	30	*
	31	* Locates and loads the firmware image (FIT) needed for the next phase. The FIT
	32	* should ideally use external data, to reduce the amount of it that needs to be
	33	* read.
	34	*
	35	* @bdev: bootdev device containing the firmwre
	36	* @meth: VBE simple bootmeth
	37	* @blow: Place to put the created bootflow, on success
	38	* @return 0 if OK, -ve on error
	39	*/
	40	int vbe_simple_read_bootflow_fw(struct udevice dev, struct bootflow bflow)
	41	{
	42	ALLOC_CACHE_ALIGN_BUFFER(u8, sbuf, MMC_MAX_BLOCK_LEN);
	43	struct udevice *media = dev_get_parent(bflow->dev);
	44	struct udevice *meth = bflow->method;
	45	struct simple_priv *priv = dev_get_priv(meth);
	46	const char fit_uname, fit_uname_config;
	47	struct bootm_headers images = {};
	48	ulong offset, size, blknum, addr, len, load_addr, num_blks;
	49	enum image_phase_t phase;
	50	struct blk_desc *desc;
	51	struct udevice *blk;
	52	int node, ret;
	53	void *buf;
	54
	55	log_debug("media=%s\n", media->name);
	56	ret = blk_get_from_parent(media, &blk);
	57	if (ret)
	58	return log_msg_ret("med", ret);
	59	log_debug("blk=%s\n", blk->name);
	60	desc = dev_get_uclass_plat(blk);
	61
	62	offset = priv->area_start + priv->skip_offset;
	63
	64	/* read in one block to find the FIT size */
	65	blknum = offset / desc->blksz;
	66	log_debug("read at %lx, blknum %lx\n", offset, blknum);
	67	ret = blk_read(blk, blknum, 1, sbuf);
	68	if (ret < 0)
	69	return log_msg_ret("rd", ret);
	70
	71	ret = fdt_check_header(sbuf);
	72	if (ret < 0)
	73	return log_msg_ret("fdt", -EINVAL);
	74	size = fdt_totalsize(sbuf);
	75	if (size > priv->area_size)
	76	return log_msg_ret("fdt", -E2BIG);
77	log_debug("FIT size %lx\n", size);
78
79	/*
80	* Load the FIT into the SPL memory. This is typically a FIT with
81	* external data, so this is quite small, perhaps a few KB.
82	*/
83	addr = CONFIG_VAL(TEXT_BASE);
84	buf = map_sysmem(addr, size);
85	num_blks = DIV_ROUND_UP(size, desc->blksz);
86	log_debug("read %lx, %lx blocks to %lx / %p\n", size, num_blks, addr,
87	buf);
88	ret = blk_read(blk, blknum, num_blks, buf);
89	if (ret < 0)
90	return log_msg_ret("rd", ret);
91
92	/* figure out the phase to load */
93	phase = IS_ENABLED(CONFIG_VPL_BUILD) ? IH_PHASE_SPL : IH_PHASE_U_BOOT;
94
95	/*
96	* Load the image from the FIT. We ignore any load-address information
97	* so in practice this simply locates the image in the external-data
98	* region and returns its address and size. Since we only loaded the FIT
99	* itself, only a part of the image will be present, at best.
100	*/
101	fit_uname = NULL;
102	fit_uname_config = NULL;
103	log_debug("loading FIT\n");
104	ret = fit_image_load(&images, addr, &fit_uname, &fit_uname_config,
105	IH_ARCH_SANDBOX, image_ph(phase, IH_TYPE_FIRMWARE),
106	BOOTSTAGE_ID_FIT_SPL_START, FIT_LOAD_IGNORED,
107	&load_addr, &len);
108	if (ret < 0)
109	return log_msg_ret("ld", ret);
110	node = ret;
111	log_debug("loaded to %lx\n", load_addr);
112
113	/* For FIT external data, read in the external data */
114	if (load_addr + len > addr + size) {
115	ulong base, full_size;
116	void *base_buf;
117
118	/* Find the start address to load from */
119	base = ALIGN_DOWN(load_addr, desc->blksz);
120
121	/*
122	* Get the total number of bytes to load, taking care of
123	* block alignment
124	*/
125	full_size = load_addr + len - base;
126
127	/*
128	* Get the start block number, number of blocks and the address
129	* to load to, then load the blocks
130	*/
131	blknum = (offset + base - addr) / desc->blksz;
132	num_blks = DIV_ROUND_UP(full_size, desc->blksz);
133	base_buf = map_sysmem(base, full_size);
134	ret = blk_read(blk, blknum, num_blks, base_buf);
135	log_debug("read %lx %lx, %lx blocks to %lx / %p: ret=%d\n",
136	blknum, full_size, num_blks, base, base_buf, ret);
137	if (ret < 0)
138	return log_msg_ret("rd", ret);
139	}
140
141	/* set up the bootflow with the info we obtained */
142	bflow->name = strdup(fdt_get_name(buf, node, NULL));
143	if (!bflow->name)
144	return log_msg_ret("name", -ENOMEM);
145	bflow->blk = blk;
146	bflow->buf = map_sysmem(load_addr, len);
147	bflow->size = len;
148
149	return 0;
150	}
151
152	static int simple_load_from_image(struct spl_image_info *spl_image,
153	struct spl_boot_device *bootdev)
154	{
155	struct udevice meth, bdev;
156	struct simple_priv *priv;
157	struct bootflow bflow;
d8b7c34f	158	struct vbe_handoff *handoff;
d2b22ae2 SG	159	int ret;
	160
	161	if (spl_phase() != PHASE_VPL && spl_phase() != PHASE_SPL)
	162	return -ENOENT;
	163
d8b7c34f SG	164	ret = bloblist_ensure_size(BLOBLISTT_VBE, sizeof(struct vbe_handoff),
	165	0, (void **)&handoff);
	166	if (ret)
	167	return log_msg_ret("ro", ret);
	168
d2b22ae2 SG	169	vbe_find_first_device(&meth);
	170	if (!meth)
	171	return log_msg_ret("vd", -ENODEV);
	172	log_debug("vbe dev %s\n", meth->name);
	173	ret = device_probe(meth);
	174	if (ret)
	175	return log_msg_ret("probe", ret);
	176
	177	priv = dev_get_priv(meth);
	178	log_debug("simple %s\n", priv->storage);
d9f48579	179	ret = bootdev_find_by_label(priv->storage, &bdev, NULL);
d2b22ae2 SG	180	if (ret)
	181	return log_msg_ret("bd", ret);
	182	log_debug("bootdev %s\n", bdev->name);
	183
	184	bootflow_init(&bflow, bdev, meth);
	185	ret = bootmeth_read_bootflow(meth, &bflow);
	186	log_debug("\nfw ret=%d\n", ret);
	187	if (ret)
	188	return log_msg_ret("rd", ret);
	189
	190	/* jump to the image */
	191	spl_image->flags = SPL_SANDBOXF_ARG_IS_BUF;
	192	spl_image->arg = bflow.buf;
	193	spl_image->size = bflow.size;
	194	log_debug("Image: %s at %p size %x\n", bflow.name, bflow.buf,
	195	bflow.size);
	196
	197	/* this is not used from now on, so free it */
	198	bootflow_free(&bflow);
	199
d8b7c34f SG	200	/* Record that VBE was used in this phase */
	201	handoff->phases \|= 1 << spl_phase();
	202
d2b22ae2 SG	203	return 0;
	204	}
	205	SPL_LOAD_IMAGE_METHOD("vbe_simple", 5, BOOT_DEVICE_VBE,
	206	simple_load_from_image);