blob: d59a704ddbade4708aceb025b66c57996357f459 [file] [log] [blame]
Simon Glassd2b22ae2022-10-20 18:23:10 -06001// 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 <sjg@chromium.org>
7 */
8
9#define LOG_CATEGORY LOGC_BOOT
10
11#include <common.h>
Simon Glassd8b7c342022-10-20 18:23:18 -060012#include <bloblist.h>
Simon Glassd2b22ae2022-10-20 18:23:10 -060013#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 */
40int 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
152static 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;
Simon Glassd8b7c342022-10-20 18:23:18 -0600158 struct vbe_handoff *handoff;
Simon Glassd2b22ae2022-10-20 18:23:10 -0600159 int ret;
160
161 if (spl_phase() != PHASE_VPL && spl_phase() != PHASE_SPL)
162 return -ENOENT;
163
Simon Glassd8b7c342022-10-20 18:23:18 -0600164 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
Simon Glassd2b22ae2022-10-20 18:23:10 -0600169 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);
Simon Glassd9f48572023-01-17 10:48:05 -0700179 ret = bootdev_find_by_label(priv->storage, &bdev, NULL);
Simon Glassd2b22ae2022-10-20 18:23:10 -0600180 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
Simon Glassd8b7c342022-10-20 18:23:18 -0600200 /* Record that VBE was used in this phase */
201 handoff->phases |= 1 << spl_phase();
202
Simon Glassd2b22ae2022-10-20 18:23:10 -0600203 return 0;
204}
205SPL_LOAD_IMAGE_METHOD("vbe_simple", 5, BOOT_DEVICE_VBE,
206 simple_load_from_image);