2022-01-13 02:26:25 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0+ BSD-3-Clause
|
2018-11-16 01:43:50 +00:00
|
|
|
/*
|
|
|
|
* Copyright 2018 Google, Inc
|
|
|
|
* Written by Simon Glass <sjg@chromium.org>
|
|
|
|
*/
|
|
|
|
|
2022-01-13 02:26:20 +00:00
|
|
|
#define LOG_CATEGORY LOGC_BLOBLIST
|
|
|
|
|
2018-11-16 01:43:50 +00:00
|
|
|
#include <common.h>
|
|
|
|
#include <bloblist.h>
|
2022-07-31 18:28:48 +00:00
|
|
|
#include <display_options.h>
|
2018-11-16 01:43:50 +00:00
|
|
|
#include <log.h>
|
2021-11-04 03:09:20 +00:00
|
|
|
#include <malloc.h>
|
2018-11-16 01:43:50 +00:00
|
|
|
#include <mapmem.h>
|
|
|
|
#include <spl.h>
|
2023-12-27 21:07:05 +00:00
|
|
|
#include <tables_csum.h>
|
2020-10-31 03:38:53 +00:00
|
|
|
#include <asm/global_data.h>
|
2019-11-14 19:57:16 +00:00
|
|
|
#include <u-boot/crc.h>
|
2018-11-16 01:43:50 +00:00
|
|
|
|
2020-09-20 00:49:28 +00:00
|
|
|
/*
|
|
|
|
* A bloblist is a single contiguous chunk of memory with a header
|
|
|
|
* (struct bloblist_hdr) and a number of blobs in it.
|
|
|
|
*
|
|
|
|
* Each blob starts on a BLOBLIST_ALIGN boundary relative to the start of the
|
|
|
|
* bloblist and consists of a struct bloblist_rec, some padding to the required
|
|
|
|
* alignment for the blog and then the actual data. The padding ensures that the
|
|
|
|
* start address of the data in each blob is aligned as required. Note that
|
|
|
|
* each blob's *data* is aligned to BLOBLIST_ALIGN regardless of the alignment
|
|
|
|
* of the bloblist itself or the blob header.
|
|
|
|
*/
|
|
|
|
|
2018-11-16 01:43:50 +00:00
|
|
|
DECLARE_GLOBAL_DATA_PTR;
|
|
|
|
|
2022-01-13 02:26:19 +00:00
|
|
|
static struct tag_name {
|
|
|
|
enum bloblist_tag_t tag;
|
|
|
|
const char *name;
|
|
|
|
} tag_name[] = {
|
2023-12-27 21:06:59 +00:00
|
|
|
{ BLOBLISTT_VOID, "(void)" },
|
2022-01-13 02:26:19 +00:00
|
|
|
|
|
|
|
/* BLOBLISTT_AREA_FIRMWARE_TOP */
|
2023-12-27 21:06:59 +00:00
|
|
|
{ BLOBLISTT_CONTROL_FDT, "Control FDT" },
|
|
|
|
{ BLOBLISTT_HOB_BLOCK, "HOB block" },
|
|
|
|
{ BLOBLISTT_HOB_LIST, "HOB list" },
|
|
|
|
{ BLOBLISTT_ACPI_TABLES, "ACPI tables for x86" },
|
|
|
|
{ BLOBLISTT_TPM_EVLOG, "TPM event log defined by TCG EFI" },
|
|
|
|
{ BLOBLISTT_TPM_CRB_BASE, "TPM Command Response Buffer address" },
|
2022-01-13 02:26:19 +00:00
|
|
|
|
|
|
|
/* BLOBLISTT_AREA_FIRMWARE */
|
|
|
|
{ BLOBLISTT_TPM2_TCG_LOG, "TPM v2 log space" },
|
|
|
|
{ BLOBLISTT_TCPA_LOG, "TPM log space" },
|
2023-12-27 21:06:59 +00:00
|
|
|
{ BLOBLISTT_ACPI_GNVS, "ACPI GNVS" },
|
|
|
|
|
|
|
|
/* BLOBLISTT_AREA_TF */
|
|
|
|
{ BLOBLISTT_OPTEE_PAGABLE_PART, "OP-TEE pagable part" },
|
|
|
|
|
|
|
|
/* BLOBLISTT_AREA_OTHER */
|
|
|
|
{ BLOBLISTT_INTEL_VBT, "Intel Video-BIOS table" },
|
2022-01-13 02:26:19 +00:00
|
|
|
{ BLOBLISTT_SMBIOS_TABLES, "SMBIOS tables for x86" },
|
|
|
|
{ BLOBLISTT_VBOOT_CTX, "Chrome OS vboot context" },
|
|
|
|
|
|
|
|
/* BLOBLISTT_PROJECT_AREA */
|
|
|
|
{ BLOBLISTT_U_BOOT_SPL_HANDOFF, "SPL hand-off" },
|
2023-09-26 14:14:52 +00:00
|
|
|
{ BLOBLISTT_VBE, "VBE" },
|
2023-07-16 03:38:59 +00:00
|
|
|
{ BLOBLISTT_U_BOOT_VIDEO, "SPL video handoff" },
|
2022-01-13 02:26:19 +00:00
|
|
|
|
|
|
|
/* BLOBLISTT_VENDOR_AREA */
|
2020-09-20 00:49:26 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
const char *bloblist_tag_name(enum bloblist_tag_t tag)
|
|
|
|
{
|
2022-01-13 02:26:19 +00:00
|
|
|
int i;
|
2020-09-20 00:49:26 +00:00
|
|
|
|
2022-01-13 02:26:19 +00:00
|
|
|
for (i = 0; i < ARRAY_SIZE(tag_name); i++) {
|
|
|
|
if (tag_name[i].tag == tag)
|
|
|
|
return tag_name[i].name;
|
|
|
|
}
|
|
|
|
|
|
|
|
return "invalid";
|
2020-09-20 00:49:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct bloblist_rec *bloblist_first_blob(struct bloblist_hdr *hdr)
|
2018-11-16 01:43:50 +00:00
|
|
|
{
|
|
|
|
if (hdr->alloced <= hdr->hdr_size)
|
|
|
|
return NULL;
|
|
|
|
return (struct bloblist_rec *)((void *)hdr + hdr->hdr_size);
|
|
|
|
}
|
|
|
|
|
2023-12-27 21:07:03 +00:00
|
|
|
static inline uint rec_hdr_size(struct bloblist_rec *rec)
|
|
|
|
{
|
|
|
|
return rec->hdr_size;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline uint rec_tag(struct bloblist_rec *rec)
|
|
|
|
{
|
|
|
|
return rec->tag;
|
|
|
|
}
|
|
|
|
|
2021-07-05 22:32:53 +00:00
|
|
|
static ulong bloblist_blob_end_ofs(struct bloblist_hdr *hdr,
|
|
|
|
struct bloblist_rec *rec)
|
2018-11-16 01:43:50 +00:00
|
|
|
{
|
|
|
|
ulong offset;
|
|
|
|
|
|
|
|
offset = (void *)rec - (void *)hdr;
|
2023-12-27 21:07:03 +00:00
|
|
|
offset += rec_hdr_size(rec) + ALIGN(rec->size, BLOBLIST_ALIGN);
|
2021-07-05 22:32:53 +00:00
|
|
|
|
|
|
|
return offset;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct bloblist_rec *bloblist_next_blob(struct bloblist_hdr *hdr,
|
|
|
|
struct bloblist_rec *rec)
|
|
|
|
{
|
|
|
|
ulong offset = bloblist_blob_end_ofs(hdr, rec);
|
|
|
|
|
2018-11-16 01:43:50 +00:00
|
|
|
if (offset >= hdr->alloced)
|
|
|
|
return NULL;
|
|
|
|
return (struct bloblist_rec *)((void *)hdr + offset);
|
|
|
|
}
|
|
|
|
|
|
|
|
#define foreach_rec(_rec, _hdr) \
|
|
|
|
for (_rec = bloblist_first_blob(_hdr); \
|
|
|
|
_rec; \
|
|
|
|
_rec = bloblist_next_blob(_hdr, _rec))
|
|
|
|
|
|
|
|
static struct bloblist_rec *bloblist_findrec(uint tag)
|
|
|
|
{
|
|
|
|
struct bloblist_hdr *hdr = gd->bloblist;
|
|
|
|
struct bloblist_rec *rec;
|
|
|
|
|
|
|
|
if (!hdr)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
foreach_rec(rec, hdr) {
|
2023-12-27 21:07:03 +00:00
|
|
|
if (rec_tag(rec) == tag)
|
2018-11-16 01:43:50 +00:00
|
|
|
return rec;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2023-12-27 21:07:00 +00:00
|
|
|
static int bloblist_addrec(uint tag, int size, int align_log2,
|
2020-09-20 00:49:29 +00:00
|
|
|
struct bloblist_rec **recp)
|
2018-11-16 01:43:50 +00:00
|
|
|
{
|
|
|
|
struct bloblist_hdr *hdr = gd->bloblist;
|
|
|
|
struct bloblist_rec *rec;
|
2020-09-20 00:49:28 +00:00
|
|
|
int data_start, new_alloced;
|
|
|
|
|
2023-12-27 21:07:00 +00:00
|
|
|
if (!align_log2)
|
|
|
|
align_log2 = BLOBLIST_ALIGN_LOG2;
|
2020-09-20 00:49:29 +00:00
|
|
|
|
2020-09-20 00:49:28 +00:00
|
|
|
/* Figure out where the new data will start */
|
2020-09-20 00:49:29 +00:00
|
|
|
data_start = map_to_sysmem(hdr) + hdr->alloced + sizeof(*rec);
|
|
|
|
|
|
|
|
/* Align the address and then calculate the offset from ->alloced */
|
2023-12-27 21:07:00 +00:00
|
|
|
data_start = ALIGN(data_start, 1U << align_log2) - map_to_sysmem(hdr);
|
2018-11-16 01:43:50 +00:00
|
|
|
|
2020-09-20 00:49:28 +00:00
|
|
|
/* Calculate the new allocated total */
|
2023-12-27 21:07:00 +00:00
|
|
|
new_alloced = data_start + ALIGN(size, 1U << align_log2);
|
2020-09-20 00:49:29 +00:00
|
|
|
|
2021-07-05 22:32:55 +00:00
|
|
|
if (new_alloced > hdr->size) {
|
2022-01-13 02:26:20 +00:00
|
|
|
log_err("Failed to allocate %x bytes size=%x, need size=%x\n",
|
|
|
|
size, hdr->size, new_alloced);
|
2018-11-16 01:43:50 +00:00
|
|
|
return log_msg_ret("bloblist add", -ENOSPC);
|
|
|
|
}
|
|
|
|
rec = (void *)hdr + hdr->alloced;
|
|
|
|
|
|
|
|
rec->tag = tag;
|
2020-09-20 00:49:28 +00:00
|
|
|
rec->hdr_size = data_start - hdr->alloced;
|
2018-11-16 01:43:50 +00:00
|
|
|
rec->size = size;
|
2020-01-27 15:49:52 +00:00
|
|
|
|
|
|
|
/* Zero the record data */
|
2023-12-27 21:07:03 +00:00
|
|
|
memset((void *)rec + rec_hdr_size(rec), '\0', rec->size);
|
2020-09-20 00:49:28 +00:00
|
|
|
|
|
|
|
hdr->alloced = new_alloced;
|
2018-11-16 01:43:50 +00:00
|
|
|
*recp = rec;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2020-09-20 00:49:29 +00:00
|
|
|
static int bloblist_ensurerec(uint tag, struct bloblist_rec **recp, int size,
|
2023-12-27 21:07:00 +00:00
|
|
|
int align_log2)
|
2018-11-16 01:43:50 +00:00
|
|
|
{
|
|
|
|
struct bloblist_rec *rec;
|
|
|
|
|
|
|
|
rec = bloblist_findrec(tag);
|
|
|
|
if (rec) {
|
2020-01-27 15:49:50 +00:00
|
|
|
if (size && size != rec->size) {
|
|
|
|
*recp = rec;
|
2018-11-16 01:43:50 +00:00
|
|
|
return -ESPIPE;
|
2020-01-27 15:49:50 +00:00
|
|
|
}
|
2018-11-16 01:43:50 +00:00
|
|
|
} else {
|
|
|
|
int ret;
|
|
|
|
|
2023-12-27 21:07:00 +00:00
|
|
|
ret = bloblist_addrec(tag, size, align_log2, &rec);
|
2018-11-16 01:43:50 +00:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
*recp = rec;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void *bloblist_find(uint tag, int size)
|
|
|
|
{
|
|
|
|
struct bloblist_rec *rec;
|
|
|
|
|
|
|
|
rec = bloblist_findrec(tag);
|
|
|
|
if (!rec)
|
|
|
|
return NULL;
|
|
|
|
if (size && size != rec->size)
|
|
|
|
return NULL;
|
|
|
|
|
2023-12-27 21:07:03 +00:00
|
|
|
return (void *)rec + rec_hdr_size(rec);
|
2018-11-16 01:43:50 +00:00
|
|
|
}
|
|
|
|
|
2023-12-27 21:07:00 +00:00
|
|
|
void *bloblist_add(uint tag, int size, int align_log2)
|
2018-11-16 01:43:50 +00:00
|
|
|
{
|
|
|
|
struct bloblist_rec *rec;
|
|
|
|
|
2023-12-27 21:07:00 +00:00
|
|
|
if (bloblist_addrec(tag, size, align_log2, &rec))
|
2018-11-16 01:43:50 +00:00
|
|
|
return NULL;
|
|
|
|
|
2023-12-27 21:07:03 +00:00
|
|
|
return (void *)rec + rec_hdr_size(rec);
|
2018-11-16 01:43:50 +00:00
|
|
|
}
|
|
|
|
|
2023-12-27 21:07:00 +00:00
|
|
|
int bloblist_ensure_size(uint tag, int size, int align_log2, void **blobp)
|
2018-11-16 01:43:50 +00:00
|
|
|
{
|
|
|
|
struct bloblist_rec *rec;
|
|
|
|
int ret;
|
|
|
|
|
2023-12-27 21:07:00 +00:00
|
|
|
ret = bloblist_ensurerec(tag, &rec, size, align_log2);
|
2018-11-16 01:43:50 +00:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
2023-12-27 21:07:03 +00:00
|
|
|
*blobp = (void *)rec + rec_hdr_size(rec);
|
2018-11-16 01:43:50 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void *bloblist_ensure(uint tag, int size)
|
|
|
|
{
|
|
|
|
struct bloblist_rec *rec;
|
|
|
|
|
2020-09-20 00:49:29 +00:00
|
|
|
if (bloblist_ensurerec(tag, &rec, size, 0))
|
2018-11-16 01:43:50 +00:00
|
|
|
return NULL;
|
|
|
|
|
2023-12-27 21:07:03 +00:00
|
|
|
return (void *)rec + rec_hdr_size(rec);
|
2018-11-16 01:43:50 +00:00
|
|
|
}
|
|
|
|
|
2020-01-27 15:49:50 +00:00
|
|
|
int bloblist_ensure_size_ret(uint tag, int *sizep, void **blobp)
|
|
|
|
{
|
|
|
|
struct bloblist_rec *rec;
|
|
|
|
int ret;
|
|
|
|
|
2020-09-20 00:49:29 +00:00
|
|
|
ret = bloblist_ensurerec(tag, &rec, *sizep, 0);
|
2020-01-27 15:49:50 +00:00
|
|
|
if (ret == -ESPIPE)
|
|
|
|
*sizep = rec->size;
|
|
|
|
else if (ret)
|
|
|
|
return ret;
|
2023-12-27 21:07:03 +00:00
|
|
|
*blobp = (void *)rec + rec_hdr_size(rec);
|
2020-01-27 15:49:50 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2021-07-05 22:32:53 +00:00
|
|
|
static int bloblist_resize_rec(struct bloblist_hdr *hdr,
|
|
|
|
struct bloblist_rec *rec,
|
|
|
|
int new_size)
|
|
|
|
{
|
|
|
|
int expand_by; /* Number of bytes to expand by (-ve to contract) */
|
|
|
|
int new_alloced; /* New value for @hdr->alloced */
|
|
|
|
ulong next_ofs; /* Offset of the record after @rec */
|
|
|
|
|
|
|
|
expand_by = ALIGN(new_size - rec->size, BLOBLIST_ALIGN);
|
|
|
|
new_alloced = ALIGN(hdr->alloced + expand_by, BLOBLIST_ALIGN);
|
|
|
|
if (new_size < 0) {
|
2022-01-13 02:26:20 +00:00
|
|
|
log_debug("Attempt to shrink blob size below 0 (%x)\n",
|
|
|
|
new_size);
|
2021-07-05 22:32:53 +00:00
|
|
|
return log_msg_ret("size", -EINVAL);
|
|
|
|
}
|
|
|
|
if (new_alloced > hdr->size) {
|
2022-01-13 02:26:20 +00:00
|
|
|
log_err("Failed to allocate %x bytes size=%x, need size=%x\n",
|
|
|
|
new_size, hdr->size, new_alloced);
|
2021-07-05 22:32:53 +00:00
|
|
|
return log_msg_ret("alloc", -ENOSPC);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Move the following blobs up or down, if this is not the last */
|
|
|
|
next_ofs = bloblist_blob_end_ofs(hdr, rec);
|
|
|
|
if (next_ofs != hdr->alloced) {
|
|
|
|
memmove((void *)hdr + next_ofs + expand_by,
|
|
|
|
(void *)hdr + next_ofs, new_alloced - next_ofs);
|
|
|
|
}
|
|
|
|
hdr->alloced = new_alloced;
|
|
|
|
|
|
|
|
/* Zero the new part of the blob */
|
|
|
|
if (expand_by > 0) {
|
2023-12-27 21:07:03 +00:00
|
|
|
memset((void *)rec + rec_hdr_size(rec) + rec->size, '\0',
|
2021-07-05 22:32:53 +00:00
|
|
|
new_size - rec->size);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Update the size of this blob */
|
|
|
|
rec->size = new_size;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int bloblist_resize(uint tag, int new_size)
|
|
|
|
{
|
|
|
|
struct bloblist_hdr *hdr = gd->bloblist;
|
|
|
|
struct bloblist_rec *rec;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
rec = bloblist_findrec(tag);
|
|
|
|
if (!rec)
|
|
|
|
return log_msg_ret("find", -ENOENT);
|
|
|
|
ret = bloblist_resize_rec(hdr, rec, new_size);
|
|
|
|
if (ret)
|
|
|
|
return log_msg_ret("resize", ret);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-11-16 01:43:50 +00:00
|
|
|
static u32 bloblist_calc_chksum(struct bloblist_hdr *hdr)
|
|
|
|
{
|
2023-12-27 21:07:05 +00:00
|
|
|
u8 chksum;
|
2018-11-16 01:43:50 +00:00
|
|
|
|
2023-12-27 21:07:05 +00:00
|
|
|
chksum = table_compute_checksum(hdr, hdr->alloced);
|
|
|
|
chksum += hdr->chksum;
|
2018-11-16 01:43:50 +00:00
|
|
|
|
|
|
|
return chksum;
|
|
|
|
}
|
|
|
|
|
|
|
|
int bloblist_new(ulong addr, uint size, uint flags)
|
|
|
|
{
|
|
|
|
struct bloblist_hdr *hdr;
|
|
|
|
|
|
|
|
if (size < sizeof(*hdr))
|
|
|
|
return log_ret(-ENOSPC);
|
|
|
|
if (addr & (BLOBLIST_ALIGN - 1))
|
|
|
|
return log_ret(-EFAULT);
|
|
|
|
hdr = map_sysmem(addr, size);
|
|
|
|
memset(hdr, '\0', sizeof(*hdr));
|
|
|
|
hdr->version = BLOBLIST_VERSION;
|
|
|
|
hdr->hdr_size = sizeof(*hdr);
|
|
|
|
hdr->flags = flags;
|
|
|
|
hdr->magic = BLOBLIST_MAGIC;
|
|
|
|
hdr->size = size;
|
|
|
|
hdr->alloced = hdr->hdr_size;
|
|
|
|
hdr->chksum = 0;
|
|
|
|
gd->bloblist = hdr;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int bloblist_check(ulong addr, uint size)
|
|
|
|
{
|
|
|
|
struct bloblist_hdr *hdr;
|
|
|
|
u32 chksum;
|
|
|
|
|
|
|
|
hdr = map_sysmem(addr, sizeof(*hdr));
|
|
|
|
if (hdr->magic != BLOBLIST_MAGIC)
|
|
|
|
return log_msg_ret("Bad magic", -ENOENT);
|
|
|
|
if (hdr->version != BLOBLIST_VERSION)
|
|
|
|
return log_msg_ret("Bad version", -EPROTONOSUPPORT);
|
|
|
|
if (size && hdr->size != size)
|
|
|
|
return log_msg_ret("Bad size", -EFBIG);
|
|
|
|
chksum = bloblist_calc_chksum(hdr);
|
|
|
|
if (hdr->chksum != chksum) {
|
2022-01-13 02:26:20 +00:00
|
|
|
log_err("Checksum %x != %x\n", hdr->chksum, chksum);
|
2018-11-16 01:43:50 +00:00
|
|
|
return log_msg_ret("Bad checksum", -EIO);
|
|
|
|
}
|
|
|
|
gd->bloblist = hdr;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int bloblist_finish(void)
|
|
|
|
{
|
|
|
|
struct bloblist_hdr *hdr = gd->bloblist;
|
|
|
|
|
|
|
|
hdr->chksum = bloblist_calc_chksum(hdr);
|
2022-01-13 02:26:22 +00:00
|
|
|
log_debug("Finished bloblist size %lx at %lx\n", (ulong)hdr->size,
|
|
|
|
(ulong)map_to_sysmem(hdr));
|
2018-11-16 01:43:50 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2022-01-13 02:26:23 +00:00
|
|
|
ulong bloblist_get_base(void)
|
|
|
|
{
|
|
|
|
return map_to_sysmem(gd->bloblist);
|
|
|
|
}
|
|
|
|
|
|
|
|
ulong bloblist_get_size(void)
|
|
|
|
{
|
|
|
|
struct bloblist_hdr *hdr = gd->bloblist;
|
|
|
|
|
|
|
|
return hdr->size;
|
|
|
|
}
|
|
|
|
|
2020-09-20 00:49:26 +00:00
|
|
|
void bloblist_get_stats(ulong *basep, ulong *sizep, ulong *allocedp)
|
|
|
|
{
|
|
|
|
struct bloblist_hdr *hdr = gd->bloblist;
|
|
|
|
|
|
|
|
*basep = map_to_sysmem(gd->bloblist);
|
|
|
|
*sizep = hdr->size;
|
|
|
|
*allocedp = hdr->alloced;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void show_value(const char *prompt, ulong value)
|
|
|
|
{
|
|
|
|
printf("%s:%*s %-5lx ", prompt, 8 - (int)strlen(prompt), "", value);
|
|
|
|
print_size(value, "\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
void bloblist_show_stats(void)
|
|
|
|
{
|
|
|
|
ulong base, size, alloced;
|
|
|
|
|
|
|
|
bloblist_get_stats(&base, &size, &alloced);
|
|
|
|
printf("base: %lx\n", base);
|
|
|
|
show_value("size", size);
|
|
|
|
show_value("alloced", alloced);
|
|
|
|
show_value("free", size - alloced);
|
|
|
|
}
|
|
|
|
|
|
|
|
void bloblist_show_list(void)
|
|
|
|
{
|
|
|
|
struct bloblist_hdr *hdr = gd->bloblist;
|
|
|
|
struct bloblist_rec *rec;
|
|
|
|
|
2022-01-13 02:26:19 +00:00
|
|
|
printf("%-8s %8s Tag Name\n", "Address", "Size");
|
2020-09-20 00:49:26 +00:00
|
|
|
for (rec = bloblist_first_blob(hdr); rec;
|
|
|
|
rec = bloblist_next_blob(hdr, rec)) {
|
2022-01-13 02:26:19 +00:00
|
|
|
printf("%08lx %8x %4x %s\n",
|
2023-12-27 21:07:03 +00:00
|
|
|
(ulong)map_to_sysmem((void *)rec + rec_hdr_size(rec)),
|
|
|
|
rec->size, rec_tag(rec),
|
|
|
|
bloblist_tag_name(rec_tag(rec)));
|
2020-09-20 00:49:26 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-01-14 03:29:43 +00:00
|
|
|
void bloblist_reloc(void *to, uint to_size, void *from, uint from_size)
|
|
|
|
{
|
|
|
|
struct bloblist_hdr *hdr;
|
|
|
|
|
|
|
|
memcpy(to, from, from_size);
|
|
|
|
hdr = to;
|
|
|
|
hdr->size = to_size;
|
|
|
|
}
|
|
|
|
|
2018-11-16 01:43:50 +00:00
|
|
|
int bloblist_init(void)
|
|
|
|
{
|
2022-01-22 12:07:27 +00:00
|
|
|
bool fixed = IS_ENABLED(CONFIG_BLOBLIST_FIXED);
|
2018-11-16 01:43:50 +00:00
|
|
|
int ret = -ENOENT;
|
2022-01-13 02:26:22 +00:00
|
|
|
ulong addr, size;
|
|
|
|
bool expected;
|
2018-11-16 01:43:50 +00:00
|
|
|
|
|
|
|
/**
|
2022-01-22 12:07:27 +00:00
|
|
|
* We don't expect to find an existing bloblist in the first phase of
|
|
|
|
* U-Boot that runs. Also we have no way to receive the address of an
|
|
|
|
* allocated bloblist from a previous stage, so it must be at a fixed
|
|
|
|
* address.
|
2018-11-16 01:43:50 +00:00
|
|
|
*/
|
2022-01-22 12:07:27 +00:00
|
|
|
expected = fixed && !u_boot_first_phase();
|
2021-01-14 03:29:43 +00:00
|
|
|
if (spl_prev_phase() == PHASE_TPL && !IS_ENABLED(CONFIG_TPL_BLOBLIST))
|
|
|
|
expected = false;
|
2022-01-22 12:07:27 +00:00
|
|
|
if (fixed)
|
|
|
|
addr = IF_ENABLED_INT(CONFIG_BLOBLIST_FIXED,
|
|
|
|
CONFIG_BLOBLIST_ADDR);
|
2022-01-13 02:26:22 +00:00
|
|
|
size = CONFIG_BLOBLIST_SIZE;
|
|
|
|
if (expected) {
|
|
|
|
ret = bloblist_check(addr, size);
|
|
|
|
if (ret) {
|
|
|
|
log_warning("Expected bloblist at %lx not found (err=%d)\n",
|
|
|
|
addr, ret);
|
|
|
|
} else {
|
|
|
|
/* Get the real size, if it is not what we expected */
|
|
|
|
size = gd->bloblist->size;
|
|
|
|
}
|
|
|
|
}
|
2018-11-16 01:43:50 +00:00
|
|
|
if (ret) {
|
2022-01-13 02:26:22 +00:00
|
|
|
if (CONFIG_IS_ENABLED(BLOBLIST_ALLOC)) {
|
|
|
|
void *ptr = memalign(BLOBLIST_ALIGN, size);
|
2021-11-04 03:09:20 +00:00
|
|
|
|
|
|
|
if (!ptr)
|
|
|
|
return log_msg_ret("alloc", -ENOMEM);
|
|
|
|
addr = map_to_sysmem(ptr);
|
2022-01-22 12:07:27 +00:00
|
|
|
} else if (!fixed) {
|
|
|
|
return log_msg_ret("!fixed", ret);
|
2021-11-04 03:09:20 +00:00
|
|
|
}
|
2022-01-13 02:26:22 +00:00
|
|
|
log_debug("Creating new bloblist size %lx at %lx\n", size,
|
|
|
|
addr);
|
|
|
|
ret = bloblist_new(addr, size, 0);
|
2018-11-16 01:43:50 +00:00
|
|
|
} else {
|
2022-01-13 02:26:22 +00:00
|
|
|
log_debug("Found existing bloblist size %lx at %lx\n", size,
|
|
|
|
addr);
|
2018-11-16 01:43:50 +00:00
|
|
|
}
|
2023-09-26 14:14:51 +00:00
|
|
|
if (ret)
|
|
|
|
return log_msg_ret("ini", ret);
|
|
|
|
gd->flags |= GD_FLG_BLOBLIST_READY;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2018-11-16 01:43:50 +00:00
|
|
|
|
2023-09-26 14:14:51 +00:00
|
|
|
int bloblist_maybe_init(void)
|
|
|
|
{
|
|
|
|
if (CONFIG_IS_ENABLED(BLOBLIST) && !(gd->flags & GD_FLG_BLOBLIST_READY))
|
|
|
|
return bloblist_init();
|
|
|
|
|
|
|
|
return 0;
|
2018-11-16 01:43:50 +00:00
|
|
|
}
|