mirror of
https://github.com/AsahiLinux/u-boot
synced 2024-12-16 08:13:17 +00:00
1a4596601f
Signed-off-by: Wolfgang Denk <wd@denx.de> [trini: Fixup common/cmd_io.c] Signed-off-by: Tom Rini <trini@ti.com>
323 lines
7.3 KiB
C
323 lines
7.3 KiB
C
/*
|
|
* Copyright (c) 2011 The Chromium OS Authors. All rights reserved.
|
|
*
|
|
* SPDX-License-Identifier: GPL-2.0+
|
|
*/
|
|
|
|
#include <cbfs.h>
|
|
#include <malloc.h>
|
|
#include <asm/byteorder.h>
|
|
|
|
enum cbfs_result file_cbfs_result;
|
|
|
|
const char *file_cbfs_error(void)
|
|
{
|
|
switch (file_cbfs_result) {
|
|
case CBFS_SUCCESS:
|
|
return "Success";
|
|
case CBFS_NOT_INITIALIZED:
|
|
return "CBFS not initialized";
|
|
case CBFS_BAD_HEADER:
|
|
return "Bad CBFS header";
|
|
case CBFS_BAD_FILE:
|
|
return "Bad CBFS file";
|
|
case CBFS_FILE_NOT_FOUND:
|
|
return "File not found";
|
|
default:
|
|
return "Unknown";
|
|
}
|
|
}
|
|
|
|
|
|
static const u32 good_magic = 0x4f524243;
|
|
static const u8 good_file_magic[] = "LARCHIVE";
|
|
|
|
|
|
static int initialized;
|
|
static struct cbfs_header cbfs_header;
|
|
static struct cbfs_cachenode *file_cache;
|
|
|
|
/* Do endian conversion on the CBFS header structure. */
|
|
static void swap_header(struct cbfs_header *dest, struct cbfs_header *src)
|
|
{
|
|
dest->magic = be32_to_cpu(src->magic);
|
|
dest->version = be32_to_cpu(src->version);
|
|
dest->rom_size = be32_to_cpu(src->rom_size);
|
|
dest->boot_block_size = be32_to_cpu(src->boot_block_size);
|
|
dest->align = be32_to_cpu(src->align);
|
|
dest->offset = be32_to_cpu(src->offset);
|
|
}
|
|
|
|
/* Do endian conversion on a CBFS file header. */
|
|
static void swap_file_header(struct cbfs_fileheader *dest,
|
|
const struct cbfs_fileheader *src)
|
|
{
|
|
memcpy(&dest->magic, &src->magic, sizeof(dest->magic));
|
|
dest->len = be32_to_cpu(src->len);
|
|
dest->type = be32_to_cpu(src->type);
|
|
dest->checksum = be32_to_cpu(src->checksum);
|
|
dest->offset = be32_to_cpu(src->offset);
|
|
}
|
|
|
|
/*
|
|
* Given a starting position in memory, scan forward, bounded by a size, and
|
|
* find the next valid CBFS file. No memory is allocated by this function. The
|
|
* caller is responsible for allocating space for the new file structure.
|
|
*
|
|
* @param start The location in memory to start from.
|
|
* @param size The size of the memory region to search.
|
|
* @param align The alignment boundaries to check on.
|
|
* @param newNode A pointer to the file structure to load.
|
|
* @param used A pointer to the count of of bytes scanned through,
|
|
* including the file if one is found.
|
|
*
|
|
* @return 1 if a file is found, 0 if one isn't.
|
|
*/
|
|
static int file_cbfs_next_file(u8 *start, u32 size, u32 align,
|
|
struct cbfs_cachenode *newNode, u32 *used)
|
|
{
|
|
struct cbfs_fileheader header;
|
|
|
|
*used = 0;
|
|
|
|
while (size >= align) {
|
|
const struct cbfs_fileheader *fileHeader =
|
|
(const struct cbfs_fileheader *)start;
|
|
u32 name_len;
|
|
u32 step;
|
|
|
|
/* Check if there's a file here. */
|
|
if (memcmp(good_file_magic, &(fileHeader->magic),
|
|
sizeof(fileHeader->magic))) {
|
|
*used += align;
|
|
size -= align;
|
|
start += align;
|
|
continue;
|
|
}
|
|
|
|
swap_file_header(&header, fileHeader);
|
|
if (header.offset < sizeof(const struct cbfs_cachenode *) ||
|
|
header.offset > header.len) {
|
|
file_cbfs_result = CBFS_BAD_FILE;
|
|
return -1;
|
|
}
|
|
newNode->next = NULL;
|
|
newNode->type = header.type;
|
|
newNode->data = start + header.offset;
|
|
newNode->data_length = header.len;
|
|
name_len = header.offset - sizeof(struct cbfs_cachenode *);
|
|
newNode->name = (char *)fileHeader +
|
|
sizeof(struct cbfs_cachenode *);
|
|
newNode->name_length = name_len;
|
|
newNode->checksum = header.checksum;
|
|
|
|
step = header.len;
|
|
if (step % align)
|
|
step = step + align - step % align;
|
|
|
|
*used += step;
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* Look through a CBFS instance and copy file metadata into regular memory. */
|
|
static void file_cbfs_fill_cache(u8 *start, u32 size, u32 align)
|
|
{
|
|
struct cbfs_cachenode *cache_node;
|
|
struct cbfs_cachenode *newNode;
|
|
struct cbfs_cachenode **cache_tail = &file_cache;
|
|
|
|
/* Clear out old information. */
|
|
cache_node = file_cache;
|
|
while (cache_node) {
|
|
struct cbfs_cachenode *oldNode = cache_node;
|
|
cache_node = cache_node->next;
|
|
free(oldNode);
|
|
}
|
|
file_cache = NULL;
|
|
|
|
while (size >= align) {
|
|
int result;
|
|
u32 used;
|
|
|
|
newNode = (struct cbfs_cachenode *)
|
|
malloc(sizeof(struct cbfs_cachenode));
|
|
result = file_cbfs_next_file(start, size, align,
|
|
newNode, &used);
|
|
|
|
if (result < 0) {
|
|
free(newNode);
|
|
return;
|
|
} else if (result == 0) {
|
|
free(newNode);
|
|
break;
|
|
}
|
|
*cache_tail = newNode;
|
|
cache_tail = &newNode->next;
|
|
|
|
size -= used;
|
|
start += used;
|
|
}
|
|
file_cbfs_result = CBFS_SUCCESS;
|
|
}
|
|
|
|
/* Get the CBFS header out of the ROM and do endian conversion. */
|
|
static int file_cbfs_load_header(uintptr_t end_of_rom,
|
|
struct cbfs_header *header)
|
|
{
|
|
struct cbfs_header *header_in_rom;
|
|
|
|
header_in_rom = (struct cbfs_header *)(uintptr_t)
|
|
*(u32 *)(end_of_rom - 3);
|
|
swap_header(header, header_in_rom);
|
|
|
|
if (header->magic != good_magic || header->offset >
|
|
header->rom_size - header->boot_block_size) {
|
|
file_cbfs_result = CBFS_BAD_HEADER;
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void file_cbfs_init(uintptr_t end_of_rom)
|
|
{
|
|
u8 *start_of_rom;
|
|
initialized = 0;
|
|
|
|
if (file_cbfs_load_header(end_of_rom, &cbfs_header))
|
|
return;
|
|
|
|
start_of_rom = (u8 *)(end_of_rom + 1 - cbfs_header.rom_size);
|
|
|
|
file_cbfs_fill_cache(start_of_rom + cbfs_header.offset,
|
|
cbfs_header.rom_size, cbfs_header.align);
|
|
if (file_cbfs_result == CBFS_SUCCESS)
|
|
initialized = 1;
|
|
}
|
|
|
|
const struct cbfs_header *file_cbfs_get_header(void)
|
|
{
|
|
if (initialized) {
|
|
file_cbfs_result = CBFS_SUCCESS;
|
|
return &cbfs_header;
|
|
} else {
|
|
file_cbfs_result = CBFS_NOT_INITIALIZED;
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
const struct cbfs_cachenode *file_cbfs_get_first(void)
|
|
{
|
|
if (!initialized) {
|
|
file_cbfs_result = CBFS_NOT_INITIALIZED;
|
|
return NULL;
|
|
} else {
|
|
file_cbfs_result = CBFS_SUCCESS;
|
|
return file_cache;
|
|
}
|
|
}
|
|
|
|
void file_cbfs_get_next(const struct cbfs_cachenode **file)
|
|
{
|
|
if (!initialized) {
|
|
file_cbfs_result = CBFS_NOT_INITIALIZED;
|
|
file = NULL;
|
|
return;
|
|
}
|
|
|
|
if (*file)
|
|
*file = (*file)->next;
|
|
file_cbfs_result = CBFS_SUCCESS;
|
|
}
|
|
|
|
const struct cbfs_cachenode *file_cbfs_find(const char *name)
|
|
{
|
|
struct cbfs_cachenode *cache_node = file_cache;
|
|
|
|
if (!initialized) {
|
|
file_cbfs_result = CBFS_NOT_INITIALIZED;
|
|
return NULL;
|
|
}
|
|
|
|
while (cache_node) {
|
|
if (!strcmp(name, cache_node->name))
|
|
break;
|
|
cache_node = cache_node->next;
|
|
}
|
|
if (!cache_node)
|
|
file_cbfs_result = CBFS_FILE_NOT_FOUND;
|
|
else
|
|
file_cbfs_result = CBFS_SUCCESS;
|
|
|
|
return cache_node;
|
|
}
|
|
|
|
const struct cbfs_cachenode *file_cbfs_find_uncached(uintptr_t end_of_rom,
|
|
const char *name)
|
|
{
|
|
u8 *start;
|
|
u32 size;
|
|
u32 align;
|
|
static struct cbfs_cachenode node;
|
|
|
|
if (file_cbfs_load_header(end_of_rom, &cbfs_header))
|
|
return NULL;
|
|
|
|
start = (u8 *)(end_of_rom + 1 - cbfs_header.rom_size);
|
|
size = cbfs_header.rom_size;
|
|
align = cbfs_header.align;
|
|
|
|
while (size >= align) {
|
|
int result;
|
|
u32 used;
|
|
|
|
result = file_cbfs_next_file(start, size, align, &node, &used);
|
|
|
|
if (result < 0)
|
|
return NULL;
|
|
else if (result == 0)
|
|
break;
|
|
|
|
if (!strcmp(name, node.name))
|
|
return &node;
|
|
|
|
size -= used;
|
|
start += used;
|
|
}
|
|
file_cbfs_result = CBFS_FILE_NOT_FOUND;
|
|
return NULL;
|
|
}
|
|
|
|
const char *file_cbfs_name(const struct cbfs_cachenode *file)
|
|
{
|
|
file_cbfs_result = CBFS_SUCCESS;
|
|
return file->name;
|
|
}
|
|
|
|
u32 file_cbfs_size(const struct cbfs_cachenode *file)
|
|
{
|
|
file_cbfs_result = CBFS_SUCCESS;
|
|
return file->data_length;
|
|
}
|
|
|
|
u32 file_cbfs_type(const struct cbfs_cachenode *file)
|
|
{
|
|
file_cbfs_result = CBFS_SUCCESS;
|
|
return file->type;
|
|
}
|
|
|
|
long file_cbfs_read(const struct cbfs_cachenode *file, void *buffer,
|
|
unsigned long maxsize)
|
|
{
|
|
u32 size;
|
|
|
|
size = file->data_length;
|
|
if (maxsize && size > maxsize)
|
|
size = maxsize;
|
|
|
|
memcpy(buffer, file->data, size);
|
|
|
|
file_cbfs_result = CBFS_SUCCESS;
|
|
return size;
|
|
}
|