1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * Copyright 2018 Google, Inc
4 * Written by Simon Glass <sjg@chromium.org>
5 */
6
7 #include <common.h>
8 #include <bloblist.h>
9 #include <log.h>
10 #include <mapmem.h>
11 #include <spl.h>
12 #include <asm/global_data.h>
13 #include <u-boot/crc.h>
14
15 /*
16 * A bloblist is a single contiguous chunk of memory with a header
17 * (struct bloblist_hdr) and a number of blobs in it.
18 *
19 * Each blob starts on a BLOBLIST_ALIGN boundary relative to the start of the
20 * bloblist and consists of a struct bloblist_rec, some padding to the required
21 * alignment for the blog and then the actual data. The padding ensures that the
22 * start address of the data in each blob is aligned as required. Note that
23 * each blob's *data* is aligned to BLOBLIST_ALIGN regardless of the alignment
24 * of the bloblist itself or the blob header.
25 *
26 * So far, only BLOBLIST_ALIGN alignment is supported.
27 */
28
29 DECLARE_GLOBAL_DATA_PTR;
30
31 static const char *const tag_name[] = {
32 [BLOBLISTT_NONE] = "(none)",
33 [BLOBLISTT_EC_HOSTEVENT] = "EC host event",
34 [BLOBLISTT_SPL_HANDOFF] = "SPL hand-off",
35 [BLOBLISTT_VBOOT_CTX] = "Chrome OS vboot context",
36 [BLOBLISTT_VBOOT_HANDOFF] = "Chrome OS vboot hand-off",
37 [BLOBLISTT_ACPI_GNVS] = "ACPI GNVS",
38 [BLOBLISTT_INTEL_VBT] = "Intel Video-BIOS table",
39 [BLOBLISTT_TPM2_TCG_LOG] = "TPM v2 log space",
40 [BLOBLISTT_TCPA_LOG] = "TPM log space",
41 [BLOBLISTT_ACPI_TABLES] = "ACPI tables for x86",
42 [BLOBLISTT_SMBIOS_TABLES] = "SMBIOS tables for x86",
43 };
44
bloblist_tag_name(enum bloblist_tag_t tag)45 const char *bloblist_tag_name(enum bloblist_tag_t tag)
46 {
47 if (tag < 0 || tag >= BLOBLISTT_COUNT)
48 return "invalid";
49
50 return tag_name[tag];
51 }
52
bloblist_first_blob(struct bloblist_hdr * hdr)53 static struct bloblist_rec *bloblist_first_blob(struct bloblist_hdr *hdr)
54 {
55 if (hdr->alloced <= hdr->hdr_size)
56 return NULL;
57 return (struct bloblist_rec *)((void *)hdr + hdr->hdr_size);
58 }
59
bloblist_next_blob(struct bloblist_hdr * hdr,struct bloblist_rec * rec)60 static struct bloblist_rec *bloblist_next_blob(struct bloblist_hdr *hdr,
61 struct bloblist_rec *rec)
62 {
63 ulong offset;
64
65 offset = (void *)rec - (void *)hdr;
66 offset += rec->hdr_size + ALIGN(rec->size, BLOBLIST_ALIGN);
67 if (offset >= hdr->alloced)
68 return NULL;
69 return (struct bloblist_rec *)((void *)hdr + offset);
70 }
71
72 #define foreach_rec(_rec, _hdr) \
73 for (_rec = bloblist_first_blob(_hdr); \
74 _rec; \
75 _rec = bloblist_next_blob(_hdr, _rec))
76
bloblist_findrec(uint tag)77 static struct bloblist_rec *bloblist_findrec(uint tag)
78 {
79 struct bloblist_hdr *hdr = gd->bloblist;
80 struct bloblist_rec *rec;
81
82 if (!hdr)
83 return NULL;
84
85 foreach_rec(rec, hdr) {
86 if (rec->tag == tag)
87 return rec;
88 }
89
90 return NULL;
91 }
92
bloblist_addrec(uint tag,int size,int align,struct bloblist_rec ** recp)93 static int bloblist_addrec(uint tag, int size, int align,
94 struct bloblist_rec **recp)
95 {
96 struct bloblist_hdr *hdr = gd->bloblist;
97 struct bloblist_rec *rec;
98 int data_start, new_alloced;
99
100 if (!align)
101 align = BLOBLIST_ALIGN;
102
103 /* Figure out where the new data will start */
104 data_start = map_to_sysmem(hdr) + hdr->alloced + sizeof(*rec);
105
106 /* Align the address and then calculate the offset from ->alloced */
107 data_start = ALIGN(data_start, align) - map_to_sysmem(hdr);
108
109 /* Calculate the new allocated total */
110 new_alloced = data_start + ALIGN(size, align);
111
112 if (new_alloced >= hdr->size) {
113 log(LOGC_BLOBLIST, LOGL_ERR,
114 "Failed to allocate %x bytes size=%x, need size=%x\n",
115 size, hdr->size, new_alloced);
116 return log_msg_ret("bloblist add", -ENOSPC);
117 }
118 rec = (void *)hdr + hdr->alloced;
119
120 rec->tag = tag;
121 rec->hdr_size = data_start - hdr->alloced;
122 rec->size = size;
123 rec->spare = 0;
124
125 /* Zero the record data */
126 memset((void *)rec + rec->hdr_size, '\0', rec->size);
127
128 hdr->alloced = new_alloced;
129 *recp = rec;
130
131 return 0;
132 }
133
bloblist_ensurerec(uint tag,struct bloblist_rec ** recp,int size,int align)134 static int bloblist_ensurerec(uint tag, struct bloblist_rec **recp, int size,
135 int align)
136 {
137 struct bloblist_rec *rec;
138
139 rec = bloblist_findrec(tag);
140 if (rec) {
141 if (size && size != rec->size) {
142 *recp = rec;
143 return -ESPIPE;
144 }
145 } else {
146 int ret;
147
148 ret = bloblist_addrec(tag, size, align, &rec);
149 if (ret)
150 return ret;
151 }
152 *recp = rec;
153
154 return 0;
155 }
156
bloblist_find(uint tag,int size)157 void *bloblist_find(uint tag, int size)
158 {
159 struct bloblist_rec *rec;
160
161 rec = bloblist_findrec(tag);
162 if (!rec)
163 return NULL;
164 if (size && size != rec->size)
165 return NULL;
166
167 return (void *)rec + rec->hdr_size;
168 }
169
bloblist_add(uint tag,int size,int align)170 void *bloblist_add(uint tag, int size, int align)
171 {
172 struct bloblist_rec *rec;
173
174 if (bloblist_addrec(tag, size, align, &rec))
175 return NULL;
176
177 return (void *)rec + rec->hdr_size;
178 }
179
bloblist_ensure_size(uint tag,int size,int align,void ** blobp)180 int bloblist_ensure_size(uint tag, int size, int align, void **blobp)
181 {
182 struct bloblist_rec *rec;
183 int ret;
184
185 ret = bloblist_ensurerec(tag, &rec, size, align);
186 if (ret)
187 return ret;
188 *blobp = (void *)rec + rec->hdr_size;
189
190 return 0;
191 }
192
bloblist_ensure(uint tag,int size)193 void *bloblist_ensure(uint tag, int size)
194 {
195 struct bloblist_rec *rec;
196
197 if (bloblist_ensurerec(tag, &rec, size, 0))
198 return NULL;
199
200 return (void *)rec + rec->hdr_size;
201 }
202
bloblist_ensure_size_ret(uint tag,int * sizep,void ** blobp)203 int bloblist_ensure_size_ret(uint tag, int *sizep, void **blobp)
204 {
205 struct bloblist_rec *rec;
206 int ret;
207
208 ret = bloblist_ensurerec(tag, &rec, *sizep, 0);
209 if (ret == -ESPIPE)
210 *sizep = rec->size;
211 else if (ret)
212 return ret;
213 *blobp = (void *)rec + rec->hdr_size;
214
215 return 0;
216 }
217
bloblist_calc_chksum(struct bloblist_hdr * hdr)218 static u32 bloblist_calc_chksum(struct bloblist_hdr *hdr)
219 {
220 struct bloblist_rec *rec;
221 u32 chksum;
222
223 chksum = crc32(0, (unsigned char *)hdr,
224 offsetof(struct bloblist_hdr, chksum));
225 foreach_rec(rec, hdr) {
226 chksum = crc32(chksum, (void *)rec, rec->hdr_size);
227 chksum = crc32(chksum, (void *)rec + rec->hdr_size, rec->size);
228 }
229
230 return chksum;
231 }
232
bloblist_new(ulong addr,uint size,uint flags)233 int bloblist_new(ulong addr, uint size, uint flags)
234 {
235 struct bloblist_hdr *hdr;
236
237 if (size < sizeof(*hdr))
238 return log_ret(-ENOSPC);
239 if (addr & (BLOBLIST_ALIGN - 1))
240 return log_ret(-EFAULT);
241 hdr = map_sysmem(addr, size);
242 memset(hdr, '\0', sizeof(*hdr));
243 hdr->version = BLOBLIST_VERSION;
244 hdr->hdr_size = sizeof(*hdr);
245 hdr->flags = flags;
246 hdr->magic = BLOBLIST_MAGIC;
247 hdr->size = size;
248 hdr->alloced = hdr->hdr_size;
249 hdr->chksum = 0;
250 gd->bloblist = hdr;
251
252 return 0;
253 }
254
bloblist_check(ulong addr,uint size)255 int bloblist_check(ulong addr, uint size)
256 {
257 struct bloblist_hdr *hdr;
258 u32 chksum;
259
260 hdr = map_sysmem(addr, sizeof(*hdr));
261 if (hdr->magic != BLOBLIST_MAGIC)
262 return log_msg_ret("Bad magic", -ENOENT);
263 if (hdr->version != BLOBLIST_VERSION)
264 return log_msg_ret("Bad version", -EPROTONOSUPPORT);
265 if (size && hdr->size != size)
266 return log_msg_ret("Bad size", -EFBIG);
267 chksum = bloblist_calc_chksum(hdr);
268 if (hdr->chksum != chksum) {
269 log(LOGC_BLOBLIST, LOGL_ERR, "Checksum %x != %x\n", hdr->chksum,
270 chksum);
271 return log_msg_ret("Bad checksum", -EIO);
272 }
273 gd->bloblist = hdr;
274
275 return 0;
276 }
277
bloblist_finish(void)278 int bloblist_finish(void)
279 {
280 struct bloblist_hdr *hdr = gd->bloblist;
281
282 hdr->chksum = bloblist_calc_chksum(hdr);
283
284 return 0;
285 }
286
bloblist_get_stats(ulong * basep,ulong * sizep,ulong * allocedp)287 void bloblist_get_stats(ulong *basep, ulong *sizep, ulong *allocedp)
288 {
289 struct bloblist_hdr *hdr = gd->bloblist;
290
291 *basep = map_to_sysmem(gd->bloblist);
292 *sizep = hdr->size;
293 *allocedp = hdr->alloced;
294 }
295
show_value(const char * prompt,ulong value)296 static void show_value(const char *prompt, ulong value)
297 {
298 printf("%s:%*s %-5lx ", prompt, 8 - (int)strlen(prompt), "", value);
299 print_size(value, "\n");
300 }
301
bloblist_show_stats(void)302 void bloblist_show_stats(void)
303 {
304 ulong base, size, alloced;
305
306 bloblist_get_stats(&base, &size, &alloced);
307 printf("base: %lx\n", base);
308 show_value("size", size);
309 show_value("alloced", alloced);
310 show_value("free", size - alloced);
311 }
312
bloblist_show_list(void)313 void bloblist_show_list(void)
314 {
315 struct bloblist_hdr *hdr = gd->bloblist;
316 struct bloblist_rec *rec;
317
318 printf("%-8s %8s Tag Name\n", "Address", "Size");
319 for (rec = bloblist_first_blob(hdr); rec;
320 rec = bloblist_next_blob(hdr, rec)) {
321 printf("%08lx %8x %3d %s\n",
322 (ulong)map_to_sysmem((void *)rec + rec->hdr_size),
323 rec->size, rec->tag, bloblist_tag_name(rec->tag));
324 }
325 }
326
bloblist_reloc(void * to,uint to_size,void * from,uint from_size)327 void bloblist_reloc(void *to, uint to_size, void *from, uint from_size)
328 {
329 struct bloblist_hdr *hdr;
330
331 memcpy(to, from, from_size);
332 hdr = to;
333 hdr->size = to_size;
334 }
335
bloblist_init(void)336 int bloblist_init(void)
337 {
338 bool expected;
339 int ret = -ENOENT;
340
341 /**
342 * Wed expect to find an existing bloblist in the first phase of U-Boot
343 * that runs
344 */
345 expected = !u_boot_first_phase();
346 if (spl_prev_phase() == PHASE_TPL && !IS_ENABLED(CONFIG_TPL_BLOBLIST))
347 expected = false;
348 if (expected)
349 ret = bloblist_check(CONFIG_BLOBLIST_ADDR,
350 CONFIG_BLOBLIST_SIZE);
351 if (ret) {
352 log(LOGC_BLOBLIST, expected ? LOGL_WARNING : LOGL_DEBUG,
353 "Existing bloblist not found: creating new bloblist\n");
354 ret = bloblist_new(CONFIG_BLOBLIST_ADDR, CONFIG_BLOBLIST_SIZE,
355 0);
356 } else {
357 log(LOGC_BLOBLIST, LOGL_DEBUG, "Found existing bloblist\n");
358 }
359
360 return ret;
361 }
362